Struct Interval 

pub struct Interval { /* private fields */ }

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.

The domain and the range of the point function are:

Domain	Range
$\R$	$[0, ∞)$

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

Returns the maximum of self and rhs.

The domain and the range of the point function are:

Domain	Range
$\R^2$	$\R$

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

Returns the minimum of self and rhs.

The domain and the range of the point function are:

Domain	Range
$\R^2$	$\R$

impl Interval

pub fn mul_rev_to_pair(self, numerator: Self) -> [Self; 2]

Returns the reverse multiplication $\numerator \setdiv′ \self$ (beware the order of the arguments) as an array of two intervals. The operation is also known as two-output division in IEEE Std 1788-2015.

For intervals $𝒙$ and $𝒚$, the reverse multiplication is defined as:

$$ 𝒙 \setdiv′ 𝒚 = \set{z ∈ \R ∣ ∃y ∈ 𝒚 : zy ∈ 𝒙}. $$

For comparison, the standard division is defined as:

$$ \begin{align*} 𝒙 \setdiv 𝒚 &= \set{x / y ∣ (x, y) ∈ 𝒙 × 𝒚 ∖ \set 0} \\ &= \set{z ∈ \R ∣ ∃y ∈ 𝒚 ∖ \set 0 : zy ∈ 𝒙}. \end{align*} $$

The interval division $𝒙 / 𝒚$ is an enclosure of $𝒙 \setdiv 𝒚$. A notable difference between two definitions is that when $𝒙 = 𝒚 = \set 0$, $𝒙 \setdiv 𝒚 = ∅$, while $𝒙 \setdiv′ 𝒚 = \R$.

The function returns:

• [Interval::EMPTY; 2] if $\numerator \setdiv′ \self$ is empty;
• [z, Interval::EMPTY] if $\numerator \setdiv′ \self$ has one component $𝒛$, where z is the tightest enclosure of $𝒛$;
• [z1, z2] if $\numerator \setdiv′ \self$ has two components $𝒛₁$ and $𝒛₂$ ordered so that $\sup 𝒛₁ ≤ \inf 𝒛₂$, where z1 and z2 are the tightest enclosures of $𝒛₁$ and $𝒛₂$, respectively.

When $\self ≠ ∅ ∧ \numerator ≠ ∅$, the number of components $\numerator \setdiv′ \self$ has are summarized as:

	$0 ∈ \numerator$	$0 ∉ \numerator$
$0 ∈ \self$	1	0, 1, or 2
$0 ∉ \self$	1	1

Examples

use inari::{Interval as I, const_interval as c};
let zero = c!(0.0, 0.0);
assert_eq!(zero.mul_rev_to_pair(c!(1.0, 2.0)), [I::EMPTY; 2]);
assert_eq!(zero.mul_rev_to_pair(c!(0.0, 2.0)), [I::ENTIRE, I::EMPTY]);
assert_eq!(zero.mul_rev_to_pair(zero), [I::ENTIRE, I::EMPTY]);
let x = c!(1.0, 2.0);
assert_eq!(I::ENTIRE.mul_rev_to_pair(x), [c!(f64::NEG_INFINITY, 0.0), c!(0.0, f64::INFINITY)]);
assert_eq!(c!(1.0, 1.0).mul_rev_to_pair(x), [x, I::EMPTY]);
assert_eq!(c!(1.0, f64::INFINITY).mul_rev_to_pair(c!(1.0, 1.0)),
           [c!(0.0, 1.0), I::EMPTY]);
assert_eq!(c!(-1.0, 1.0).mul_rev_to_pair(c!(1.0, 2.0)),
           [c!(f64::NEG_INFINITY, -1.0), c!(1.0, f64::INFINITY)]);
assert_eq!(c!(-1.0, 1.0).mul_rev_to_pair(zero), [I::ENTIRE, I::EMPTY]);

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

Returns the tightest interval z such that rhs $+$ z $⊇$ self, if both self and rhs are bounded and the width of self is greater than or equal to that of rhs. Otherwise, returns Interval::ENTIRE.

Even when x.cancel_minus(y) is not Interval::ENTIRE, its value is generally different from x - y, as the latter gives the tightest enclosure of x $-$ y, while the former does not always enclose x $-$ y. In such case, x.cancel_minus(y) $⊆$ x - y holds, but generally not the equality.

Examples

Getting an enclosure of a partial sum omitting a single term from their total:

use inari::*;
let x = interval!("[0.1, 0.2]").unwrap();
let y = interval!("[0.3, 0.4]").unwrap();
let z = interval!("[0.5, 0.6]").unwrap();
let sum = x + y + z;
assert!((y + z).subset(sum.cancel_minus(x)));
assert!((x + z).subset(sum.cancel_minus(y)));
assert!((x + y).subset(sum.cancel_minus(z)));

sum.cancel_minus(x) is a subset of sum - x:

assert!(sum.cancel_minus(x).subset(sum - x));

But the inverse does not hold in general:

assert!((sum - x).subset(sum.cancel_minus(x)));

