Struct inari::Interval

#[repr(C)]
pub struct Interval { /* fields omitted */ }

An interval with f64 bounds.

It is sometimes referred to as a bare interval in contrast to a decorated interval (DecInterval).

Implementations

impl Interval

pub fn abs(self) -> Self

Returns the absolute value of self.

Tightness: tightest

pub fn max(self, rhs: Self) -> Self

Returns the maximum of self and rhs.

Tightness: tightest

pub fn min(self, rhs: Self) -> Self

Returns the minimum of self and rhs.

Tightness: tightest

impl Interval

pub fn mul_add(self, rhs: Self, addend: Self) -> Self

Returns $(\self × \rhs) + \addend$.

Tightness: tightest

pub fn recip(self) -> Self

Returns the multiplicative inverse of self.

Tightness: tightest

pub fn sqr(self) -> Self

Returns the square of self.

Tightness: tightest

pub fn sqrt(self) -> Self

Returns the principal square root of self.

Tightness: tightest

impl Interval

pub fn contains(self, rhs: f64) -> bool

Returns true if rhs is a member of self: $\rhs ∈ \self$.

The result is false whenever rhs is infinite or NaN.

Examples

use inari::*;
assert!(const_interval!(1.0, 2.0).contains(1.0));
assert!(!Interval::EMPTY.contains(1.0));
assert!(Interval::ENTIRE.contains(1.0));

$±∞$ and NaN are not real numbers, thus do not belong to any interval:

use inari::*;
assert!(!Interval::ENTIRE.contains(f64::INFINITY));
assert!(!Interval::ENTIRE.contains(f64::NEG_INFINITY));
assert!(!Interval::ENTIRE.contains(f64::NAN));

pub fn disjoint(self, rhs: Self) -> bool

Returns true if self and rhs are disjoint:

$$ \self ∩ \rhs = ∅, $$

or equivalently,

$$ ∀x ∈ \self, ∀y ∈ \rhs : x ≠ y, $$

or equivalently,

	$\rhs = ∅$	$\rhs = [c, d]$
$\self = ∅$	true	true
$\self = [a, b]$	true	$b < c ∨ d < a$

Examples

use inari::*;
assert!(const_interval!(1.0, 2.0).disjoint(const_interval!(3.0, 4.0)));
assert!(!const_interval!(1.0, 3.0).disjoint(const_interval!(3.0, 4.0)));
assert!(!const_interval!(1.0, 5.0).disjoint(const_interval!(3.0, 4.0)));
assert!(Interval::EMPTY.disjoint(Interval::EMPTY));
assert!(Interval::EMPTY.disjoint(Interval::ENTIRE));

pub fn interior(self, rhs: Self) -> bool

Returns true if self is interior to rhs:

$$ (∀x ∈ \self, ∃y ∈ \rhs : x < y) ∧ (∀x ∈ \self, ∃y ∈ \rhs : y < x), $$

or equivalently,

	$\rhs = ∅$	$\rhs = [c, d]$
$\self = ∅$	true	true
$\self = [a, b]$	false	$c <′ a ∧ b <′ d$

where $<′$ is defined as:

$$ x <′ y :⟺ x < y ∨ x = y = -∞ ∨ x = y = +∞. $$

Examples

use inari::*;
assert!(const_interval!(1.1, 1.9).interior(const_interval!(1.0, 2.0)));
assert!(!const_interval!(1.1, 2.0).interior(const_interval!(1.0, 2.0)));
assert!(Interval::EMPTY.interior(Interval::EMPTY));
assert!(Interval::ENTIRE.interior(Interval::ENTIRE));

pub fn is_common_interval(self) -> bool

Returns true if self is nonempty and bounded.

Examples

use inari::*;
assert!(const_interval!(1.0, 2.0).is_common_interval());
assert!(!const_interval!(1.0, f64::INFINITY).is_common_interval());
assert!(!Interval::EMPTY.is_common_interval());
assert!(!Interval::ENTIRE.is_common_interval());

