Struct Interval

pub struct Interval<T> {
    pub min: T,
    pub max: T,
}

An interval on the real number line.

Fields

min: T

The smallest value in the interval.

max: T

The largest value in the interval.

Implementations

impl<T> Interval<T>

pub const fn new(min: T, max: T) -> Self

Creates a new interval.

impl<T: PartialOrd> Interval<T>

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

Returns true if this interval overlaps with the other.

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

Returns true if this interval contains the value.

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

pub fn length(&self) -> T

Gets the magnitude of the interval.

impl<T: Copy> Interval<T>

pub fn as_array(&self) -> [T; 2]

Gets the interval as an array.

impl<T: Float> Interval<T>

pub fn disc(centre: T, radius: T) -> Self

Creates an interval with the given centre and radius.

pub fn midpoint(&self) -> T

Returns the centre/mid-point of the interval.

pub fn clearance_with(&self, other: &Self) -> T

Computes the gap between two intervals. Will be negative if the intervals overlap.

pub fn distance(&self, other: T) -> T

Computes the distance between a point and the interval. Will be negative if the point is within the interval.

pub fn lerp(&self, t: T) -> T

Interpolates between the two endpoints of the interval, where t=0 will yield self.min and t=1 will yield self.max.

pub fn inv_lerp(&self, value: T) -> T

Performs the inverse operation of Self::lerp, such that providing an input of self.min will yield 0 and an input of self.max will yield 1.

Trait Implementations

impl<T: Float> Add<T> for Interval<T>

type Output = Interval<T>

The resulting type after applying the + operator.

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

Performs the + operation.

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: 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() -> Interval<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Interval<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Float> Sub<T> for Interval<T>

type Output = Interval<T>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

impl<T> StructuralPartialEq for Interval<T>