Struct Interval 

pub struct Interval<T> {
    pub lower: T,
    pub upper: T,
    pub kind: IntervalKind,
}

The interval between lower and upper, with the endpoints included or excluded according to kind.

use symplex::{Interval, IntervalKind};

let ci = Interval::closed(0.108_f64, 0.603);
assert!(ci.contains(&0.3) && ci.contains(&0.603));
assert!((ci.width() - 0.495).abs() < 1e-12);
assert_eq!(ci.to_string(), "[0.108, 0.603]");

let iso = Interval::left_open(1, 2); // (1, 2]
assert!(!iso.contains(&1) && iso.contains(&2));
assert_eq!(iso.kind, IntervalKind::LeftOpen);
assert_eq!(iso.to_string(), "(1, 2]");

// Range syntax: `a..=b` is `[a, b]`, `a..b` is `[a, b)`.
assert_eq!(Interval::from(0.0..=1.0), Interval::closed(0.0, 1.0));
assert_eq!(Interval::from(0..5), Interval::right_open(0, 5));

assert!(Interval::open(3, 3).is_empty() && !Interval::closed(3, 3).is_empty());

Fields

lower: T

The lower endpoint.

upper: T

The upper endpoint.

kind: IntervalKind

Which endpoints belong to the interval.

Implementations

impl Interval<Ex>

pub fn to_set(&self) -> SetEx

The interval as a set expression, in the lower endpoint’s context; the inverse of SetEx::as_intervals on one piece.

Examples

use symplex::prelude::*;

let ctx = Context::new();
let iv = Interval::left_open(ctx.int(0), ctx.int(1)); // (0, 1]
assert_eq!(format!("{}", iv.to_set()), "(0, 1]");
assert_eq!(iv.to_set(), ctx.interval(&ctx.int(0), &ctx.int(1), IntervalKind::LeftOpen));

pub fn contains(&self, x: &Ex) -> Option<bool>

Is x in the interval? Ex has no order, so this goes through the set layer and is three-valued: None when the comparison with an endpoint cannot be decided symbolically.

use symplex::prelude::*;

let ctx = Context::new();
let iv = Interval::left_open(ctx.int(0), ctx.int(1)); // (0, 1]
assert_eq!(iv.contains(&ctx.rational(1, 2)), Some(true));
assert_eq!(iv.contains(&ctx.int(0)), Some(false));
assert_eq!(iv.contains(&ctx.int(1)), Some(true));
assert_eq!(iv.contains(&ctx.symbol("t")), None);

pub fn is_empty(&self) -> Option<bool>

Is the interval known to be empty? Three-valued like contains.

impl<T> Interval<Extended<T>>

pub const fn is_bounded(&self) -> bool

Are both endpoints finite? [0, ∞) is not; [0, 1] is. (The kind is irrelevant: an infinite end is unbounded whether the interval is written closed or open there.)

impl<T> Interval<T>

pub const fn closed(lower: T, upper: T) -> Self

[lower, upper].

pub const fn open(lower: T, upper: T) -> Self

(lower, upper).

pub const fn left_open(lower: T, upper: T) -> Self

(lower, upper].

pub const fn right_open(lower: T, upper: T) -> Self

[lower, upper).

pub fn point(value: T) -> Self

where T: Clone,

The singleton [value, value].

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

Apply f to both endpoints, keeping the kind. (For a decreasing f the caller must also swap the endpoints and reversed the kind.)

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

Borrow both endpoints.

pub fn with_kind(self, kind: IntervalKind) -> Self

The same endpoints with a different kind.

pub fn reversed(self) -> Self

The image under a decreasing map that has already been applied to the endpoints: swap them and swap the openness with them, so that [a, b) becomes (f(b), f(a)].

pub fn into_pair(self) -> (T, T)

The endpoints as a (lower, upper) tuple, for destructuring: let (lo, hi) = ci.into_pair();. The kind is dropped.

impl<T: Clone> Interval<&T>

pub fn cloned(self) -> Interval<T>

Clone both endpoints.

impl<T: PartialOrd> Interval<T>

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

Is x in the interval (endpoints according to kind)?

pub fn is_ordered(&self) -> bool

lower <= upper (false for NaN endpoints).

pub fn is_empty(&self) -> bool

Does the interval contain no point? [a, a] is the singleton {a}; (a, a), (a, a], [a, a), anything with lower > upper and anything with an unordered (NaN) endpoint are empty. Between distinct endpoints an open interval of a discrete type may still be empty — (1, 2) over the integers — which this does not detect.

pub fn contains_interval(&self, other: &Interval<T>) -> bool

Is every point of other in self? (Empty other counts as contained only when it is a degenerate interval at a point of self; callers who care should test is_empty first.)

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

pub fn intersect(&self, other: &Interval<T>) -> Option<Interval<T>>

The intersection self ∩ other, or None when it is empty. At a shared endpoint the open side wins ([0, 2] ∩ (0, 3) is (0, 2]); when one interval’s upper end meets the other’s lower end the result is the point only if both ends are closed.

pub fn hull(&self, other: &Interval<T>) -> Option<Interval<T>>

The smallest interval containing both ([0, 1) ∪ (2, 3] hulls to [0, 3]). At a shared endpoint the closed side wins. None only when the endpoints cannot be ordered (a NaN endpoint).

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

x moved to the nearest point of a closed interval (x.clamp(lower, upper)); for another kind the nearest point does not exist, so this uses the closure and says so in the name.

impl<T: PartialEq> Interval<T>

pub fn is_point(&self) -> bool

Is this the singleton [a, a]? Structural equality of the endpoints, so it works for Interval<Ex> too.

impl Interval<f64>

pub fn is_finite(&self) -> bool

Are both endpoints finite (neither ±∞ nor NaN)?

pub fn with_infinite_ends_open(self) -> Self

±∞ is not a real number, so an infinite endpoint cannot belong to the interval: this opens any infinite end ([0, ∞] → [0, ∞)), which is what stats::Support and the set layer do. Finite ends are untouched.

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

pub fn width(&self) -> T

upper − lower.

Trait Implementations

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

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

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

Formats the value using the given formatter.

impl<T: Default> Default for Interval<T>

fn default() -> Self

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

impl<T> From<Interval<T>> for Bounds<T>

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

The closure [lower, upper] of the interval (the kind is dropped — constraint boxes are closed).

impl<T> From<Range<T>> for Interval<T>

a..b is [a, b), as in Rust.

fn from(r: Range<T>) -> Self

Converts to this type from the input type.

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

a..=b is [a, b].

fn from(r: 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 for Interval<T>

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

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<T> 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) -> bool

where T: PartialOrd<U>, U: PartialOrd<T> + ?Sized,

Returns true if item is contained in the range.

fn is_empty(&self) -> bool

where T: PartialOrd,

🔬This is a nightly-only experimental API. (range_bounds_is_empty)

Returns true if the range contains no items. One-sided ranges (RangeFrom, etc) always return false.

impl<T: PartialEq> StructuralPartialEq for Interval<T>