pub fn is_empty(self) -> bool

Returns true if self is empty: $\self = ∅$.

Examples

use inari::*;
assert!(!const_interval!(1.0, 1.0).is_empty());
assert!(Interval::EMPTY.is_empty());
assert!(!Interval::ENTIRE.is_empty());

pub fn is_entire(self) -> bool

Returns true if $\self = [-∞, +∞]$.

Examples

use inari::*;
assert!(!const_interval!(1.0, f64::INFINITY).is_entire());
assert!(!Interval::EMPTY.is_entire());
assert!(Interval::ENTIRE.is_entire());

pub fn is_singleton(self) -> bool

Returns true if self consists of a single real number:

$$ ∃x ∈ ℝ : \self = [x, x]. $$

The result is false whenever self is empty or unbounded.

Examples

use inari::*;
assert!(const_interval!(1.0, 1.0).is_singleton());
assert!(!const_interval!(1.0, 2.0).is_singleton());
assert!(!Interval::EMPTY.is_singleton());
assert!(!Interval::ENTIRE.is_singleton());

0.1 is not representable as a f64 number:

use inari::*;
// The singleton interval that consists of the closest [`f64`] number to 0.1.
assert!(const_interval!(0.1, 0.1).is_singleton());
// The tightest interval that encloses 0.1.
#[cfg(feature = "gmp")]
assert!(!interval!("[0.1, 0.1]").unwrap().is_singleton());

pub fn less(self, rhs: Self) -> bool

Returns true if self is weakly less than rhs:

$$ (∀x ∈ \self, ∃y ∈ \rhs : x ≤ y) ∧ (∀y ∈ \rhs, ∃x ∈ \self : x ≤ y), $$

or equivalently,

	$\rhs = ∅$	$\rhs = [c, d]$
$\self = ∅$	true	false
$\self = [a, b]$	false	$a ≤ c ∧ b ≤ d$

Examples

use inari::*;
assert!(const_interval!(1.0, 2.0).less(const_interval!(3.0, 4.0)));
assert!(const_interval!(1.0, 3.0).less(const_interval!(2.0, 4.0)));
assert!(const_interval!(1.0, 4.0).less(const_interval!(1.0, 4.0)));
assert!(Interval::EMPTY.less(Interval::EMPTY));
assert!(!Interval::EMPTY.less(Interval::ENTIRE));
assert!(!Interval::ENTIRE.less(Interval::EMPTY));
assert!(Interval::ENTIRE.less(Interval::ENTIRE));

pub fn precedes(self, rhs: Self) -> bool

Returns true if self is to the left of rhs but may touch it:

$$ ∀x ∈ \self, ∀y ∈ \rhs : x ≤ y, $$

or equivalently,

	$\rhs = ∅$	$\rhs = [c, d]$
$\self = ∅$	true	true
$\self = [a, b]$	true	$b ≤ c$

Examples

use inari::*;
assert!(const_interval!(1.0, 2.0).precedes(const_interval!(3.0, 4.0)));
assert!(const_interval!(1.0, 3.0).precedes(const_interval!(3.0, 4.0)));
assert!(!const_interval!(1.0, 3.0).precedes(const_interval!(2.0, 4.0)));
assert!(Interval::EMPTY.precedes(Interval::EMPTY));
assert!(Interval::EMPTY.precedes(Interval::ENTIRE));
assert!(Interval::ENTIRE.precedes(Interval::EMPTY));
assert!(!Interval::ENTIRE.precedes(Interval::ENTIRE));

pub fn strict_less(self, rhs: Self) -> bool

Returns true if self is strictly less than rhs:

$$ (∀x ∈ \self, ∃y ∈ \rhs : x < y) ∧ (∀y ∈ \self, ∃x ∈ \rhs : x < y), $$

or equivalently,

	$\rhs = ∅$	$\rhs = [c, d]$
$\self = ∅$	true	false
$\self = [a, b]$	false	$a <′ c ∧ b <′ d$

where $<′$ is defined as:

