[−][src]Struct inari::Interval
An interval with f64
bounds.
It is sometimes referred to as a bare interval in contrast to a decorated interval (DecInterval
).
Implementations
impl Interval
[src]
pub fn abs(self) -> Self
[src]
Returns the absolute value of self
.
Tightness: tightest
pub fn max(self, rhs: Self) -> Self
[src]
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
[src]
Returns $[\min(a, c), \min(b, d)]$ if both $\self = [a, b]$ and $\rhs = [c, d]$ are nonempty; otherwise $β $.
Tightness: tightest
impl Interval
[src]
pub fn mul_add(self, rhs: Self, addend: Self) -> Self
[src]
Returns $(\self Γ \rhs) + \addend$.
Tightness: tightest
pub fn recip(self) -> Self
[src]
Returns the multiplicative inverse of self
.
Tightness: tightest
pub fn sqr(self) -> Self
[src]
Returns the square of self
.
Tightness: tightest
pub fn sqrt(self) -> Self
[src]
Returns the principal square root of self
.
Tightness: tightest
impl Interval
[src]
pub fn contains(self, rhs: f64) -> bool
[src]
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
[src]
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
[src]
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
[src]
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
[src]
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
[src]
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
[src]
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
[src]
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
[src]
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
[src]
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
[src]
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
[src]
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
[src]
pub fn to_be_bytes(self) -> [u8; 16]
[src]
Returns the big-endian interchange representation of self
.
pub fn to_le_bytes(self) -> [u8; 16]
[src]
Returns the little-endian interchange representation of self
.
pub fn to_ne_bytes(self) -> [u8; 16]
[src]
Returns the native-byte-order interchange representation of self
.
pub fn try_from_be_bytes(bytes: [u8; 16]) -> Result<Self>
[src]
Creates an interval from its big-endian interchange representation.
pub fn try_from_le_bytes(bytes: [u8; 16]) -> Result<Self>
[src]
Creates an interval from its little-endian interchange representation.
pub fn try_from_ne_bytes(bytes: [u8; 16]) -> Result<Self>
[src]
Creates an interval from its native-byte-order interchange representation.
impl Interval
[src]
pub const EMPTY: Self
[src]
$β $, the empty interval.
pub const ENTIRE: Self
[src]
$[-β, β]$.
pub const E: Self
[src]
The tightest interval enclosing $\e$, the base of natural logarithms.
pub const FRAC_1_PI: Self
[src]
The tightest interval enclosing $1 / \pi$.
pub const FRAC_1_SQRT_2: Self
[src]
The tightest interval enclosing $1 / \sqrt{2}$.
pub const FRAC_2_PI: Self
[src]
The tightest interval enclosing $2 / \pi$.
pub const FRAC_2_SQRT_PI: Self
[src]
The tightest interval enclosing $2 / \sqrt{\pi}$.
pub const FRAC_PI_2: Self
[src]
The tightest interval enclosing $\pi / 2$.
pub const FRAC_PI_3: Self
[src]
The tightest interval enclosing $\pi / 3$.
pub const FRAC_PI_4: Self
[src]
The tightest interval enclosing $\pi / 4$.
pub const FRAC_PI_6: Self
[src]
The tightest interval enclosing $\pi / 6$.
pub const FRAC_PI_8: Self
[src]
The tightest interval enclosing $\pi / 8$.
pub const LN_10: Self
[src]
The tightest interval enclosing $\ln 10$.
pub const LN_2: Self
[src]
The tightest interval enclosing $\ln 2$.
pub const LOG10_2: Self
[src]
The tightest interval enclosing $\log_{10} 2$.
pub const LOG10_E: Self
[src]
The tightest interval enclosing $\log_{10} \e$.
pub const LOG2_10: Self
[src]
The tightest interval enclosing $\log_2 10$.
pub const LOG2_E: Self
[src]
The tightest interval enclosing $\log_2 \e$.
pub const PI: Self
[src]
The tightest interval enclosing $\pi$.
pub const SQRT_2: Self
[src]
The tightest interval enclosing $\sqrt{2}$.
pub const TAU: Self
[src]
The tightest interval enclosing $2 \pi$.
impl Interval
[src]
pub fn acos(self) -> Self
[src]
Returns the inverse cosine of self
.
Tightness: tightest
pub fn acosh(self) -> Self
[src]
Returns the inverse hyperbolic cosine of self
.
Tightness: tightest
pub fn asin(self) -> Self
[src]
Returns the inverse sine of self
.
Tightness: tightest
pub fn asinh(self) -> Self
[src]
Returns the inverse hyperbolic sine of self
.
Tightness: tightest
pub fn atan(self) -> Self
[src]
Returns the inverse tangent of self
.
Tightness: tightest
pub fn atan2(self, rhs: Self) -> Self
[src]
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
[src]
Returns the inverse hyperbolic tangent of self
.
Tightness: tightest
pub fn cos(self) -> Self
[src]
Returns the cosine of self
.
Tightness: tightest
pub fn cosh(self) -> Self
[src]
Returns the hyperbolic cosine of self
.
Tightness: tightest
pub fn exp(self) -> Self
[src]
Returns the exponential of self
.
Tightness: tightest
pub fn exp10(self) -> Self
[src]
Returns self
raised to the power of 10.
Tightness: tightest
pub fn exp2(self) -> Self
[src]
Returns self
raised to the power of 2.
Tightness: tightest
pub fn ln(self) -> Self
[src]
Returns the natural logarithm of self
.
Tightness: tightest
pub fn log10(self) -> Self
[src]
Returns the base-10 logarithm of self
.
Tightness: tightest
pub fn log2(self) -> Self
[src]
Returns the base-2 logarithm of self
.
Tightness: tightest
pub fn pow(self, rhs: Self) -> Self
[src]
Returns self
raised to the power of rhs
.
Tightness: tightest
pub fn pown(self, rhs: i32) -> Self
[src]
Returns self
raised to the power of rhs
, where rhs
is an integer.
Tightness: tightest
pub fn sin(self) -> Self
[src]
Returns the sine of self
.
Tightness: tightest
pub fn sinh(self) -> Self
[src]
Returns the hyperbolic sine of self
.
Tightness: tightest
pub fn tan(self) -> Self
[src]
Returns the tangent of self
.
Tightness: tightest
pub fn tanh(self) -> Self
[src]
Returns the hyperbolic tangent of self
.
Tightness: tightest
impl Interval
[src]
pub fn ceil(self) -> Self
[src]
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
[src]
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_ties_to_away(self) -> Self
[src]
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_ties_to_away(), const_interval!(0.0, 1.0)); assert_eq!(const_interval!(0.5, 1.5).round_ties_to_away(), const_interval!(1.0, 2.0)); assert_eq!(const_interval!(0.8, 1.8).round_ties_to_away(), const_interval!(1.0, 2.0)); assert_eq!(const_interval!(-1.2, -0.2).round_ties_to_away(), const_interval!(-1.0, 0.0)); assert_eq!(const_interval!(-1.5, -0.5).round_ties_to_away(), const_interval!(-2.0, -1.0)); assert_eq!(const_interval!(-1.8, -0.8).round_ties_to_away(), const_interval!(-2.0, -1.0)); assert_eq!(Interval::EMPTY.round_ties_to_away(), Interval::EMPTY); assert_eq!(Interval::ENTIRE.round_ties_to_away(), Interval::ENTIRE);
See also: Interval::round_ties_to_even
.
pub fn round_ties_to_even(self) -> Self
[src]
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_ties_to_away
.
pub fn sign(self) -> Self
[src]
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
[src]
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
[src]
pub fn inf(self) -> f64
[src]
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
[src]
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
[src]
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 nearestf64
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
[src]
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
[src]
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
[src]
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
[src]
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
[src]
pub fn overlap(self, rhs: Self) -> OverlappingState
[src]
Returns the overlapping state of self
and rhs
. See OverlappingState
for the possible values returned.
impl Interval
[src]
pub fn convex_hull(self, rhs: Self) -> Self
[src]
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
[src]
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
[src]
type Output = Self
The resulting type after applying the +
operator.
fn add(self, rhs: Self) -> Self
[src]
Tightness: tightest
impl AddAssign<Interval> for Interval
[src]
fn add_assign(&mut self, rhs: Self)
[src]
impl Clone for Interval
[src]
impl Copy for Interval
[src]
impl Debug for Interval
[src]
impl Display for Interval
[src]
impl Div<Interval> for Interval
[src]
type Output = Self
The resulting type after applying the /
operator.
fn div(self, rhs: Self) -> Self
[src]
Tightness: tightest
impl DivAssign<Interval> for Interval
[src]
fn div_assign(&mut self, rhs: Self)
[src]
impl Eq for Interval
[src]
impl FromStr for Interval
[src]
type Err = IntervalError<Self>
The associated error which can be returned from parsing.
fn from_str(s: &str) -> Result<Self>
[src]
impl LowerExp for Interval
[src]
impl LowerHex for Interval
[src]
impl Mul<Interval> for Interval
[src]
type Output = Self
The resulting type after applying the *
operator.
fn mul(self, rhs: Self) -> Self
[src]
Tightness: tightest
impl MulAssign<Interval> for Interval
[src]
fn mul_assign(&mut self, rhs: Self)
[src]
impl Neg for Interval
[src]
type Output = Self
The resulting type after applying the -
operator.
fn neg(self) -> Self
[src]
Tightness: tightest
impl PartialEq<Interval> for Interval
[src]
impl Sub<Interval> for Interval
[src]
type Output = Self
The resulting type after applying the -
operator.
fn sub(self, rhs: Self) -> Self
[src]
Tightness: tightest
impl SubAssign<Interval> for Interval
[src]
fn sub_assign(&mut self, rhs: Self)
[src]
impl TryFrom<(f64, f64)> for Interval
[src]
Auto Trait Implementations
impl RefUnwindSafe for Interval
impl Send for Interval
impl Sync for Interval
impl Unpin for Interval
impl UnwindSafe for Interval
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Az for T
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> CheckedAs for T
[src]
pub fn checked_as<Dst>(self) -> Option<Dst> where
T: CheckedCast<Dst>,
[src]
T: CheckedCast<Dst>,
impl<T> Conv for T
impl<T> Conv for T
impl<T> FmtForward for T
fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,
Self: Binary,
fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,
Self: Display,
fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,
Self: LowerExp,
fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,
Self: LowerHex,
fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,
Self: Octal,
fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,
Self: Pointer,
fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,
Self: UpperExp,
fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,
Self: UpperHex,
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> OverflowingAs for T
[src]
pub fn overflowing_as<Dst>(self) -> (Dst, bool) where
T: OverflowingCast<Dst>,
[src]
T: OverflowingCast<Dst>,
impl<T> Pipe for T where
T: ?Sized,
T: ?Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
R: 'a,
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
B: 'a + ?Sized,
R: 'a,
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,
Self: Borrow<B>,
fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
B: 'a + ?Sized,
R: 'a,
Self: BorrowMut<B>,
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
B: 'a + ?Sized,
R: 'a,
Self: BorrowMut<B>,
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
R: 'a,
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
Self: AsRef<U>,
U: 'a + ?Sized,
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where
R: 'a,
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
Self: AsMut<U>,
U: 'a + ?Sized,
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
R: 'a,
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
Self: Deref<Target = T>,
T: 'a + ?Sized,
fn pipe_deref_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
R: 'a,
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
R: 'a,
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
impl<T> Pipe for T
impl<T> PipeAsRef for T
fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
R: 'a,
Self: AsRef<T>,
T: 'a,
R: 'a,
Self: AsRef<T>,
T: 'a,
fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where
R: 'a,
Self: AsMut<T>,
T: 'a,
R: 'a,
Self: AsMut<T>,
T: 'a,
impl<T> PipeBorrow for T
fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
R: 'a,
Self: Borrow<T>,
T: 'a,
R: 'a,
Self: Borrow<T>,
T: 'a,
fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
R: 'a,
Self: BorrowMut<T>,
T: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
R: 'a,
Self: BorrowMut<T>,
T: 'a,
impl<T> PipeDeref for T
fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
R: 'a,
Self: Deref,
R: 'a,
Self: Deref,
fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
R: 'a,
Self: DerefMut,
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
R: 'a,
Self: DerefMut,
impl<T> PipeRef for T
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
R: 'a,
fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
R: 'a,
impl<T> SaturatingAs for T
[src]
pub fn saturating_as<Dst>(self) -> Dst where
T: SaturatingCast<Dst>,
[src]
T: SaturatingCast<Dst>,
impl<T> Tap for T
fn tap(self, func: impl FnOnce(&Self)) -> Self
fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
B: ?Sized,
Self: Borrow<B>,
B: ?Sized,
Self: Borrow<B>,
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
B: ?Sized,
Self: BorrowMut<B>,
B: ?Sized,
Self: BorrowMut<B>,
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
R: ?Sized,
Self: AsRef<R>,
R: ?Sized,
Self: AsRef<R>,
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
R: ?Sized,
Self: AsMut<R>,
R: ?Sized,
Self: AsMut<R>,
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
Self: Deref<Target = T>,
T: ?Sized,
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
B: ?Sized,
Self: Borrow<B>,
B: ?Sized,
Self: Borrow<B>,
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
B: ?Sized,
Self: BorrowMut<B>,
B: ?Sized,
Self: BorrowMut<B>,
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
R: ?Sized,
Self: AsRef<R>,
R: ?Sized,
Self: AsRef<R>,
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
R: ?Sized,
Self: AsMut<R>,
R: ?Sized,
Self: AsMut<R>,
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
Self: Deref<Target = T>,
T: ?Sized,
fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
impl<T> Tap for T
fn tap<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
F: FnOnce(&Self) -> R,
fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
F: FnOnce(&Self) -> R,
fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
F: FnOnce(&mut Self) -> R,
fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
F: FnOnce(&mut Self) -> R,
impl<T, U> TapAsRef<U> for T where
U: ?Sized,
U: ?Sized,
fn tap_ref<F, R>(self, func: F) -> Self where
F: FnOnce(&T) -> R,
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Self: AsRef<T>,
fn tap_ref_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&T) -> R,
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Self: AsRef<T>,
fn tap_ref_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
impl<T, U> TapBorrow<U> for T where
U: ?Sized,
U: ?Sized,
fn tap_borrow<F, R>(self, func: F) -> Self where
F: FnOnce(&T) -> R,
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Self: Borrow<T>,
fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&T) -> R,
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Self: Borrow<T>,
fn tap_borrow_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
impl<T> TapDeref for T
fn tap_deref<F, R>(self, func: F) -> Self where
F: FnOnce(&Self::Target) -> R,
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Self: Deref,
fn tap_deref_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self::Target) -> R,
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Self: Deref,
fn tap_deref_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T> TryConv for T
impl<T> TryConv for T
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> WrappingAs for T
[src]
pub fn wrapping_as<Dst>(self) -> Dst where
T: WrappingCast<Dst>,
[src]
T: WrappingCast<Dst>,