sum.cancel_minus(x), etc. returns Interval::ENTIRE when sum is unbounded:

use inari::*;
let x = const_interval!(1.0, 2.0);
let y = const_interval!(3.0, f64::MAX);
let sum = x + y;
assert_eq!(sum.cancel_minus(x), Interval::ENTIRE);
assert_eq!(sum.cancel_minus(y), Interval::ENTIRE);

sum.cancel_minus(x) returns Interval::ENTIRE when the width of “sum” is less than that of x:

use inari::*;
let x = const_interval!(1.0, 2.0);
let sum = const_interval!(4.0, 4.5);
assert_eq!(sum.cancel_minus(x), Interval::ENTIRE);

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

x.cancel_plus(y) is equivalent to x.cancel_minus(-y).

See Interval::cancel_minus for more information.

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

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

The domain and the range of the point function are:

Domain	Range
$\R^3$	$\R$

pub fn recip(self) -> Self

Returns the multiplicative inverse of self.

The domain and the range of the point function are:

Domain	Range
$\R ∖ \set 0$	$\R ∖ \set 0$

pub fn sqr(self) -> Self

Returns the square of self.

The domain and the range of the point function are:

Domain	Range
$\R$	$[0, ∞)$

pub fn sqrt(self) -> Self

Returns the principal square root of self.

The domain and the range of the point function are:

Domain	Range
$[0, ∞)$	$[0, ∞)$

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 self in the big-endian byte order.

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

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

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

Returns the interchange representation of self 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.

The domain and the range of the point function are:

Domain	Range
$[-1, 1]$	$[0, π]$

pub fn acosh(self) -> Self

Returns the inverse hyperbolic cosine of self.

The domain and the range of the point function are:

Domain	Range
$[1, ∞)$	$[0, ∞)$

pub fn asin(self) -> Self

Returns the inverse sine of self.

The domain and the range of the point function are:

Domain	Range
$[-1, 1]$	$[-π/2, π/2]$

pub fn asinh(self) -> Self

Returns the inverse hyperbolic sine of self.

The domain and the range of the point function are:

Domain	Range
$\R$	$\R$

pub fn atan(self) -> Self

Returns the inverse tangent of self.

The domain and the range of the point function are:

Domain	Range
$\R$	$(-π/2, π/2)$

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.

The domain and the range of the point function are:

Domain	Range
$\R^2 ∖ \set{(0, 0)}$	$(-π, π]$

pub fn atanh(self) -> Self

Returns the inverse hyperbolic tangent of self.

The domain and the range of the point function are:

Domain	Range
$(-1, 1)$	$\R$

pub fn cos(self) -> Self

Returns the cosine of self.

The domain and the range of the point function are:

Domain	Range
$\R$	$[-1, 1]$

pub fn cosh(self) -> Self

Returns the hyperbolic cosine of self.

The domain and the range of the point function are:

Domain	Range
$\R$	$[1, ∞)$

pub fn exp(self) -> Self

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

The domain and the range of the point function are:

Domain	Range
$\R$	$(0, ∞)$

pub fn exp10(self) -> Self

Returns self raised to the power of 10.

The domain and the range of the point function are:

Domain	Range
$\R$	$(0, ∞)$

pub fn exp2(self) -> Self

Returns self raised to the power of 2.

The domain and the range of the point function are:

Domain	Range
$\R$	$(0, ∞)$

pub fn ln(self) -> Self

Returns the natural logarithm of self.

The domain and the range of the point function are:

Domain	Range
$(0, ∞)$	$\R$

pub fn log10(self) -> Self

Returns the base-10 logarithm of self.

The domain and the range of the point function are:

Domain	Range
$(0, ∞)$	$\R$

pub fn log2(self) -> Self

Returns the base-2 logarithm of self.

The domain and the range of the point function are:

Domain	Range
$(0, ∞)$	$\R$

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

Returns self raised to the power of rhs.

The point function is defined as follows:

$$ x^y = \begin{cases} 0 & \for x = 0 ∧ y > 0, \\ e^{y \ln x} & \for x > 0. \end{cases} $$

The domain and the range of the point function are:

Domain	Range
$((0, ∞) × \R) ∪ (\set 0 × (0, ∞))$	$[0, ∞)$

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

Returns self raised to the power of rhs.

The point functions are indexed by $n$, and are defined as follows:

$$ x^n = \begin{cases} \overbrace{x × ⋯ × x}^{n \text{ copies}} & \for n > 0, \\ 1 & \for n = 0, \\ 1 / x^{-n} & \for n < 0. \end{cases} $$

The domains and the ranges of the point functions are:

	Domain	Range
$n > 0$, odd	$\R$	$\R$
$n > 0$, even	$\R$	$[0, ∞)$
$n = 0$	$\R$	$\set 1$
$n < 0$, odd	$\R ∖ \set 0$	$\R ∖ \set 0$
$n < 0$, even	$\R ∖ \set 0$	$(0, ∞)$

pub fn sin(self) -> Self

Returns the sine of self.