$$ x <′ y :⟺ x < y ∨ x = y = -∞ ∨ x = y = +∞. $$

Examples

use inari::*;
assert!(const_interval!(1.0, 2.0).strict_less(const_interval!(3.0, 4.0)));
assert!(const_interval!(1.0, 3.0).strict_less(const_interval!(2.0, 4.0)));
assert!(!const_interval!(1.0, 4.0).strict_less(const_interval!(2.0, 4.0)));
assert!(const_interval!(1.0, f64::INFINITY).strict_less(const_interval!(2.0, f64::INFINITY)));
assert!(Interval::EMPTY.strict_less(Interval::EMPTY));
assert!(!Interval::EMPTY.strict_less(Interval::ENTIRE));
assert!(!Interval::ENTIRE.strict_less(Interval::EMPTY));
assert!(Interval::ENTIRE.strict_less(Interval::ENTIRE));

pub fn strict_precedes(self, rhs: Self) -> bool

Returns true if self is strictly to the left of rhs:

$$ ∀x ∈ \self, ∀y ∈ \rhs : x < y, $$

or equivalently,

	$\rhs = ∅$	$\rhs = [c, d]$
$\self = ∅$	true	true
$\self = [a, b]$	true	$b < c$

pub fn subset(self, rhs: Self) -> bool

Returns true if self is a subset of rhs:

$$ \self ⊆ \rhs, $$

or equivalently,

$$ ∀x ∈ \self, ∃y ∈ \rhs : x = y, $$

or equivalently,

	$\rhs = ∅$	$\rhs = [c, d]$
$\self = ∅$	true	true
$\self = [a, b]$	false	$c ≤ a ∧ b ≤ d$

Examples

use inari::*;
assert!(const_interval!(1.0, 2.0).subset(const_interval!(1.0, 2.0)));
assert!(Interval::EMPTY.subset(Interval::EMPTY));
assert!(Interval::EMPTY.subset(Interval::ENTIRE));
assert!(Interval::ENTIRE.subset(Interval::ENTIRE));

impl Interval

pub fn to_be_bytes(self) -> [u8; 16]

Returns the interchange representation of the interval in the big-endian byte order.

pub fn to_le_bytes(self) -> [u8; 16]

Returns the interchange representation of the interval in the little-endian byte order.

pub fn to_ne_bytes(self) -> [u8; 16]

Returns the interchange representation of the interval in the native byte order of the target platform.

pub fn try_from_be_bytes(bytes: [u8; 16]) -> Option<Self>

Creates an interval from its interchange representation in the big-endian byte order.

pub fn try_from_le_bytes(bytes: [u8; 16]) -> Option<Self>

Creates an interval from its interchange representation in the little-endian byte order.

pub fn try_from_ne_bytes(bytes: [u8; 16]) -> Option<Self>

Creates an interval from its interchange representation in the native byte order of the target platform.

impl Interval

pub const EMPTY: Self

$∅$, the empty set.

pub const ENTIRE: Self

$[-∞, +∞]$.

pub const E: Self

The tightest interval enclosing $\e$, the base of natural logarithms.

pub const FRAC_1_PI: Self

The tightest interval enclosing $1 / π$.

pub const FRAC_1_SQRT_2: Self

The tightest interval enclosing $1 / \sqrt{2}$.

pub const FRAC_2_PI: Self

The tightest interval enclosing $2 / π$.

pub const FRAC_2_SQRT_PI: Self

The tightest interval enclosing $2 / \sqrt{π}$.

pub const FRAC_PI_2: Self

The tightest interval enclosing $π / 2$.

pub const FRAC_PI_3: Self

The tightest interval enclosing $π / 3$.

pub const FRAC_PI_4: Self

The tightest interval enclosing $π / 4$.

pub const FRAC_PI_6: Self

The tightest interval enclosing $π / 6$.

pub const FRAC_PI_8: Self

The tightest interval enclosing $π / 8$.

pub const LN_10: Self

The tightest interval enclosing $\ln 10$.

