#[repr(C)]pub struct Interval { /* private fields */ }
Expand description
An interval with f64
bounds.
It is sometimes referred to as a bare interval in contrast to a decorated interval (DecInterval
).
Implementations§
source§impl Interval
impl Interval
source§impl Interval
impl Interval
sourcepub fn mul_rev_to_pair(self, numerator: Self) -> [Self; 2]
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 $π$, wherez
is the tightest enclosure of $π$;[z1, z2]
if $\numerator \setdivβ² \self$ has two components $πβ$ and $πβ$ ordered so that $\sup πβ β€ \inf πβ$, wherez1
andz2
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]);
sourcepub fn cancel_minus(self, rhs: Self) -> Self
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);
sourcepub fn cancel_plus(self, rhs: Self) -> Self
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.
sourcepub fn mul_add(self, rhs: Self, addend: Self) -> Self
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$ |
sourcepub fn recip(self) -> Self
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$ |
source§impl Interval
impl Interval
sourcepub fn contains(self, rhs: f64) -> bool
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));
sourcepub fn disjoint(self, rhs: Self) -> bool
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));
sourcepub fn interior(self, rhs: Self) -> bool
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));
sourcepub fn is_common_interval(self) -> bool
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());
sourcepub fn is_empty(self) -> bool
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());
sourcepub fn is_entire(self) -> bool
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());
sourcepub fn is_singleton(self) -> bool
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());
sourcepub fn less(self, rhs: Self) -> bool
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));
sourcepub fn precedes(self, rhs: Self) -> bool
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));
sourcepub fn strict_less(self, rhs: Self) -> bool
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));
sourcepub fn strict_precedes(self, rhs: Self) -> bool
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$ |
sourcepub fn subset(self, rhs: Self) -> bool
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));
source§impl Interval
impl Interval
sourcepub fn to_be_bytes(self) -> [u8; 16]
pub fn to_be_bytes(self) -> [u8; 16]
Returns the interchange representation of self
in the big-endian byte order.
sourcepub fn to_le_bytes(self) -> [u8; 16]
pub fn to_le_bytes(self) -> [u8; 16]
Returns the interchange representation of self
in the little-endian byte order.
sourcepub fn to_ne_bytes(self) -> [u8; 16]
pub fn to_ne_bytes(self) -> [u8; 16]
Returns the interchange representation of self
in the native byte order of the target platform.
sourcepub fn try_from_be_bytes(bytes: [u8; 16]) -> Option<Self>
pub fn try_from_be_bytes(bytes: [u8; 16]) -> Option<Self>
Creates an Interval
from its interchange representation in the big-endian byte order.
source§impl Interval
impl Interval
sourcepub const FRAC_1_SQRT_2: Self = _
pub const FRAC_1_SQRT_2: Self = _
The tightest interval enclosing $1 / \sqrt{2}$.
sourcepub const FRAC_2_SQRT_PI: Self = _
pub const FRAC_2_SQRT_PI: Self = _
The tightest interval enclosing $2 / \sqrt{Ο}$.
source§impl Interval
impl Interval
sourcepub fn acos(self) -> Self
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, Ο]$ |
sourcepub fn acosh(self) -> Self
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, β)$ |
sourcepub fn asin(self) -> Self
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]$ |
sourcepub fn asinh(self) -> Self
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$ |
sourcepub fn atan(self) -> Self
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)$ |
sourcepub fn atan2(self, rhs: Self) -> Self
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)}$ | $(-Ο, Ο]$ |
sourcepub fn atanh(self) -> Self
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$ |
sourcepub fn cos(self) -> Self
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]$ |
sourcepub fn cosh(self) -> Self
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, β)$ |
sourcepub fn exp(self) -> Self
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, β)$ |
sourcepub fn exp10(self) -> Self
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, β)$ |
sourcepub fn exp2(self) -> Self
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, β)$ |
sourcepub fn ln(self) -> Self
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$ |
sourcepub fn log10(self) -> Self
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$ |
sourcepub fn log2(self) -> Self
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$ |
sourcepub fn pow(self, rhs: Self) -> Self
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, β)$ |
sourcepub fn powi(self, rhs: i32) -> Self
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, β)$ |
sourcepub fn sin(self) -> Self
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]$ |
sourcepub fn sinh(self) -> Self
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$ |
source§impl Interval
impl Interval
sourcepub fn ceil(self) -> Self
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
.
sourcepub fn floor(self) -> Self
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
.
sourcepub fn round(self) -> Self
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_to_even
.
sourcepub fn round_ties_to_even(self) -> Self
pub fn round_ties_to_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_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
.
sourcepub fn sign(self) -> Self
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));
sourcepub fn trunc(self) -> Self
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
.
source§impl Interval
impl Interval
sourcepub fn inf(self) -> f64
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
.
sourcepub fn mag(self) -> f64
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
.
sourcepub fn mid(self) -> f64
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
.
sourcepub fn mig(self) -> f64
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
.
sourcepub fn rad(self) -> f64
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
.
sourcepub fn sup(self) -> f64
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
.
sourcepub fn wid(self) -> f64
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);
source§impl Interval
impl Interval
sourcepub fn convex_hull(self, rhs: Self) -> Self
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}]$ |
sourcepub fn intersection(self, rhs: Self) -> Self
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§
source§impl AddAssign<&Interval> for Interval
impl AddAssign<&Interval> for Interval
source§fn add_assign(&mut self, other: &Interval)
fn add_assign(&mut self, other: &Interval)
+=
operation. Read moresource§impl AddAssign<Interval> for Interval
impl AddAssign<Interval> for Interval
source§fn add_assign(&mut self, rhs: Self)
fn add_assign(&mut self, rhs: Self)
+=
operation. Read moresource§impl DivAssign<&Interval> for Interval
impl DivAssign<&Interval> for Interval
source§fn div_assign(&mut self, other: &Interval)
fn div_assign(&mut self, other: &Interval)
/=
operation. Read moresource§impl DivAssign<Interval> for Interval
impl DivAssign<Interval> for Interval
source§fn div_assign(&mut self, rhs: Self)
fn div_assign(&mut self, rhs: Self)
/=
operation. Read moresource§impl MulAssign<&Interval> for Interval
impl MulAssign<&Interval> for Interval
source§fn mul_assign(&mut self, other: &Interval)
fn mul_assign(&mut self, other: &Interval)
*=
operation. Read moresource§impl MulAssign<Interval> for Interval
impl MulAssign<Interval> for Interval
source§fn mul_assign(&mut self, rhs: Self)
fn mul_assign(&mut self, rhs: Self)
*=
operation. Read moresource§impl PartialEq<Interval> for Interval
impl PartialEq<Interval> for Interval
source§impl SubAssign<&Interval> for Interval
impl SubAssign<&Interval> for Interval
source§fn sub_assign(&mut self, other: &Interval)
fn sub_assign(&mut self, other: &Interval)
-=
operation. Read moresource§impl SubAssign<Interval> for Interval
impl SubAssign<Interval> for Interval
source§fn sub_assign(&mut self, rhs: Self)
fn sub_assign(&mut self, rhs: Self)
-=
operation. Read more