The domain and the range of the point function are:

Domain	Range
$\R$	$[-1, 1]$

pub fn sinh(self) -> Self

Returns the hyperbolic sine of self.

The domain and the range of the point function are:

Domain	Range
$\R$	$\R$

pub fn tan(self) -> Self

Returns the tangent of self.

The domain and the range of the point function are:

Domain	Range
$\R ∖ \set{(n + 1/2) π ∣ n ∈ \Z}$	$\R$

pub fn tanh(self) -> Self

Returns the hyperbolic tangent of self.

The domain and the range of the point function are:

Domain	Range
$\R$	$(-1, 1)$

impl Interval

pub fn ceil(self) -> Self

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

The domain and the range of the point function are:

Domain	Range
$\R$	$\Z$

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

The domain and the range of the point function are:

Domain	Range
$\R$	$\Z$

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.

The domain and the range of the point function are:

Domain	Range
$\R$	$\Z$

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

pub fn round_ties_even(self) -> Self

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

The domain and the range of the point function are:

Domain	Range
$\R$	$\Z$

Examples

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

See also: Interval::round.

pub fn sign(self) -> Self

Returns the sign of self.

The domain and the range of the point function are:

Domain	Range
$\R$	$\set{-1, 0, 1}$

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.

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.

The domain and the range of the point function are:

Domain	Range
$\R$	$\Z$

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. When $a = 0$, -0.0 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. When $b = 0$, 0.0 (the positive zero) 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}]$

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}]$

Trait Implementations

impl Add<&Interval> for &Interval

type Output = <Interval as Add>::Output

The resulting type after applying the + operator.

fn add(self, other: &Interval) -> <Interval as Add<Interval>>::Output

Performs the + operation.

impl Add<&Interval> for Interval

type Output = <Interval as Add>::Output

The resulting type after applying the + operator.

fn add(self, other: &Interval) -> <Interval as Add<Interval>>::Output

Performs the + operation.

impl<'a> Add<Interval> for &'a Interval

type Output = <Interval as Add>::Output

The resulting type after applying the + operator.

fn add(self, other: Interval) -> <Interval as Add<Interval>>::Output

Performs the + operation.

impl Add for Interval

type Output = Interval

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<&Interval> for Interval

fn add_assign(&mut self, other: &Interval)

Performs the += operation.

impl AddAssign for Interval

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Interval

fn clone(&self) -> Interval

Returns a duplicate 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

type Output = <Interval as Div>::Output

The resulting type after applying the / operator.

fn div(self, other: &Interval) -> <Interval as Div<Interval>>::Output

Performs the / operation.

impl Div<&Interval> for Interval

type Output = <Interval as Div>::Output

The resulting type after applying the / operator.

fn div(self, other: &Interval) -> <Interval as Div<Interval>>::Output

Performs the / operation.

impl<'a> Div<Interval> for &'a Interval

type Output = <Interval as Div>::Output

The resulting type after applying the / operator.

fn div(self, other: Interval) -> <Interval as Div<Interval>>::Output

Performs the / operation.

impl Div for Interval

type Output = Interval

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<&Interval> for Interval

fn div_assign(&mut self, other: &Interval)

Performs the /= operation.

impl DivAssign 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, Self: Sized,

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

type Output = <Interval as Mul>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Interval) -> <Interval as Mul<Interval>>::Output

Performs the * operation.

impl Mul<&Interval> for Interval

type Output = <Interval as Mul>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Interval) -> <Interval as Mul<Interval>>::Output

Performs the * operation.

impl<'a> Mul<Interval> for &'a Interval

type Output = <Interval as Mul>::Output

The resulting type after applying the * operator.

fn mul(self, other: Interval) -> <Interval as Mul<Interval>>::Output

Performs the * operation.

impl Mul for Interval

type Output = Interval

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<&Interval> for Interval

fn mul_assign(&mut self, other: &Interval)

Performs the *= operation.

impl MulAssign for Interval

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for &Interval

type Output = <Interval as Neg>::Output

The resulting type after applying the - operator.

fn neg(self) -> <Interval as Neg>::Output

Performs the unary - operation.

impl Neg for Interval

type Output = Interval

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq for Interval

fn eq(&self, rhs: &Self) -> 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 Sub<&Interval> for &Interval

type Output = <Interval as Sub>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Interval) -> <Interval as Sub<Interval>>::Output

Performs the - operation.

impl Sub<&Interval> for Interval

type Output = <Interval as Sub>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Interval) -> <Interval as Sub<Interval>>::Output

Performs the - operation.

impl<'a> Sub<Interval> for &'a Interval

type Output = <Interval as Sub>::Output

The resulting type after applying the - operator.

fn sub(self, other: Interval) -> <Interval as Sub<Interval>>::Output

Performs the - operation.

impl Sub for Interval

type Output = Interval

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<&Interval> for Interval

fn sub_assign(&mut self, other: &Interval)

Performs the -= operation.

impl SubAssign 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

impl Send for Interval

impl Sync for Interval

impl Unpin for Interval