pub const LN_2: Self

The tightest interval enclosing $\ln 2$.

pub const LOG10_2: Self

The tightest interval enclosing $\log_{10} 2$.

pub const LOG10_E: Self

The tightest interval enclosing $\log_{10} \e$.

pub const LOG2_10: Self

The tightest interval enclosing $\log_2 10$.

pub const LOG2_E: Self

The tightest interval enclosing $\log_2 \e$.

pub const PI: Self

The tightest interval enclosing $π$.

pub const SQRT_2: Self

The tightest interval enclosing $\sqrt{2}$.

pub const TAU: Self

The tightest interval enclosing $2 π$.

impl Interval

pub fn acos(self) -> Self

Returns the inverse cosine of self.

Tightness: tightest

pub fn acosh(self) -> Self

Returns the inverse hyperbolic cosine of self.

Tightness: tightest

pub fn asin(self) -> Self

Returns the inverse sine of self.

Tightness: tightest

pub fn asinh(self) -> Self

Returns the inverse hyperbolic sine of self.

Tightness: tightest

pub fn atan(self) -> Self

Returns the inverse tangent of self.

Tightness: tightest

pub fn atan2(self, rhs: Self) -> Self

Returns the angle of the point $(\rhs, \self)$ measured counterclockwise from the positive $x$-axis in the Euclidean plane.

Tightness: tightest

pub fn atanh(self) -> Self

Returns the inverse hyperbolic tangent of self.

Tightness: tightest

pub fn cos(self) -> Self

Returns the cosine of self.

Tightness: tightest

pub fn cosh(self) -> Self

Returns the hyperbolic cosine of self.

Tightness: tightest

pub fn exp(self) -> Self

Returns self raised to the power of $\e$.

Tightness: tightest

pub fn exp10(self) -> Self

Returns self raised to the power of 10.

Tightness: tightest

pub fn exp2(self) -> Self

Returns self raised to the power of 2.

Tightness: tightest

pub fn ln(self) -> Self

Returns the natural logarithm of self.

Tightness: tightest

pub fn log10(self) -> Self

Returns the base-10 logarithm of self.

Tightness: tightest

pub fn log2(self) -> Self

Returns the base-2 logarithm of self.

Tightness: tightest

pub fn pow(self, rhs: Self) -> Self

Returns self raised to the power of rhs.

Tightness: tightest

pub fn pown(self, rhs: i32) -> Self

Returns self raised to the power of rhs.

Tightness: tightest

pub fn sin(self) -> Self

Returns the sine of self.

Tightness: tightest

pub fn sinh(self) -> Self

Returns the hyperbolic sine of self.

Tightness: tightest

pub fn tan(self) -> Self

Returns the tangent of self.

Tightness: tightest

pub fn tanh(self) -> Self

Returns the hyperbolic tangent of self.

Tightness: tightest

impl Interval

pub fn ceil(self) -> Self

Rounds self to the closest integer toward $+∞$.

Tightness: tightest

Examples

use inari::*;
assert_eq!(const_interval!(0.2, 1.2).ceil(), const_interval!(1.0, 2.0));
assert_eq!(const_interval!(0.8, 1.8).ceil(), const_interval!(1.0, 2.0));
assert_eq!(const_interval!(-1.2, -0.2).ceil(), const_interval!(-1.0, 0.0));
assert_eq!(const_interval!(-1.8, -0.8).ceil(), const_interval!(-1.0, 0.0));
assert_eq!(Interval::EMPTY.ceil(), Interval::EMPTY);
assert_eq!(Interval::ENTIRE.ceil(), Interval::ENTIRE);

See also: Interval::floor, Interval::trunc.

pub fn floor(self) -> Self

Rounds self to the closest integer toward $-∞$.

Tightness: tightest

Examples

