Enum Interval

Source

pub enum Interval<T> {
    Empty,
    LessThan(T),
    LessThanOrEqual(T),
    GreaterThanOrEqual(T),
    GreaterThan(T),
    Open((T, T)),
    LeftOpen((T, T)),
    RightOpen((T, T)),
    Closed((T, T)),
    Full,
}

Expand description

Represent the subset of domain values for some T: PartialOrd.

https://en.wikipedia.org/wiki/Interval_(mathematics)

Variants§

§

Empty

The empty set of values.

https://en.wikipedia.org/wiki/Empty_set

§

LessThan(T)

The set of values strictly less than the boundary.

§

LessThanOrEqual(T)

The set of values less or equal than the boundary.

§

GreaterThanOrEqual(T)

The set of values greater or equal than the boundary.

§

GreaterThan(T)

The set of values strictly greater than the boundary.

§

Open((T, T))

The set of values in open range (a, b) (both boundaries are excluded).

§

LeftOpen((T, T))

The set of values in half-open (a, b] range bounded exclusively below and inclusively above.

§

RightOpen((T, T))

The set of values in half-open [a, b) range bounded inclusively below and exclusively above.

§

Closed((T, T))

The set of values in closed range [a, b] (both boundaries are included).

§

Full

Interval containing any value.

https://en.wikipedia.org/wiki/Universe_(mathematics)

Implementations§

Source §

impl<T> Interval<T>

Source

pub fn as_ref_bounds( &self, ) -> Result<(Endpoint<LEFT, &T>, Endpoint<RIGHT, &T>), <Interval<&T> as IntoBounds<&T>>::Error>
where for<'a> Interval<&'a T>: IntoBounds<&'a T>,

Get referenced interval’s bounds.

§Errors

EmptyIntervalError wrapping a reference to itself when the interval is empty.

Source §

impl<T> Interval<T>

Source

pub fn map<U, F>(self, f: F) -> Interval
where F: FnMut(T) -> U,

Apply a transformation to the borders of an Interval, preserving its structure.

Source

pub const fn as_ref(&self) -> Interval<&T>

Get an Interval with referenced bound values.

Source

pub fn reverse(self) -> Self

Swap the Interval’s bounds.

Source

pub fn into_closure(self) -> Self

Transform the Interval into a closed one by augmenting it with its endpoints.

Source

pub fn into_interior(self) -> Self
where Self: Bounded<T> + SingletonBounds<T>,

Transform the Interval into an open one by excluding its endpoint values.

Source

pub fn reduce(self) -> Self
where T: PartialOrd,

Reduce the Interval to its minimal form.

assert_eq!(Interval::Open((5, 5)).reduce(), Interval::Empty);
assert_eq!(Interval::Closed((5, 5)).reduce(), Interval::singleton(5));
assert_eq!(Interval::Closed((7, 5)).reduce(), Interval::Empty);

Source

pub fn is_empty(&self) -> bool
where T: PartialOrd,

Whether the Interval contains no valid values, i.e. is Self::Empty or have invalid bounds (a > b).

assert!(Interval::<u32>::Empty.is_empty());
assert!(interval!((5, 5)).is_empty());
assert!(!interval!([5, 5]).is_empty());
assert!(interval!([7, 5]).is_empty());

Source

pub const fn is_full(&self) -> bool

Whether the Interval contains every possible value.

Source

pub fn contains(&self, point: &U) -> bool
where T: PartialOrd + PartialOrd, U: ?Sized + PartialOrd<T>,

Whether the Interval contains a given point.

Source

pub fn len(&self) -> Size<<T as Sub>::Output>
where T: Clone + PartialOrd + Sub,

Returns the length of the Interval if both bounds are finite.

assert_eq!(interval!(0: u8).len().into_diff().unwrap(), 0);
assert!(interval!(< 5).len().into_diff().is_none());
assert!(interval!(<= 3.2).len().into_diff().is_none());
assert!(interval!(> -10).len().into_diff().is_none());
assert!(interval!(>= 0u32).len().into_diff().is_none());
assert_eq!(interval!(= 42).len().into_diff().unwrap(), 0);
assert_eq!(interval!(== 42).len().into_diff().unwrap(), 0);

assert_eq!(interval!((1, 10)).len().into_diff().unwrap(), 9);
assert_eq!(interval!((0, =100)).len().into_diff().unwrap(), 100);
assert_eq!(interval!((=0, 100)).len().into_diff().unwrap(), 100);
assert_eq!(interval!((=6, 5)).len().into_diff().unwrap(), 0);
assert_eq!(interval!([0.0, 1.0]).len().into_diff().unwrap(), 1.0);
assert_eq!(interval!([5.0, 1.0]).len().into_diff().unwrap(), 0.0);
assert_eq!(interval!((=0.0, =1.0)).len().into_diff().unwrap(), 1.0);
assert!(interval!(U: i32).len().into_diff().is_none());

Source

pub fn clamp(&self, x: T) -> Result<(Ordering, T), T>
where T: Clone + PartialOrd,

Restrict a given value to the Interval.

§Returns

Ok((Less, upper)) if the resulted value should be less than the upper;
Ok((Equal, x)) if the resulted value is exactly x;
Ok((Greater, lower)) if the resulted value should be greater than the lower.

§Errors

Returns wrapped original value if the interval is empty;

Source §

impl<T> Interval<T>

Source

pub fn point_cmp(&self, point: &T) -> Option<Ordering>
where T: PartialOrd,

Whether the given point lies completely to the left/right of the interval, or maybe completely matches it (in a singleton case).

This should be an impl of PartialOrd<T> for Interval<T>, but this would require an impl of PartialEq<T> for Interval<T>, which does not make much sense.

Even worse, multiple existing implementations of PartialEq for Interval<T> breaks the type inference system in expressions like interval < interval_like.into(). This lowers much of ergonomics of using compare operators.

Source §

impl<T> Interval<T>
where Self: Bounded<T>,

Source

pub fn complement(self) -> OneOrPair<Self>

Compute the complement of this interval.

If the Interval has two endpoints, the complement will be represented as a pair of intervals (one to the left of the start, one to the right of the end).