Struct Interval 

pub struct Interval<T> {
    pub lb: T,
    pub ub: T,
    pub _marker: PhantomData<T>,
}

A range of values with a lower bound (lb) and an upper bound (ub).

 lb        ub
  |---------|
  *=========*-----> T

An interval is valid when lb <= ub. The is_invalid() method checks for the invalid case lb > ub.

Examples

use physdes::interval::Interval;

let interval = Interval::new(1, 5);
assert_eq!(interval.lb, 1);
assert_eq!(interval.ub, 5);

Fields

lb: T

ub: T

_marker: PhantomData<T>

Implementations

impl<T> Interval<T>

pub const fn new(lb: T, ub: T) -> Self

Creates a new interval with the given lower and upper bounds.

Note: No validity check is performed. An interval where lb > ub is considered invalid and can be checked with is_invalid().

Examples

use physdes::interval::Interval;

let interval = Interval::new(1, 5);
assert_eq!(interval.lb, 1);
assert_eq!(interval.ub, 5);

let interval = Interval::new(5, 1);  // Invalid interval but still created
assert_eq!(interval.lb, 5);
assert_eq!(interval.ub, 1);

impl<T: Copy> Interval<T>

pub const fn lb(&self) -> T

Returns the lower bound.

pub const fn ub(&self) -> T

Returns the upper bound.

impl<T: PartialOrd> Interval<T>

pub fn is_invalid(&self) -> bool

Returns true if the lower bound exceeds the upper bound (invalid interval).

Examples

use physdes::interval::Interval;

let valid_interval = Interval::new(1, 5);
assert!(!valid_interval.is_invalid());

let invalid_interval = Interval::new(5, 1);
assert!(invalid_interval.is_invalid());

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

pub fn length(&self) -> T

Computes the length of the interval: ub - lb.

$$L = ub - lb$$

Examples

use physdes::interval::Interval;

let interval = Interval::new(2, 8);
assert_eq!(interval.length(), 6);

let interval = Interval::new(-3, 5);
assert_eq!(interval.length(), 8);

Trait Implementations

impl<T: Add<Output = T>> Add for Interval<T>

Interval addition (component-wise): $[a,b] + [c,d] = [a+c,; b+d]$

type Output = Interval<T>

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self::Output

Performs the + operation.

impl<T> Add<T> for Interval<T>

where T: Copy + Add<Output = T>,

fn add(self, rhs: T) -> Self::Output

Shift the interval by a scalar: $[a,b] + t = [a+t,; b+t]$

type Output = Interval<T>

The resulting type after applying the + operator.

impl<T> AddAssign<T> for Interval<T>

where T: Copy + AddAssign<T>,

fn add_assign(&mut self, rhs: T)

Shift the interval by a scalar: $[a,b] \mathrel{+}= t \implies [a+t,; b+t]$

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

fn clone(&self) -> Interval<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: PartialOrd> Contain<Interval<T>> for Interval<T>

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

Checks if self entirely contains other: $[a,b] \supseteq [c,d] \iff a \le c \land d \le b$

impl<T: PartialOrd> Contain<T> for Interval<T>

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

Checks if the interval contains a scalar value: $x \in [a,b] \iff a \le x \le b$

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> Displacement<Interval<T>> for Interval<T>

where T: Displacement<T, Output = T>,

fn displace(&self, other: &Interval<T>) -> Self::Output

Computes the component-wise displacement between two intervals.

type Output = Interval<T>

impl<T> Display for Interval<T>

where T: PartialOrd + Copy + Display,

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

Formats the interval as [lb, ub].

impl<T> Enlarge<T> for Interval<T>

where T: Copy + Add<Output = T> + Sub<Output = T>,

fn enlarge_with(&self, alpha: T) -> Self

Enlarges the interval by alpha on both sides: $\text{enlarge}([a,b], \alpha) = [a-\alpha,; b+\alpha]$

type Output = Interval<T>

impl<T: Eq> Eq for Interval<T>

impl<T> Hull<Interval<T>> for Interval<T>

where T: Copy + Ord,

fn hull_with(&self, other: &Interval<T>) -> Self::Output