use inari::*;
assert_eq!(const_interval!(0.2, 1.2).floor(), const_interval!(0.0, 1.0));
assert_eq!(const_interval!(0.8, 1.8).floor(), const_interval!(0.0, 1.0));
assert_eq!(const_interval!(-1.2, -0.2).floor(), const_interval!(-2.0, -1.0));
assert_eq!(const_interval!(-1.8, -0.8).floor(), const_interval!(-2.0, -1.0));
assert_eq!(Interval::EMPTY.floor(), Interval::EMPTY);
assert_eq!(Interval::ENTIRE.floor(), Interval::ENTIRE);

See also: Interval::ceil, Interval::trunc.

pub fn round(self) -> Self

Rounds self to the closest integer, away from zero in case of ties.

Tightness: tightest

Examples

use inari::*;
assert_eq!(const_interval!(0.2, 1.2).round(), const_interval!(0.0, 1.0));
assert_eq!(const_interval!(0.5, 1.5).round(), const_interval!(1.0, 2.0));
assert_eq!(const_interval!(0.8, 1.8).round(), const_interval!(1.0, 2.0));
assert_eq!(const_interval!(-1.2, -0.2).round(), const_interval!(-1.0, 0.0));
assert_eq!(const_interval!(-1.5, -0.5).round(), const_interval!(-2.0, -1.0));
assert_eq!(const_interval!(-1.8, -0.8).round(), const_interval!(-2.0, -1.0));
assert_eq!(Interval::EMPTY.round(), Interval::EMPTY);
assert_eq!(Interval::ENTIRE.round(), Interval::ENTIRE);

See also: Interval::round_ties_to_even.

pub fn round_ties_to_even(self) -> Self

Rounds self to the closest integer, the even number in case of ties.

Tightness: tightest

Examples

use inari::*;
assert_eq!(const_interval!(0.2, 1.2).round_ties_to_even(), const_interval!(0.0, 1.0));
assert_eq!(const_interval!(0.5, 1.5).round_ties_to_even(), const_interval!(0.0, 2.0));
assert_eq!(const_interval!(0.8, 1.8).round_ties_to_even(), const_interval!(1.0, 2.0));
assert_eq!(const_interval!(-1.2, -0.2).round_ties_to_even(), const_interval!(-1.0, 0.0));
assert_eq!(const_interval!(-1.5, -0.5).round_ties_to_even(), const_interval!(-2.0, 0.0));
assert_eq!(const_interval!(-1.8, -0.8).round_ties_to_even(), const_interval!(-2.0, -1.0));
assert_eq!(Interval::EMPTY.round_ties_to_even(), Interval::EMPTY);
assert_eq!(Interval::ENTIRE.round_ties_to_even(), Interval::ENTIRE);

See also: Interval::round.

pub fn sign(self) -> Self

Returns the sign of self.

Note the difference in definition between f64::signum and this function; +0.0_f64.signum() and -0.0_f64.signum() return +1.0 and -1.0, respectively, while the sign of zero is just zero,

Tightness: tightest

Examples

use inari::*;
assert_eq!(const_interval!(-10.0, -0.1).sign(), const_interval!(-1.0, -1.0));
assert_eq!(const_interval!(0.0, 0.0).sign(), const_interval!(0.0, 0.0));
assert_eq!(const_interval!(0.1, 10.0).sign(), const_interval!(1.0, 1.0));
assert_eq!(Interval::EMPTY.sign(), Interval::EMPTY);
assert_eq!(Interval::ENTIRE.sign(), const_interval!(-1.0, 1.0));

pub fn trunc(self) -> Self

Rounds self to the closest integer toward zero.

Tightness: tightest

Examples

use inari::*;
assert_eq!(const_interval!(0.2, 1.2).trunc(), const_interval!(0.0, 1.0));
assert_eq!(const_interval!(0.8, 1.8).trunc(), const_interval!(0.0, 1.0));
assert_eq!(const_interval!(-1.2, -0.2).trunc(), const_interval!(-1.0, 0.0));
assert_eq!(const_interval!(-1.8, -0.8).trunc(), const_interval!(-1.0, 0.0));
assert_eq!(Interval::EMPTY.trunc(), Interval::EMPTY);
assert_eq!(Interval::ENTIRE.trunc(), Interval::ENTIRE);

