Enum stats_ci::Interval

pub enum Interval<T> {
    Empty,
    Degenerate(T),
    Concrete {
        left: T,
        right: T,
    },
}

Interval over a partially ordered type (NB: floating point numbers are partially ordered because of NaN). The interval is defined by its lower and upper bounds.

Examples

let interval = Interval::new(0., 1.);
assert_eq!(interval.low().unwrap(), 0.);
assert_eq!(interval.high().unwrap(), 1.);
assert!(!interval.is_empty());
assert!(!interval.is_degenerate());
assert!(interval.is_concrete());
assert!(interval.contains(&0.5));
assert!(!interval.contains(&2.));

let interval2: Interval<_> = Interval::from(0..=10);
assert_eq!(interval2.low().unwrap(), 0);
assert_eq!(interval2.high().unwrap(), 10);

Variants

Empty

Degenerate(T)

Concrete

Fields

left: T

right: T

Implementations

impl<T: PartialOrd> Interval<T>

pub fn new(low: T, high: T) -> Self

Create a new interval from its left and right bounds for ordered types with equality.

Examples

let interval = Interval::new(0., 1.);
assert_eq!(interval.low().unwrap(), 0.);
assert_eq!(interval.high().unwrap(), 1.);
assert!(!interval.is_empty());
let interval2 = Interval::new("A", "Z");
assert_eq!(interval2.low().unwrap(), "A");
assert_eq!(interval2.high().unwrap(), "Z");
let interval3 = Interval::new(0, 0_usize);
assert_eq!(interval3.low().unwrap(), 0);
assert_eq!(interval3.high().unwrap(), 0);
assert!(interval3.is_degenerate());
let interval4 = Interval::new(1, 0);
assert!(interval4.is_empty());

pub fn contains(&self, x: &T) -> bool

Test whether the interval contains a value.

pub fn intersects(&self, other: &Self) -> bool

Test whether the interval intersects another interval.

pub fn is_included_in(&self, other: &Self) -> bool

Test whether the interval is included in another interval.

The inclusion is not strict, i.e. an interval is included in itself.

pub fn includes(&self, other: &Self) -> bool

Test whether the interval includes another interval.

The inclusion is not strict, i.e. an interval includes itself.

impl<T> Interval<T>

pub fn new_unordered_unchecked(left: T, right: T) -> Self

Create a new interval from its left and right bounds for unordered types. The function is unchecked and always results in a concrete interval. NB: this function is not meant for ordered types; in particular for numerical types.

Examples

#[derive(Debug)]
enum Directions { North, South, East, West};
let interval = Interval::new_unordered_unchecked(Directions::North, Directions::West);
assert!(matches!(interval.left().unwrap(), Directions::North));
assert!(matches!(interval.right().unwrap(), Directions::West));
assert!(!interval.is_empty());
assert!(!interval.is_degenerate());
assert!(interval.is_concrete());
let interval = Interval::new_unordered_unchecked(Directions::North, Directions::North);
// NB: the interval is not degenerate because the bounds equality is not checked
assert!(!interval.is_degenerate());

pub fn is_empty(&self) -> bool

Test if the interval is empty.

pub fn is_degenerate(&self) -> bool

Test if the interval is degenerate, in the sense that it contains a single element.

pub fn is_concrete(&self) -> bool

Test if the interval is concrete, in the sense that it contains at least two elements.

pub fn left(&self) -> Option<&T>

Get the left bound of the interval (if any).

pub fn right(&self) -> Option<&T>

Get the right bound of the interval (if any).

impl<T: PartialOrd + Clone> Interval<T>

pub fn low(&self) -> Option<T>

Get the lower bound of the interval (if any) for partially ordered types.

This function clones the bound. If cloning is an issue, use Self::low_as_ref() instead.

pub fn high(&self) -> Option<T>

Get the upper bound of the interval (if any) for partially ordered types.

This function clones the bound. If cloning is an issue, use Self::high_as_ref() instead.

impl<T: PartialOrd> Interval<T>

pub fn low_as_ref(&self) -> Option<&T>

Get a reference to the lower bound of the interval (if any) for ordered types.

See also Self::low() if cloning is not an issue.

pub fn high_as_ref(&self) -> Option<&T>

Get a reference to the upper bound of the interval (if any) for ordered types.

See also Self::high() if cloning is not an issue.

impl<T: PartialEq> Interval<T>

pub fn new_unordered(left: T, right: T) -> Self

Create a new interval from its left and right bounds for unordered types with equality.

Examples

#[derive(Debug, PartialEq)]
enum Directions { North, South, East, West};
let interval = Interval::new_unordered(Directions::North, Directions::West);
assert_eq!(interval.left().unwrap(), &Directions::North);
assert_eq!(interval.right().unwrap(), &Directions::West);
assert!(!interval.is_empty());
assert!(!interval.is_degenerate());
assert!(interval.is_concrete());
let interval = Interval::new_unordered(Directions::North, Directions::North);
assert!(interval.is_degenerate());

impl<T: Sub<Output = T> + Zero + Clone> Interval<T>

pub fn width(&self) -> Option<T>

Trait Implementations

impl<T> AsRef<Interval<T>> for Interval<T>

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone> Clone for Interval<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Interval<T>

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

Formats the value using the given formatter.

impl<T> Default for Interval<T>

fn default() -> Interval<T>

Returns the “default value” for a type.

impl<T: Display> Display for Interval<T>

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

Formats the value using the given formatter.

impl<T: PartialOrd> From<(Option<T>, Option<T>)> for Interval<T>

fn from((low, high): (Option<T>, Option<T>)) -> Self

Converts to this type from the input type.

impl<T: PartialOrd> From<(T, T)> for Interval<T>

fn from((low, high): (T, T)) -> Self

Converts to this type from the input type.

impl<T: PartialOrd + Clone> From<Interval<T>> for (Option<T>, Option<T>)

fn from(interval: Interval<T>) -> Self

Converts to this type from the input type.

impl<T: PartialOrd + Clone> From<Interval<T>> for Option<(T, T)>

fn from(interval: Interval<T>) -> Self

Converts to this type from the input type.

impl<T: Ord> From<RangeInclusive<T>> for Interval<T>

fn from(range: RangeInclusive<T>) -> Self

Converts to this type from the input type.

impl<T: Hash> Hash for Interval<T>

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<T: PartialEq> PartialEq<Interval<T>> for Interval<T>

fn eq(&self, other: &Interval<T>) -> 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<T: PartialOrd> PartialOrd<Interval<T>> for Interval<T>

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

compare two intervals. given two intervals a and b, a < b if and only if the upper bound of a is less than the lower bound of b. recall that interval bounds are assumed inclusive.

Examples

let a = Interval::new(0, 10);
let b = Interval::new(10, 20);
let c = Interval::new(11, 20);
let d = Interval::new(0, 10);
assert_eq!(a.partial_cmp(&b), None);
assert_eq!(a.partial_cmp(&c), Some(Ordering::Less));
assert_eq!(c.partial_cmp(&a), Some(Ordering::Greater));
assert_eq!(a.partial_cmp(&d), Some(Ordering::Equal));

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<T: PartialOrd> RangeBounds<T> for Interval<T>

fn start_bound(&self) -> Bound<&T>

Start index bound.

fn end_bound(&self) -> Bound<&T>

End index bound.

fn contains<U>(&self, item: &U) -> boolwhere T: PartialOrd<U>, U: PartialOrd<T> + ?Sized,

Returns true if item is contained in the range.

impl<T: Copy> Copy for Interval<T>

impl<T> StructuralPartialEq for Interval<T>