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 $[\max(a, c), \max(b, d)]$ if both $\self = [a, b]$ and $\rhs = [c, d]$ are nonempty; otherwise, $∅$.

Tightness: tightest

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

Returns $[\min(a, c), \min(b, d)]$ if both $\self = [a, b]$ and $\rhs = [c, d]$ are nonempty; otherwise $∅$.

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$).

If rhs is not a real number, false is returned.

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 = ∅$).

The formal definition is:

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

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.

The formal definition is:

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

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.

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 a member of f64:

use inari::*;
// The singleton set that consists of the nearest `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.

The formal definition is:

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

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 but may touch rhs.

The formal definition is:

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

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.

The formal definition is:

$$ (∀x ∈ \self, ∃y ∈ \rhs : x < y) ∧ (∀y ∈ \self, ∃x ∈ \rhs : 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.

The formal definition is:

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

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

Returns true if self is a subset of rhs ($\self ⊆ \rhs$).

The formal definition is:

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

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 target platform’s native byte order.

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

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

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

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

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

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

impl Interval

pub const EMPTY: Self

$∅$, the empty set.

pub const ENTIRE: Self

$[-∞, +∞]$, the whole real line.

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 $xy$-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 the exponential of self.

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, where rhs is an integer.

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 the bounds of self to integers using directed rounding 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 the bounds of self to integers using directed rounding 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 the bounds of self to the nearest integers, with halfway cases rounded away from zero.

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 the bounds of self to the nearest integers, with halfway cases rounded to even numbers.

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 between the sign function and f64::signum; $\sgn(0)$ is always zero, while the values of +0.0_f64.signum() and -0.0_f64.signum() are +1.0 and -1.0, respectively.

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 the bounds of self to integers using directed rounding 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 (greatest) lower bound of self.

Equivalently, it returns $a$ if $\self = [a, b]$ is nonempty; otherwise, $+∞$.

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 self is nonempty; otherwise, NaN.

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

$$ \operatorname{mag}(𝒙) = \sup\{|x| ∣ x ∈ 𝒙\} = \max(|a|, |b|). $$

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 self is nonempty; otherwise, NaN. For nonempty cases, the following values are returned.

• If $\self = [-∞, +∞]$, zero is returned.
• If $\self = [-∞, b]$ where $b < +∞$, f64::MIN is returned.
• If $\self = [a, +∞]$ where $a > -∞$, f64::MAX is returned.
• If self is bounded, $\operatorname{mid}(\self)$ rounded to the nearest f64 value is returned.

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

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

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 self is nonempty; otherwise, NaN.

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

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

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 self is nonempty; otherwise, NaN. The result $r$ is the smallest f64 number that satisfies $\self ⊆ [m - r, m + r]$ where $m$ is the f64 value returned by self.mid().

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

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

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 (least) upper bound of self.

Equivalently, it returns $b$ if $\self = [a, b]$ is nonempty; otherwise, $-∞$.

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 self is nonempty; otherwise, NaN. The result is rounded toward $+∞$.

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

$$ \operatorname{wid}(𝒙) = b - a. $$

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 values returned.

impl Interval

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

Returns $[\min(a, c), \max(b, d)]$ if both $\self = [a, b]$ and $\rhs = [c, d]$ are nonempty. If either interval is empty, the other is returned. If both are empty, $∅$ is returned.

This is equivalent to $\self ∪ \rhs$ if the intervals are not disjoint,

Tightness: tightest

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

Returns $\self ∩ \rhs$. If the result is nonempty, it is equivalent to $[\max(a, c), \min(b, d)]$, where both $\self = [a, b]$ and $\rhs = [c, d]$ are nonempty.

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<Self>

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 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 ==.

#[must_use]

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<Self>

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