See also: Interval::ceil, Interval::floor.

impl Interval

pub fn inf(self) -> f64

Returns the lower bound of self.

The lower bound of an interval $𝒙$ is:

$$ \inf(𝒙) = \begin{cases} +∞ & \if 𝒙 = ∅, \\ a & \if 𝒙 = [a, b]. \end{cases} $$

The exact value is returned.

Examples

use inari::*;
assert_eq!(const_interval!(-2.0, 3.0).inf(), -2.0);
assert_eq!(Interval::EMPTY.inf(), f64::INFINITY);
assert_eq!(Interval::ENTIRE.inf(), f64::NEG_INFINITY);

See also: Interval::sup.

pub fn mag(self) -> f64

Returns the magnitude of self if it is nonempty; otherwise, a NaN.

The magnitude of a nonempty interval $𝒙 = [a, b]$ is:

$$ \begin{align*} \mag(𝒙) &= \sup \set{|x| ∣ x ∈ 𝒙} \\ &= \max \set{|a|, |b|}. \end{align*} $$

The exact value is returned.

Examples

use inari::*;
assert_eq!(const_interval!(-2.0, 3.0).mag(), 3.0);
assert!(Interval::EMPTY.mag().is_nan());
assert_eq!(Interval::ENTIRE.mag(), f64::INFINITY);

See also: Interval::mig.

pub fn mid(self) -> f64

Returns the midpoint of self if it is nonempty; otherwise, a NaN.

The midpoint of a nonempty interval $𝒙 = [a, b]$ is:

$$ \mid(𝒙) = \frac{a + b}{2}. $$

As an approximation in f64, it returns:

• 0.0, if $\self = [-∞, +∞]$;
• f64::MIN, if $\self = [-∞, b]$, where $b ∈ \R$;
• f64::MAX, if $\self = [a, +∞]$, where $a ∈ \R$;
• otherwise, the closest f64 number to $\mid(\self)$, away from zero in case of ties.

Examples

use inari::*;
assert_eq!(const_interval!(-2.0, 3.0).mid(), 0.5);
assert_eq!(const_interval!(f64::NEG_INFINITY, 3.0).mid(), f64::MIN);
assert_eq!(const_interval!(-2.0, f64::INFINITY).mid(), f64::MAX);
assert!(Interval::EMPTY.mid().is_nan());
assert_eq!(Interval::ENTIRE.mid(), 0.0);

See also: Interval::rad.

pub fn mig(self) -> f64

Returns the mignitude of self if it is nonempty; otherwise, a NaN.

The mignitude of a nonempty interval $𝒙 = [a, b]$ is:

$$ \begin{align*} \mig(𝒙) &= \inf \set{|x| ∣ x ∈ 𝒙} \\ &= \begin{cases} \min \set{|a|, |b|} & \if \sgn(a) = \sgn(b), \\ 0 & \otherwise. \end{cases} \end{align*} $$

The exact value is returned.

Examples

use inari::*;
assert_eq!(const_interval!(-2.0, 3.0).mig(), 0.0);
assert_eq!(const_interval!(2.0, 3.0).mig(), 2.0);
assert!(Interval::EMPTY.mig().is_nan());
assert_eq!(Interval::ENTIRE.mig(), 0.0);

See also: Interval::mag.

pub fn rad(self) -> f64

Returns the radius of self if it is nonempty; otherwise, a NaN.

The radius of a nonempty interval $𝒙 = [a, b]$ is:

$$ \rad(𝒙) = \frac{b - a}{2}. $$

As an approximation in f64, it returns the least f64 number r that satisfies $\self ⊆ [𝚖 - 𝚛, 𝚖 + 𝚛]$, where m is the midpoint returned by Self::mid.

Examples

use inari::*;
assert_eq!(const_interval!(-2.0, 3.0).rad(), 2.5);
assert!(Interval::EMPTY.rad().is_nan());
assert_eq!(Interval::ENTIRE.rad(), f64::INFINITY);