Computes the hull (bounding interval) of two intervals:

$$\text{hull}([a,b],[c,d]) = [\min(a,c),; \max(b,d)]$$

type Output = Interval<T>

impl<T> Hull<T> for Interval<T>

where T: Copy + Ord,

fn hull_with(&self, other: &T) -> Self::Output

The hull_with function calculates the hull (minimum and maximum values) between two values.

Arguments:

• other: The other parameter is a reference to a value of type T, which is the same type as the values stored in the struct implementing the hull_with method. In this method, the other value is used to update the lower bound (lb) and upper bound (`

type Output = Interval<T>

impl<T> Intersect<Interval<T>> for Interval<T>

where T: Copy + Ord,

fn intersect_with(&self, other: &Interval<T>) -> Self::Output

Computes the intersection of two intervals:

$$\text{intersect}([a,b],[c,d]) = [\max(a,c),; \min(b,d)]$$

type Output = Interval<T>

impl<T> Intersect<T> for Interval<T>

where T: Copy + Ord,

fn intersect_with(&self, other: &T) -> Self::Output

Computes the intersection of an interval and a scalar value.

type Output = Interval<T>

impl MinDist<Interval<i32>> for Interval<i32>

fn min_dist_with(&self, other: &Interval<i32>) -> u32

Computes the minimum distance between two intervals:

$$d = \begin{cases} c-b & \text{if } b < c \ a-d & \text{if } d < a \ 0 & \text{otherwise} \end{cases}$$

impl MinDist<Interval<i32>> for i32

fn min_dist_with(&self, other: &Interval<i32>) -> u32

Computes the minimum distance between a scalar and an interval.

impl MinDist<i32> for Interval<i32>

fn min_dist_with(&self, other: &i32) -> u32

Computes the minimum distance between an interval and a scalar value.

impl<T> Mul<T> for Interval<T>

where T: Copy + Mul<Output = T>,

fn mul(self, rhs: T) -> Self::Output

Scale the interval by a scalar: $[a,b] \cdot t = [a \cdot t,; b \cdot t]$

type Output = Interval<T>

The resulting type after applying the * operator.

impl<T> MulAssign<T> for Interval<T>

where T: Copy + MulAssign<T>,

fn mul_assign(&mut self, rhs: T)

Scale the interval by a scalar: $[a,b] \mathrel{*}= t \implies [a \cdot t,; b \cdot t]$

impl<T> Neg for Interval<T>

where T: Copy + Neg<Output = T>,

Interval negation: $-[a,b] = [-b,; -a]$

type Output = Interval<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: PartialOrd> Overlap<Interval<T>> for Interval<T>

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

Checks if two intervals overlap: $[a,b] \cap [c,d] \neq \varnothing \iff a \le d \land c \le b$

impl<T: PartialOrd> Overlap<T> for Interval<T>

fn overlaps(&self, other: &T) -> bool

Checks if the interval contains a scalar value: $x \in [a,b] \iff a \le x \le b$

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

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd> PartialOrd for Interval<T>

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

Orders intervals by their position: Less if ub < other.lb, Greater if other.ub < self.lb, Equal otherwise.

Examples

use physdes::interval::Interval;
use std::marker::PhantomData;
assert_eq!(Interval::new(1, 2).partial_cmp(&Interval::new(3, 4)), Some(std::cmp::Ordering::Less));

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

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

impl<T: Sub<Output = T>> Sub for Interval<T>

Interval subtraction (component-wise): $[a,b] - [c,d] = [a-c,; b-d]$

type Output = Interval<T>

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self::Output

Performs the - operation.

impl<T> Sub<T> for Interval<T>

where T: Copy + Sub<Output = T>,

fn sub(self, rhs: T) -> Self::Output

Shift the interval by a negative scalar: $[a,b] - t = [a-t,; b-t]$

type Output = Interval<T>

The resulting type after applying the - operator.

impl<T> SubAssign<T> for Interval<T>

where T: Copy + SubAssign<T>,

fn sub_assign(&mut self, rhs: T)

Shift the interval by a negative scalar: $[a,b] \mathrel{-}= t \implies [a-t,; b-t]$