See also: Interval::mid.

pub fn sup(self) -> f64

Returns the upper bound of self.

The upper bound of an interval $𝒙$ is:

$$ \sup(𝒙) = \begin{cases} -∞ & \if 𝒙 = ∅, \\ b & \if 𝒙 = [a, b]. \end{cases} $$

The exact value is returned.

Examples

use inari::*;
assert_eq!(const_interval!(-2.0, 3.0).sup(), 3.0);
assert_eq!(Interval::EMPTY.sup(), f64::NEG_INFINITY);
assert_eq!(Interval::ENTIRE.sup(), f64::INFINITY);

See also: Interval::inf.

pub fn wid(self) -> f64

Returns the width of self if it is nonempty; otherwise, a NaN.

The width of a nonempty interval $𝒙 = [a, b]$ is:

$$ \wid(𝒙) = b - a. $$

As an approximation in f64, it returns the closest f64 number toward $+∞$.

Examples

use inari::*;
assert_eq!(const_interval!(-2.0, 3.0).wid(), 5.0);
assert_eq!(const_interval!(-1.0, f64::MAX).wid(), f64::INFINITY);
assert!(Interval::EMPTY.wid().is_nan());
assert_eq!(Interval::ENTIRE.wid(), f64::INFINITY);

impl Interval

pub fn overlap(self, rhs: Self) -> Overlap

Returns the overlapping state of self and rhs. See Overlap for the possible states to be returned.

impl Interval

pub fn convex_hull(self, rhs: Self) -> Self

Returns $\hull(\self ∪ \rhs)$, the tightest interval that contains both self and rhs as its subsets.

	$\rhs = ∅$	$\rhs = [c, d]$
$\self = ∅$	$∅$	$[c, d]$
$\self = [a, b]$	$[a, b]$	$[\min \set{a, c}, \max \set{b, d}]$

Tightness: tightest

pub fn intersection(self, rhs: Self) -> Self

Returns $\self ∩ \rhs$, the intersection of self and rhs.

	$\rhs = ∅$	$\rhs = [c, d]$
$\self = ∅$	$∅$	$∅$
$\self = [a, b]$	$∅$	$[\max \set{a, c}, \min \set{b, d}]$

Tightness: tightest

Trait Implementations

impl Add<Interval> for Interval

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

Tightness: tightest

type Output = Self

The resulting type after applying the + operator.

impl AddAssign<Interval> for Interval

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Interval

fn clone(&self) -> Interval

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Interval

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

Formats the value using the given formatter.

impl Display for Interval

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

Formats the value using the given formatter.

impl Div<Interval> for Interval

fn div(self, rhs: Self) -> Self

Tightness: tightest

type Output = Self

The resulting type after applying the / operator.

impl DivAssign<Interval> for Interval

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl FromStr for Interval

type Err = IntervalError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self>

Parses a string s to return a value of this type.

impl Hash for Interval

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, 

Feeds a slice of this type into the given Hasher.

impl LowerExp for Interval

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

Formats the value using the given formatter.

impl LowerHex for Interval

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

Formats the value using the given formatter.

impl Mul<Interval> for Interval

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

Tightness: tightest

type Output = Self

The resulting type after applying the * operator.

impl MulAssign<Interval> for Interval

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for Interval

fn neg(self) -> Self

Tightness: tightest

type Output = Self

The resulting type after applying the - operator.

impl PartialEq<Interval> for Interval

fn eq(&self, rhs: &Self) -> 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 !=.

impl Sub<Interval> for Interval

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

Tightness: tightest

type Output = Self

The resulting type after applying the - operator.

impl SubAssign<Interval> for Interval

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl TryFrom<(f64, f64)> for Interval

type Error = IntervalError

The type returned in the event of a conversion error.

fn try_from((a, b): (f64, f64)) -> Result<Self>

Performs the conversion.

impl Copy for Interval

impl Eq for Interval