Struct typed_floats::NonZeroNonNaN
source · pub struct NonZeroNonNaN<T = f64>(/* private fields */);
Expand description
A non-NaN floating point number different from zero
It satisfies the following constraints:
- It is not NaN.
- It is not zero.
Implementations§
source§impl NonZeroNonNaN
impl NonZeroNonNaN
sourcepub const fn accept_infinity() -> bool
pub const fn accept_infinity() -> bool
Returns true if the type can accept infinity
sourcepub const fn accept_zero() -> bool
pub const fn accept_zero() -> bool
Returns true if the type can accept zero
sourcepub const fn accept_negative() -> bool
pub const fn accept_negative() -> bool
Returns true if the type can accept negative values
sourcepub const fn accept_positive() -> bool
pub const fn accept_positive() -> bool
Returns true if the type can accept positive values
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn new(value: f32) -> Result<Self, InvalidNumber>
pub fn new(value: f32) -> Result<Self, InvalidNumber>
sourcepub unsafe fn new_unchecked(value: f32) -> Self
pub unsafe fn new_unchecked(value: f32) -> Self
Creates a new value from a primitive type with zero overhead (in release mode). It is up to the caller to ensure that the value is valid
§Examples
let x = unsafe { NonZeroNonNaN::new_unchecked(3.0) };
assert_eq!(x, 3.0);
§Safety
The caller must ensure that the value is valid. It will panic in debug mode if the value is not valid, but in release mode the behavior is undefined
sourcepub const fn get(&self) -> f32
pub const fn get(&self) -> f32
Returns the value as a primitive type
§Examples
use typed_floats::tf32::NonZeroNonNaN;
let x = NonZeroNonNaN::new(3.0).unwrap();
let y: f32 = x.into();
assert_eq!(y, 3.0);
sourcepub const fn is_nan(&self) -> bool
pub const fn is_nan(&self) -> bool
Returns true
if this value is NaN.
This is never the case for the provided types
§Examples
use typed_floats::tf32::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.is_nan(), false);
See f32::is_nan()
for more details.
sourcepub fn is_infinite(&self) -> bool
pub fn is_infinite(&self) -> bool
Returns true
if this value is positive infinity or negative infinity.
§Examples
use typed_floats::tf32::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.is_infinite(), false);
See f32::is_infinite()
for more details.
sourcepub fn is_finite(&self) -> bool
pub fn is_finite(&self) -> bool
Returns true
if this number is positive infinity nor negative infinity.
§Examples
use typed_floats::tf32::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.is_finite(), true);
See f32::is_finite()
for more details.
sourcepub fn is_subnormal(&self) -> bool
pub fn is_subnormal(&self) -> bool
Returns true
if the number is subnormal.
§Examples
use typed_floats::tf32::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.is_subnormal(), false);
See f32::is_subnormal()
for more details.
sourcepub fn is_normal(&self) -> bool
pub fn is_normal(&self) -> bool
Returns true
if the number is neither zero, infinite or subnormal.
§Examples
use typed_floats::tf32::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.is_normal(), true);
See f32::is_normal()
for more details.
sourcepub fn classify(&self) -> FpCategory
pub fn classify(&self) -> FpCategory
Returns the floating point category of the number. If only one property is going to be tested, it is generally faster to use the specific predicate instead.
§Examples
use typed_floats::tf32::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.classify(), core::num::FpCategory::Normal);
See f32::classify()
for more details.
sourcepub fn is_sign_positive(&self) -> bool
pub fn is_sign_positive(&self) -> bool
Returns true
if self
has a positive sign, including +0.0
and positive infinity.
§Examples
use typed_floats::tf32::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.is_sign_positive(), true);
See f32::is_sign_positive()
for more details.
sourcepub fn is_sign_negative(&self) -> bool
pub fn is_sign_negative(&self) -> bool
Returns true
if self
has a negative sign, including -0.0
and negative infinity.
§Examples
use typed_floats::tf32::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.is_sign_negative(), false);
See f32::is_sign_negative()
for more details.
sourcepub const fn is_negative_zero(&self) -> bool
pub const fn is_negative_zero(&self) -> bool
Returns true
if the number is negative zero.
§Examples
use typed_floats::tf32::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.is_negative_zero(), false);
sourcepub const fn is_positive_zero(&self) -> bool
pub const fn is_positive_zero(&self) -> bool
Returns true
if the number is positive zero.
§Examples
use typed_floats::tf32::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.is_positive_zero(), false);
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn new(value: f64) -> Result<Self, InvalidNumber>
pub fn new(value: f64) -> Result<Self, InvalidNumber>
sourcepub unsafe fn new_unchecked(value: f64) -> Self
pub unsafe fn new_unchecked(value: f64) -> Self
Creates a new value from a primitive type with zero overhead (in release mode). It is up to the caller to ensure that the value is valid
§Examples
let x = unsafe { NonZeroNonNaN::new_unchecked(3.0) };
assert_eq!(x, 3.0);
§Safety
The caller must ensure that the value is valid. It will panic in debug mode if the value is not valid, but in release mode the behavior is undefined
sourcepub const fn get(&self) -> f64
pub const fn get(&self) -> f64
Returns the value as a primitive type
§Examples
use typed_floats::tf64::NonZeroNonNaN;
let x = NonZeroNonNaN::new(3.0).unwrap();
let y: f64 = x.into();
assert_eq!(y, 3.0);
sourcepub const fn is_nan(&self) -> bool
pub const fn is_nan(&self) -> bool
Returns true
if this value is NaN.
This is never the case for the provided types
§Examples
use typed_floats::tf64::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.is_nan(), false);
See f64::is_nan()
for more details.
sourcepub fn is_infinite(&self) -> bool
pub fn is_infinite(&self) -> bool
Returns true
if this value is positive infinity or negative infinity.
§Examples
use typed_floats::tf64::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.is_infinite(), false);
See f64::is_infinite()
for more details.
sourcepub fn is_finite(&self) -> bool
pub fn is_finite(&self) -> bool
Returns true
if this number is positive infinity nor negative infinity.
§Examples
use typed_floats::tf64::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.is_finite(), true);
See f64::is_finite()
for more details.
sourcepub fn is_subnormal(&self) -> bool
pub fn is_subnormal(&self) -> bool
Returns true
if the number is subnormal.
§Examples
use typed_floats::tf64::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.is_subnormal(), false);
See f64::is_subnormal()
for more details.
sourcepub fn is_normal(&self) -> bool
pub fn is_normal(&self) -> bool
Returns true
if the number is neither zero, infinite or subnormal.
§Examples
use typed_floats::tf64::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.is_normal(), true);
See f64::is_normal()
for more details.
sourcepub fn classify(&self) -> FpCategory
pub fn classify(&self) -> FpCategory
Returns the floating point category of the number. If only one property is going to be tested, it is generally faster to use the specific predicate instead.
§Examples
use typed_floats::tf64::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.classify(), core::num::FpCategory::Normal);
See f64::classify()
for more details.
sourcepub fn is_sign_positive(&self) -> bool
pub fn is_sign_positive(&self) -> bool
Returns true
if self
has a positive sign, including +0.0
and positive infinity.
§Examples
use typed_floats::tf64::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.is_sign_positive(), true);
See f64::is_sign_positive()
for more details.
sourcepub fn is_sign_negative(&self) -> bool
pub fn is_sign_negative(&self) -> bool
Returns true
if self
has a negative sign, including -0.0
and negative infinity.
§Examples
use typed_floats::tf64::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.is_sign_negative(), false);
See f64::is_sign_negative()
for more details.
sourcepub const fn is_negative_zero(&self) -> bool
pub const fn is_negative_zero(&self) -> bool
Returns true
if the number is negative zero.
§Examples
use typed_floats::tf64::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.is_negative_zero(), false);
sourcepub const fn is_positive_zero(&self) -> bool
pub const fn is_positive_zero(&self) -> bool
Returns true
if the number is positive zero.
§Examples
use typed_floats::tf64::NonZeroNonNaN;
let x: NonZeroNonNaN = 3.0.try_into().unwrap();
assert_eq!(x.is_positive_zero(), false);
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn abs(self) -> StrictlyPositive<f64>
pub fn abs(self) -> StrictlyPositive<f64>
Computes the absolute value of self
.
§Examples
let a: NonNaN = 3.0.try_into().unwrap();
let b: NonNaN = (-4.0).try_into().unwrap();
assert_eq!(a.abs(), 3.0);
assert_eq!(b.abs(), 4.0);
assert!(tf64::NEG_ZERO.abs().is_sign_positive());
assert_eq!(tf64::NEG_INFINITY.abs(), tf64::INFINITY);
See f64::abs()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn ceil(self) -> NonNaN<f64>
pub fn ceil(self) -> NonNaN<f64>
Returns the smallest integer greater than or equal to self
.
§Examples
let a: NonNaN = 3.5.try_into().unwrap();
let b: NonNaN = (-3.5).try_into().unwrap();
assert_eq!(a.ceil(), 4.0);
assert_eq!(b.ceil(), -3.0);
assert_eq!(tf64::INFINITY.ceil(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.ceil(), tf64::NEG_INFINITY);
See f64::ceil()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn floor(self) -> NonNaN<f64>
pub fn floor(self) -> NonNaN<f64>
Returns the largest integer less than or equal to self
.
§Examples
let a: NonNaN = 3.5.try_into().unwrap();
let b: NonNaN = (-3.5).try_into().unwrap();
assert_eq!(a.floor(), 3.0);
assert_eq!(b.floor(), -4.0);
assert_eq!(tf64::INFINITY.floor(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.floor(), tf64::NEG_INFINITY);
See f64::floor()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn round(self) -> NonNaN<f64>
pub fn round(self) -> NonNaN<f64>
Returns the nearest integer to self
. If a value is half-way between two
integers, round away from 0.0
.
§Examples
let a: NonNaN = 3.5.try_into().unwrap();
let b: NonNaN = (-3.5).try_into().unwrap();
assert_eq!(a.round(), 4.0);
assert_eq!(b.round(), -4.0);
assert_eq!(tf64::INFINITY.round(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.round(), tf64::NEG_INFINITY);
See f64::round()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn trunc(self) -> NonNaN<f64>
pub fn trunc(self) -> NonNaN<f64>
Returns the integer part of self
.
This means that non-integer numbers are always truncated towards zero.
§Examples
let a: NonNaN = 3.5.try_into().unwrap();
let b: NonNaN = (-3.5).try_into().unwrap();
assert_eq!(a.trunc(), 3.0);
assert_eq!(b.trunc(), -3.0);
assert_eq!(tf64::INFINITY.trunc(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.trunc(), tf64::NEG_INFINITY);
See f64::trunc()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn fract(self) -> f64
pub fn fract(self) -> f64
Returns the fractional part of self
.
For negative numbers, the result is negative except when the fractional part is zero.
For INIFINITY and NEG_INFINITY, the result is NaN.
§Examples
let a: NonNaNFinite = 3.5.try_into().unwrap();
let b: NonNaNFinite = (-3.5).try_into().unwrap();
let c: NonNaNFinite = (-3.0).try_into().unwrap();
assert_eq!(a.fract(), 0.5);
assert_eq!(b.fract(), -0.5);
assert_is_positive_zero!(c.fract());
assert_is_nan!(tf64::INFINITY.fract());
See f64::fract()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn signum(self) -> NonZeroNonNaNFinite<f64>
pub fn signum(self) -> NonZeroNonNaNFinite<f64>
Returns a number that represents the sign of self
.
1.0
if the number is positive,+0.0
orINFINITY
-1.0
if the number is negative,-0.0
orNEG_INFINITY
§Examples
let a: NonNaN = 3.5.try_into().unwrap();
let b: NonNaN = (-3.5).try_into().unwrap();
assert_eq!(a.signum(), 1.0);
assert_eq!(b.signum(), -1.0);
assert_eq!(tf64::ZERO.signum(), 1.0);
assert_eq!(tf64::NEG_ZERO.signum(), -1.0);
assert_eq!(tf64::INFINITY.signum(), 1.0);
assert_eq!(tf64::NEG_INFINITY.signum(), -1.0);
See f64::signum()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn sqrt(self) -> f64
pub fn sqrt(self) -> f64
Returns the square root of a number.
Returns NaN if self
is a negative number other than -0.0
.
Returns -0.0
if self
is -0.0
.
§Examples
let a: NonNaN = 25.0.try_into().unwrap();
let b: NonNaN = (-1).try_into().unwrap();
assert_eq!(a.sqrt(), 5.0);
assert_is_nan!(b.sqrt());
assert!(tf64::is_positive_zero(tf64::ZERO.sqrt().into()));
assert!(tf64::is_negative_zero(tf64::NEG_ZERO.sqrt()));
assert_eq!(tf64::INFINITY.sqrt(), tf64::INFINITY);
assert_is_nan!(tf64::NEG_INFINITY.sqrt());
See f64::sqrt()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn exp(self) -> Positive<f64>
pub fn exp(self) -> Positive<f64>
Returns e^(self)
, (the exponential function).
§Examples
let a: NonNaN = 1.0.try_into().unwrap();
let b: NonNaN = (-1.0).try_into().unwrap();
assert_eq!(a.exp(), core::f64::consts::E);
assert_eq!(b.exp(), 1.0 / core::f64::consts::E);
assert_eq!(tf64::ZERO.exp(), 1.0);
assert_eq!(tf64::NEG_ZERO.exp(), 1.0);
assert_eq!(tf64::INFINITY.exp(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.exp(), tf64::ZERO);
See f64::exp()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn exp2(self) -> Positive<f64>
pub fn exp2(self) -> Positive<f64>
Returns 2^(self)
.
§Examples
let a: NonNaN = 2.0.try_into().unwrap();
let b: NonNaN = (-2.0).try_into().unwrap();
assert_eq!(a.exp2(), 4.0);
assert_eq!(b.exp2(), 0.25);
assert_eq!(tf64::ZERO.exp2(), 1.0);
assert_eq!(tf64::NEG_ZERO.exp2(), 1.0);
assert_eq!(tf64::INFINITY.exp2(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.exp2(), tf64::ZERO);
See f64::exp2()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn ln(self) -> f64
pub fn ln(self) -> f64
Returns the natural logarithm of the number.
Returns NaN if self
is a negative number other than -0.0
.
§Examples
let a: NonNaN = 1.0.try_into().unwrap();
let b: NonNaN = (-1.0).try_into().unwrap();
assert_eq!(a.ln(), 0.0);
assert_is_nan!(b.ln());
assert_eq!(tf64::ZERO.ln(), f64::NEG_INFINITY);
assert_eq!(tf64::NEG_ZERO.ln(), f64::NEG_INFINITY);
assert_eq!(tf64::INFINITY.ln(), tf64::INFINITY);
assert_is_nan!(tf64::NEG_INFINITY.ln());
See f64::ln()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn log2(self) -> f64
pub fn log2(self) -> f64
Returns the base 2 logarithm of the number.
Returns NaN if self
is a negative number other than -0.0
.
§Examples
let a: NonNaN = 2.0.try_into().unwrap();
let b: NonNaN = 1.0.try_into().unwrap();
let c: NonNaN = (-1.0).try_into().unwrap();
assert_eq!(a.log2(), 1.0);
assert!(tf64::is_positive_zero(b.log2()));
assert_is_nan!(c.log2());
assert_eq!(tf64::ZERO.log2(), f64::NEG_INFINITY);
assert_eq!(tf64::NEG_ZERO.log2(), f64::NEG_INFINITY);
assert_eq!(tf64::INFINITY.log2(), tf64::INFINITY);
assert_is_nan!(tf64::NEG_INFINITY.log2());
See f64::log2()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn log10(self) -> f64
pub fn log10(self) -> f64
Returns the base 10 logarithm of the number.
Returns NaN if self
is a negative number other than -0.0
.
§Examples
let a: NonNaN = 100.0.try_into().unwrap();
let b: NonNaN = 1.0.try_into().unwrap();
let c: NonNaN = (-1.0).try_into().unwrap();
assert_eq!(a.log10(), 2.0);
assert_eq!(b.log10(), 0.0);
assert_is_nan!(c.log10());
assert_eq!(tf64::ZERO.log10(), f64::NEG_INFINITY);
assert_eq!(tf64::NEG_ZERO.log10(), f64::NEG_INFINITY);
assert_eq!(tf64::INFINITY.log10(), tf64::INFINITY);
assert_is_nan!(tf64::NEG_INFINITY.log10());
See f64::log10()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn to_degrees(self) -> NonZeroNonNaN<f64>
pub fn to_degrees(self) -> NonZeroNonNaN<f64>
Converts degrees to radians.
§Examples
let a: NonNaN = core::f64::consts::PI.try_into().unwrap();
let b: NonNaN = (-core::f64::consts::PI).try_into().unwrap();
let c: NonNaN = (2.0 * core::f64::consts::PI).try_into().unwrap();
assert_eq!(a.to_degrees(), 180.0);
assert_eq!(b.to_degrees(), -180.0);
assert_eq!(c.to_degrees(), 360.0);
assert_is_positive_zero!(tf64::ZERO.to_degrees());
assert_is_negative_zero!(tf64::NEG_ZERO.to_degrees());
assert_eq!(tf64::INFINITY.to_degrees(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.to_degrees(), tf64::NEG_INFINITY);
See f64::to_degrees()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn to_radians(self) -> NonZeroNonNaN<f64>
pub fn to_radians(self) -> NonZeroNonNaN<f64>
Converts degrees to radians.
§Examples
let a: NonNaN = 180.0.try_into().unwrap();
let b: NonNaN = 0.0.try_into().unwrap();
let c: NonNaN = (-180.0).try_into().unwrap();
let d: NonNaN = 360.0.try_into().unwrap();
assert_eq!(a.to_radians(), core::f64::consts::PI);
assert_eq!(b.to_radians(), 0.0);
assert_eq!(c.to_radians(), -core::f64::consts::PI);
assert_eq!(d.to_radians(), 2.0 * core::f64::consts::PI);
assert_eq!(tf64::INFINITY.to_radians(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.to_radians(), tf64::NEG_INFINITY);
See f64::to_radians()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn cbrt(self) -> NonZeroNonNaN<f64>
pub fn cbrt(self) -> NonZeroNonNaN<f64>
Returns the cube root of a number.
The result will be finite unless the argument is infinite.
§Examples
let a: NonNaN = 8.0.try_into().unwrap();
let b: NonNaN = (-1.0).try_into().unwrap();
assert_eq!(a.cbrt(), 2.0);
assert_eq!(b.cbrt(), -1.0);
assert_eq!(tf64::ZERO.cbrt(), tf64::ZERO);
assert_eq!(tf64::NEG_ZERO.cbrt(), tf64::NEG_ZERO);
assert_eq!(tf64::INFINITY.cbrt(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.cbrt(), tf64::NEG_INFINITY);
See f64::cbrt()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn sin(self) -> f64
pub fn sin(self) -> f64
Computes the sine of a number (in radians).
The result will be in the range [-1, 1] if the input is finite, and NaN if the input is infinite.
§Examples
let a: NonNaNFinite = core::f64::consts::PI.try_into().unwrap();
let b: NonNaNFinite = 0.0.try_into().unwrap();
let c: NonNaNFinite = (-0.0).try_into().unwrap();
let d: NonNaNFinite = (-core::f64::consts::PI).try_into().unwrap();
let e: NonNaNFinite = core::f64::consts::FRAC_PI_2.try_into().unwrap();
let f: NonNaNFinite = (-core::f64::consts::FRAC_PI_2).try_into().unwrap();
assert_relative_eq!(a.sin().get(), 0.0);
assert_relative_eq!(b.sin().get(), 0.0);
assert_relative_eq!(c.sin().get(), 0.0);
assert_relative_eq!(d.sin().get(), 0.0);
assert_relative_eq!(e.sin().get(), 1.0);
assert_relative_eq!(f.sin().get(), -1.0);
assert_is_nan!(tf64::INFINITY.sin());
assert_is_nan!(tf64::NEG_INFINITY.sin());
See f64::sin()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn cos(self) -> f64
pub fn cos(self) -> f64
Computes the cosine of a number (in radians).
The result will be in the range [-1, 1] if the input is finite, and NaN if the input is infinite.
§Examples
let a: NonNaNFinite = core::f64::consts::PI.try_into().unwrap();
let b: NonNaNFinite = 0.0.try_into().unwrap();
let c: NonNaNFinite = (-0.0).try_into().unwrap();
let d: NonNaNFinite = (-core::f64::consts::PI).try_into().unwrap();
let e: NonNaNFinite = core::f64::consts::FRAC_PI_2.try_into().unwrap();
let f: NonNaNFinite = (-core::f64::consts::FRAC_PI_2).try_into().unwrap();
assert_relative_eq!(a.cos().get(), -1.0);
assert_relative_eq!(b.cos().get(), 1.0);
assert_relative_eq!(c.cos().get(), 1.0);
assert_relative_eq!(d.cos().get(), -1.0);
assert_relative_eq!(e.cos().get(), 0.0);
assert_relative_eq!(f.cos().get(), 0.0);
assert_is_nan!(tf64::INFINITY.cos());
assert_is_nan!(tf64::NEG_INFINITY.cos());
See f64::cos()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn tan(self) -> f64
pub fn tan(self) -> f64
Computes the tangent of a number (in radians).
The result NaN if the input is infinite.
§Examples
assert_eq!(tf64::ZERO.tan(), 0.0);
assert_relative_eq!(tf64::consts::FRAC_PI_4.tan().get(), 1.0);
assert_is_nan!(tf64::INFINITY.tan());
assert_is_nan!(tf64::NEG_INFINITY.tan());
See f64::tan()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn asin(self) -> f64
pub fn asin(self) -> f64
Computes the arcsine of a number.
Return value is in radians in the range [-pi/2, pi/2] or NaN if the number is outside the range [-1, 1].
§Examples
let a: NonNaN = 2.0.try_into().unwrap();
let b: NonNaN = (-2.0).try_into().unwrap();
assert_is_nan!(a.asin());
assert_is_nan!(b.asin());
assert!(tf64::is_positive_zero(tf64::ZERO.asin()));
assert!(tf64::is_negative_zero(tf64::NEG_ZERO.asin()));
assert_is_nan!(tf64::INFINITY.asin());
assert_is_nan!(tf64::NEG_INFINITY.asin());
See f64::asin()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn acos(self) -> f64
pub fn acos(self) -> f64
Computes the arccosine of a number.
Return value is in radians in the range [0, pi] or NaN if the number is outside the range [-1, 1].
§Examples
let a: NonNaN = 2.0.try_into().unwrap();
let b: NonNaN = (-2.0).try_into().unwrap();
let c: NonNaN = (-1).try_into().unwrap();
let d: NonNaN = 1.try_into().unwrap();
assert_is_nan!(a.acos());
assert_is_nan!(b.acos());
assert_relative_eq!(c.acos(), core::f64::consts::PI);
assert_relative_eq!(d.acos(), 0.0);
assert_relative_eq!(tf64::ZERO.acos(), core::f64::consts::FRAC_PI_2);
assert_is_nan!(tf64::INFINITY.acos());
assert_is_nan!(tf64::NEG_INFINITY.acos());
See f64::acos()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn atan(self) -> NonZeroNonNaNFinite<f64>
pub fn atan(self) -> NonZeroNonNaNFinite<f64>
Computes the arctangent of a number.
Return value is in radians in the range [-pi/2, pi/2];
§Examples
assert_is_positive_zero!(tf64::ZERO.atan());
assert_is_negative_zero!(tf64::NEG_ZERO.atan());
assert_relative_eq!(tf64::INFINITY.atan().get(), core::f64::consts::FRAC_PI_2);
assert_relative_eq!(tf64::NEG_INFINITY.atan().get(), -core::f64::consts::FRAC_PI_2);
See f64::atan()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn exp_m1(self) -> NonZeroNonNaN<f64>
pub fn exp_m1(self) -> NonZeroNonNaN<f64>
Returns e^(self) - 1
in a way that is accurate even if the number is close to zero.
§Examples
assert_is_positive_zero!(tf64::ZERO.exp_m1());
assert_is_negative_zero!(tf64::NEG_ZERO.exp_m1());
assert_eq!(tf64::INFINITY.exp_m1(), f64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.exp_m1(), -1.0);
See f64::exp_m1()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn ln_1p(self) -> f64
pub fn ln_1p(self) -> f64
Returns ln(1+n)
(natural logarithm) more accurately than if the operations were performed separately.
§Examples
let a: NonNaN = (-1.0).try_into().unwrap();
assert_eq!(a.ln_1p(), f64::NEG_INFINITY);
assert!(tf64::is_positive_zero(tf64::ZERO.ln_1p().get()));
assert!(tf64::is_negative_zero(tf64::NEG_ZERO.ln_1p()));
assert_eq!(tf64::INFINITY.ln_1p(), f64::INFINITY);
assert_is_nan!(tf64::NEG_INFINITY.ln_1p());
See f64::ln_1p()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn sinh(self) -> NonZeroNonNaN<f64>
pub fn sinh(self) -> NonZeroNonNaN<f64>
Hyperbolic sine function.
§Examples
assert_is_positive_zero!(tf64::ZERO.sinh());
assert_is_negative_zero!(tf64::NEG_ZERO.sinh());
assert_eq!(tf64::INFINITY.sinh(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.sinh(), tf64::NEG_INFINITY);
See f64::sinh()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn cosh(self) -> StrictlyPositive<f64>
pub fn cosh(self) -> StrictlyPositive<f64>
Hyperbolic cosine function.
§Examples
assert_eq!(tf64::ZERO.cosh(), 1.0);
assert_eq!(tf64::NEG_ZERO.cosh(), 1.0);
assert_eq!(tf64::INFINITY.cosh(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.cosh(), tf64::INFINITY);
See f64::cosh()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn tanh(self) -> NonZeroNonNaNFinite<f64>
pub fn tanh(self) -> NonZeroNonNaNFinite<f64>
Hyperbolic tangent function.
§Examples
assert_is_positive_zero!(tf64::ZERO.tanh());
assert_is_negative_zero!(tf64::NEG_ZERO.tanh());
assert_eq!(tf64::INFINITY.tanh(), 1.0);
assert_eq!(tf64::NEG_INFINITY.tanh(), -1.0);
See f64::tanh()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn asinh(self) -> NonZeroNonNaN<f64>
pub fn asinh(self) -> NonZeroNonNaN<f64>
Inverse hyperbolic sine function.
§Examples
assert_is_positive_zero!(tf64::ZERO.asinh());
assert_is_negative_zero!(tf64::NEG_ZERO.asinh());
assert_eq!(tf64::INFINITY.asinh(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.asinh(), tf64::NEG_INFINITY);
See f64::asinh()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn acosh(self) -> f64
pub fn acosh(self) -> f64
Inverse hyperbolic cosine function.
§Examples
let a: NonNaN = 1.0.try_into().unwrap();
assert_is_positive_zero!(a.acosh());
assert_is_nan!(tf64::ZERO.acosh());
assert_eq!(tf64::INFINITY.acosh(), tf64::INFINITY);
assert_is_nan!(tf64::NEG_INFINITY.acosh());
See f64::acosh()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn atanh(self) -> f64
pub fn atanh(self) -> f64
Inverse hyperbolic tangent function.
§Examples
let a: NonNaN = 1.0.try_into().unwrap();
let b: NonNaN = (-1.0).try_into().unwrap();
assert_eq!(a.atanh(), tf64::INFINITY);
assert_eq!(b.atanh(), tf64::NEG_INFINITY);
assert_is_positive_zero!(tf64::ZERO.atanh());
assert_is_negative_zero!(tf64::NEG_ZERO.atanh());
assert_is_nan!(tf64::INFINITY.atanh());
assert_is_nan!(tf64::NEG_INFINITY.atanh());
See f64::atanh()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn recip(self) -> NonNaNFinite<f64>
pub fn recip(self) -> NonNaNFinite<f64>
Takes the reciprocal (inverse) of a number, 1/x
.
§Examples
let a: NonNaN = 1.0.try_into().unwrap();
let b: NonNaN = (-1.0).try_into().unwrap();
assert_eq!(a.recip(), 1.0);
assert_eq!(b.recip(), -1.0);
assert_eq!(tf64::ZERO.recip(), tf64::INFINITY);
assert_eq!(tf64::NEG_ZERO.recip(), tf64::NEG_INFINITY);
assert_is_positive_zero!(tf64::INFINITY.recip());
assert_is_negative_zero!(tf64::NEG_INFINITY.recip());
See f64::recip()
for more details.
source§impl NonZeroNonNaN<f64>
impl NonZeroNonNaN<f64>
sourcepub fn powi(self, n: i32) -> NonNaN<f64>
pub fn powi(self, n: i32) -> NonNaN<f64>
Raises a number to an integer power.
Using this function is generally faster than using powf
.
It might have a different sequence of rounding operations than powf
,
so the results are not guaranteed to agree.
§Examples
let x: NonNaN = (-2.0).try_into().unwrap();
assert_eq!(x.powi(3), -8.0);
assert_eq!(x.powi(2), 4.0);
assert_eq!(x.powi(1), -2.0);
assert_eq!(x.powi(0), 1.0);
assert_eq!(x.powi(-1), -0.5);
assert_eq!(x.powi(-2), 0.25);
assert_eq!(x.powi(-3), -0.125);
See f64::powi()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn abs(self) -> StrictlyPositive<f32>
pub fn abs(self) -> StrictlyPositive<f32>
Computes the absolute value of self
.
§Examples
let a: NonNaN = 3.0.try_into().unwrap();
let b: NonNaN = (-4.0).try_into().unwrap();
assert_eq!(a.abs(), 3.0);
assert_eq!(b.abs(), 4.0);
assert!(tf64::NEG_ZERO.abs().is_sign_positive());
assert_eq!(tf64::NEG_INFINITY.abs(), tf64::INFINITY);
See f64::abs()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn ceil(self) -> NonNaN<f32>
pub fn ceil(self) -> NonNaN<f32>
Returns the smallest integer greater than or equal to self
.
§Examples
let a: NonNaN = 3.5.try_into().unwrap();
let b: NonNaN = (-3.5).try_into().unwrap();
assert_eq!(a.ceil(), 4.0);
assert_eq!(b.ceil(), -3.0);
assert_eq!(tf64::INFINITY.ceil(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.ceil(), tf64::NEG_INFINITY);
See f64::ceil()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn floor(self) -> NonNaN<f32>
pub fn floor(self) -> NonNaN<f32>
Returns the largest integer less than or equal to self
.
§Examples
let a: NonNaN = 3.5.try_into().unwrap();
let b: NonNaN = (-3.5).try_into().unwrap();
assert_eq!(a.floor(), 3.0);
assert_eq!(b.floor(), -4.0);
assert_eq!(tf64::INFINITY.floor(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.floor(), tf64::NEG_INFINITY);
See f64::floor()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn round(self) -> NonNaN<f32>
pub fn round(self) -> NonNaN<f32>
Returns the nearest integer to self
. If a value is half-way between two
integers, round away from 0.0
.
§Examples
let a: NonNaN = 3.5.try_into().unwrap();
let b: NonNaN = (-3.5).try_into().unwrap();
assert_eq!(a.round(), 4.0);
assert_eq!(b.round(), -4.0);
assert_eq!(tf64::INFINITY.round(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.round(), tf64::NEG_INFINITY);
See f64::round()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn trunc(self) -> NonNaN<f32>
pub fn trunc(self) -> NonNaN<f32>
Returns the integer part of self
.
This means that non-integer numbers are always truncated towards zero.
§Examples
let a: NonNaN = 3.5.try_into().unwrap();
let b: NonNaN = (-3.5).try_into().unwrap();
assert_eq!(a.trunc(), 3.0);
assert_eq!(b.trunc(), -3.0);
assert_eq!(tf64::INFINITY.trunc(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.trunc(), tf64::NEG_INFINITY);
See f64::trunc()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn fract(self) -> f32
pub fn fract(self) -> f32
Returns the fractional part of self
.
For negative numbers, the result is negative except when the fractional part is zero.
For INIFINITY and NEG_INFINITY, the result is NaN.
§Examples
let a: NonNaNFinite = 3.5.try_into().unwrap();
let b: NonNaNFinite = (-3.5).try_into().unwrap();
let c: NonNaNFinite = (-3.0).try_into().unwrap();
assert_eq!(a.fract(), 0.5);
assert_eq!(b.fract(), -0.5);
assert_is_positive_zero!(c.fract());
assert_is_nan!(tf64::INFINITY.fract());
See f64::fract()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn signum(self) -> NonZeroNonNaNFinite<f32>
pub fn signum(self) -> NonZeroNonNaNFinite<f32>
Returns a number that represents the sign of self
.
1.0
if the number is positive,+0.0
orINFINITY
-1.0
if the number is negative,-0.0
orNEG_INFINITY
§Examples
let a: NonNaN = 3.5.try_into().unwrap();
let b: NonNaN = (-3.5).try_into().unwrap();
assert_eq!(a.signum(), 1.0);
assert_eq!(b.signum(), -1.0);
assert_eq!(tf64::ZERO.signum(), 1.0);
assert_eq!(tf64::NEG_ZERO.signum(), -1.0);
assert_eq!(tf64::INFINITY.signum(), 1.0);
assert_eq!(tf64::NEG_INFINITY.signum(), -1.0);
See f64::signum()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn sqrt(self) -> f32
pub fn sqrt(self) -> f32
Returns the square root of a number.
Returns NaN if self
is a negative number other than -0.0
.
Returns -0.0
if self
is -0.0
.
§Examples
let a: NonNaN = 25.0.try_into().unwrap();
let b: NonNaN = (-1).try_into().unwrap();
assert_eq!(a.sqrt(), 5.0);
assert_is_nan!(b.sqrt());
assert!(tf64::is_positive_zero(tf64::ZERO.sqrt().into()));
assert!(tf64::is_negative_zero(tf64::NEG_ZERO.sqrt()));
assert_eq!(tf64::INFINITY.sqrt(), tf64::INFINITY);
assert_is_nan!(tf64::NEG_INFINITY.sqrt());
See f64::sqrt()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn exp(self) -> Positive<f32>
pub fn exp(self) -> Positive<f32>
Returns e^(self)
, (the exponential function).
§Examples
let a: NonNaN = 1.0.try_into().unwrap();
let b: NonNaN = (-1.0).try_into().unwrap();
assert_eq!(a.exp(), core::f64::consts::E);
assert_eq!(b.exp(), 1.0 / core::f64::consts::E);
assert_eq!(tf64::ZERO.exp(), 1.0);
assert_eq!(tf64::NEG_ZERO.exp(), 1.0);
assert_eq!(tf64::INFINITY.exp(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.exp(), tf64::ZERO);
See f64::exp()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn exp2(self) -> Positive<f32>
pub fn exp2(self) -> Positive<f32>
Returns 2^(self)
.
§Examples
let a: NonNaN = 2.0.try_into().unwrap();
let b: NonNaN = (-2.0).try_into().unwrap();
assert_eq!(a.exp2(), 4.0);
assert_eq!(b.exp2(), 0.25);
assert_eq!(tf64::ZERO.exp2(), 1.0);
assert_eq!(tf64::NEG_ZERO.exp2(), 1.0);
assert_eq!(tf64::INFINITY.exp2(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.exp2(), tf64::ZERO);
See f64::exp2()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn ln(self) -> f32
pub fn ln(self) -> f32
Returns the natural logarithm of the number.
Returns NaN if self
is a negative number other than -0.0
.
§Examples
let a: NonNaN = 1.0.try_into().unwrap();
let b: NonNaN = (-1.0).try_into().unwrap();
assert_eq!(a.ln(), 0.0);
assert_is_nan!(b.ln());
assert_eq!(tf64::ZERO.ln(), f64::NEG_INFINITY);
assert_eq!(tf64::NEG_ZERO.ln(), f64::NEG_INFINITY);
assert_eq!(tf64::INFINITY.ln(), tf64::INFINITY);
assert_is_nan!(tf64::NEG_INFINITY.ln());
See f64::ln()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn log2(self) -> f32
pub fn log2(self) -> f32
Returns the base 2 logarithm of the number.
Returns NaN if self
is a negative number other than -0.0
.
§Examples
let a: NonNaN = 2.0.try_into().unwrap();
let b: NonNaN = 1.0.try_into().unwrap();
let c: NonNaN = (-1.0).try_into().unwrap();
assert_eq!(a.log2(), 1.0);
assert!(tf64::is_positive_zero(b.log2()));
assert_is_nan!(c.log2());
assert_eq!(tf64::ZERO.log2(), f64::NEG_INFINITY);
assert_eq!(tf64::NEG_ZERO.log2(), f64::NEG_INFINITY);
assert_eq!(tf64::INFINITY.log2(), tf64::INFINITY);
assert_is_nan!(tf64::NEG_INFINITY.log2());
See f64::log2()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn log10(self) -> f32
pub fn log10(self) -> f32
Returns the base 10 logarithm of the number.
Returns NaN if self
is a negative number other than -0.0
.
§Examples
let a: NonNaN = 100.0.try_into().unwrap();
let b: NonNaN = 1.0.try_into().unwrap();
let c: NonNaN = (-1.0).try_into().unwrap();
assert_eq!(a.log10(), 2.0);
assert_eq!(b.log10(), 0.0);
assert_is_nan!(c.log10());
assert_eq!(tf64::ZERO.log10(), f64::NEG_INFINITY);
assert_eq!(tf64::NEG_ZERO.log10(), f64::NEG_INFINITY);
assert_eq!(tf64::INFINITY.log10(), tf64::INFINITY);
assert_is_nan!(tf64::NEG_INFINITY.log10());
See f64::log10()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn to_degrees(self) -> NonZeroNonNaN<f32>
pub fn to_degrees(self) -> NonZeroNonNaN<f32>
Converts degrees to radians.
§Examples
let a: NonNaN = core::f64::consts::PI.try_into().unwrap();
let b: NonNaN = (-core::f64::consts::PI).try_into().unwrap();
let c: NonNaN = (2.0 * core::f64::consts::PI).try_into().unwrap();
assert_eq!(a.to_degrees(), 180.0);
assert_eq!(b.to_degrees(), -180.0);
assert_eq!(c.to_degrees(), 360.0);
assert_is_positive_zero!(tf64::ZERO.to_degrees());
assert_is_negative_zero!(tf64::NEG_ZERO.to_degrees());
assert_eq!(tf64::INFINITY.to_degrees(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.to_degrees(), tf64::NEG_INFINITY);
See f64::to_degrees()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn to_radians(self) -> NonZeroNonNaN<f32>
pub fn to_radians(self) -> NonZeroNonNaN<f32>
Converts degrees to radians.
§Examples
let a: NonNaN = 180.0.try_into().unwrap();
let b: NonNaN = 0.0.try_into().unwrap();
let c: NonNaN = (-180.0).try_into().unwrap();
let d: NonNaN = 360.0.try_into().unwrap();
assert_eq!(a.to_radians(), core::f64::consts::PI);
assert_eq!(b.to_radians(), 0.0);
assert_eq!(c.to_radians(), -core::f64::consts::PI);
assert_eq!(d.to_radians(), 2.0 * core::f64::consts::PI);
assert_eq!(tf64::INFINITY.to_radians(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.to_radians(), tf64::NEG_INFINITY);
See f64::to_radians()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn cbrt(self) -> NonZeroNonNaN<f32>
pub fn cbrt(self) -> NonZeroNonNaN<f32>
Returns the cube root of a number.
The result will be finite unless the argument is infinite.
§Examples
let a: NonNaN = 8.0.try_into().unwrap();
let b: NonNaN = (-1.0).try_into().unwrap();
assert_eq!(a.cbrt(), 2.0);
assert_eq!(b.cbrt(), -1.0);
assert_eq!(tf64::ZERO.cbrt(), tf64::ZERO);
assert_eq!(tf64::NEG_ZERO.cbrt(), tf64::NEG_ZERO);
assert_eq!(tf64::INFINITY.cbrt(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.cbrt(), tf64::NEG_INFINITY);
See f64::cbrt()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn sin(self) -> f32
pub fn sin(self) -> f32
Computes the sine of a number (in radians).
The result will be in the range [-1, 1] if the input is finite, and NaN if the input is infinite.
§Examples
let a: NonNaNFinite = core::f64::consts::PI.try_into().unwrap();
let b: NonNaNFinite = 0.0.try_into().unwrap();
let c: NonNaNFinite = (-0.0).try_into().unwrap();
let d: NonNaNFinite = (-core::f64::consts::PI).try_into().unwrap();
let e: NonNaNFinite = core::f64::consts::FRAC_PI_2.try_into().unwrap();
let f: NonNaNFinite = (-core::f64::consts::FRAC_PI_2).try_into().unwrap();
assert_relative_eq!(a.sin().get(), 0.0);
assert_relative_eq!(b.sin().get(), 0.0);
assert_relative_eq!(c.sin().get(), 0.0);
assert_relative_eq!(d.sin().get(), 0.0);
assert_relative_eq!(e.sin().get(), 1.0);
assert_relative_eq!(f.sin().get(), -1.0);
assert_is_nan!(tf64::INFINITY.sin());
assert_is_nan!(tf64::NEG_INFINITY.sin());
See f64::sin()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn cos(self) -> f32
pub fn cos(self) -> f32
Computes the cosine of a number (in radians).
The result will be in the range [-1, 1] if the input is finite, and NaN if the input is infinite.
§Examples
let a: NonNaNFinite = core::f64::consts::PI.try_into().unwrap();
let b: NonNaNFinite = 0.0.try_into().unwrap();
let c: NonNaNFinite = (-0.0).try_into().unwrap();
let d: NonNaNFinite = (-core::f64::consts::PI).try_into().unwrap();
let e: NonNaNFinite = core::f64::consts::FRAC_PI_2.try_into().unwrap();
let f: NonNaNFinite = (-core::f64::consts::FRAC_PI_2).try_into().unwrap();
assert_relative_eq!(a.cos().get(), -1.0);
assert_relative_eq!(b.cos().get(), 1.0);
assert_relative_eq!(c.cos().get(), 1.0);
assert_relative_eq!(d.cos().get(), -1.0);
assert_relative_eq!(e.cos().get(), 0.0);
assert_relative_eq!(f.cos().get(), 0.0);
assert_is_nan!(tf64::INFINITY.cos());
assert_is_nan!(tf64::NEG_INFINITY.cos());
See f64::cos()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn tan(self) -> f32
pub fn tan(self) -> f32
Computes the tangent of a number (in radians).
The result NaN if the input is infinite.
§Examples
assert_eq!(tf64::ZERO.tan(), 0.0);
assert_relative_eq!(tf64::consts::FRAC_PI_4.tan().get(), 1.0);
assert_is_nan!(tf64::INFINITY.tan());
assert_is_nan!(tf64::NEG_INFINITY.tan());
See f64::tan()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn asin(self) -> f32
pub fn asin(self) -> f32
Computes the arcsine of a number.
Return value is in radians in the range [-pi/2, pi/2] or NaN if the number is outside the range [-1, 1].
§Examples
let a: NonNaN = 2.0.try_into().unwrap();
let b: NonNaN = (-2.0).try_into().unwrap();
assert_is_nan!(a.asin());
assert_is_nan!(b.asin());
assert!(tf64::is_positive_zero(tf64::ZERO.asin()));
assert!(tf64::is_negative_zero(tf64::NEG_ZERO.asin()));
assert_is_nan!(tf64::INFINITY.asin());
assert_is_nan!(tf64::NEG_INFINITY.asin());
See f64::asin()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn acos(self) -> f32
pub fn acos(self) -> f32
Computes the arccosine of a number.
Return value is in radians in the range [0, pi] or NaN if the number is outside the range [-1, 1].
§Examples
let a: NonNaN = 2.0.try_into().unwrap();
let b: NonNaN = (-2.0).try_into().unwrap();
let c: NonNaN = (-1).try_into().unwrap();
let d: NonNaN = 1.try_into().unwrap();
assert_is_nan!(a.acos());
assert_is_nan!(b.acos());
assert_relative_eq!(c.acos(), core::f64::consts::PI);
assert_relative_eq!(d.acos(), 0.0);
assert_relative_eq!(tf64::ZERO.acos(), core::f64::consts::FRAC_PI_2);
assert_is_nan!(tf64::INFINITY.acos());
assert_is_nan!(tf64::NEG_INFINITY.acos());
See f64::acos()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn atan(self) -> NonZeroNonNaNFinite<f32>
pub fn atan(self) -> NonZeroNonNaNFinite<f32>
Computes the arctangent of a number.
Return value is in radians in the range [-pi/2, pi/2];
§Examples
assert_is_positive_zero!(tf64::ZERO.atan());
assert_is_negative_zero!(tf64::NEG_ZERO.atan());
assert_relative_eq!(tf64::INFINITY.atan().get(), core::f64::consts::FRAC_PI_2);
assert_relative_eq!(tf64::NEG_INFINITY.atan().get(), -core::f64::consts::FRAC_PI_2);
See f64::atan()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn exp_m1(self) -> NonZeroNonNaN<f32>
pub fn exp_m1(self) -> NonZeroNonNaN<f32>
Returns e^(self) - 1
in a way that is accurate even if the number is close to zero.
§Examples
assert_is_positive_zero!(tf64::ZERO.exp_m1());
assert_is_negative_zero!(tf64::NEG_ZERO.exp_m1());
assert_eq!(tf64::INFINITY.exp_m1(), f64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.exp_m1(), -1.0);
See f64::exp_m1()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn ln_1p(self) -> f32
pub fn ln_1p(self) -> f32
Returns ln(1+n)
(natural logarithm) more accurately than if the operations were performed separately.
§Examples
let a: NonNaN = (-1.0).try_into().unwrap();
assert_eq!(a.ln_1p(), f64::NEG_INFINITY);
assert!(tf64::is_positive_zero(tf64::ZERO.ln_1p().get()));
assert!(tf64::is_negative_zero(tf64::NEG_ZERO.ln_1p()));
assert_eq!(tf64::INFINITY.ln_1p(), f64::INFINITY);
assert_is_nan!(tf64::NEG_INFINITY.ln_1p());
See f64::ln_1p()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn sinh(self) -> NonZeroNonNaN<f32>
pub fn sinh(self) -> NonZeroNonNaN<f32>
Hyperbolic sine function.
§Examples
assert_is_positive_zero!(tf64::ZERO.sinh());
assert_is_negative_zero!(tf64::NEG_ZERO.sinh());
assert_eq!(tf64::INFINITY.sinh(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.sinh(), tf64::NEG_INFINITY);
See f64::sinh()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn cosh(self) -> StrictlyPositive<f32>
pub fn cosh(self) -> StrictlyPositive<f32>
Hyperbolic cosine function.
§Examples
assert_eq!(tf64::ZERO.cosh(), 1.0);
assert_eq!(tf64::NEG_ZERO.cosh(), 1.0);
assert_eq!(tf64::INFINITY.cosh(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.cosh(), tf64::INFINITY);
See f64::cosh()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn tanh(self) -> NonZeroNonNaNFinite<f32>
pub fn tanh(self) -> NonZeroNonNaNFinite<f32>
Hyperbolic tangent function.
§Examples
assert_is_positive_zero!(tf64::ZERO.tanh());
assert_is_negative_zero!(tf64::NEG_ZERO.tanh());
assert_eq!(tf64::INFINITY.tanh(), 1.0);
assert_eq!(tf64::NEG_INFINITY.tanh(), -1.0);
See f64::tanh()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn asinh(self) -> NonZeroNonNaN<f32>
pub fn asinh(self) -> NonZeroNonNaN<f32>
Inverse hyperbolic sine function.
§Examples
assert_is_positive_zero!(tf64::ZERO.asinh());
assert_is_negative_zero!(tf64::NEG_ZERO.asinh());
assert_eq!(tf64::INFINITY.asinh(), tf64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.asinh(), tf64::NEG_INFINITY);
See f64::asinh()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn acosh(self) -> f32
pub fn acosh(self) -> f32
Inverse hyperbolic cosine function.
§Examples
let a: NonNaN = 1.0.try_into().unwrap();
assert_is_positive_zero!(a.acosh());
assert_is_nan!(tf64::ZERO.acosh());
assert_eq!(tf64::INFINITY.acosh(), tf64::INFINITY);
assert_is_nan!(tf64::NEG_INFINITY.acosh());
See f64::acosh()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn atanh(self) -> f32
pub fn atanh(self) -> f32
Inverse hyperbolic tangent function.
§Examples
let a: NonNaN = 1.0.try_into().unwrap();
let b: NonNaN = (-1.0).try_into().unwrap();
assert_eq!(a.atanh(), tf64::INFINITY);
assert_eq!(b.atanh(), tf64::NEG_INFINITY);
assert_is_positive_zero!(tf64::ZERO.atanh());
assert_is_negative_zero!(tf64::NEG_ZERO.atanh());
assert_is_nan!(tf64::INFINITY.atanh());
assert_is_nan!(tf64::NEG_INFINITY.atanh());
See f64::atanh()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn recip(self) -> NonNaNFinite<f32>
pub fn recip(self) -> NonNaNFinite<f32>
Takes the reciprocal (inverse) of a number, 1/x
.
§Examples
let a: NonNaN = 1.0.try_into().unwrap();
let b: NonNaN = (-1.0).try_into().unwrap();
assert_eq!(a.recip(), 1.0);
assert_eq!(b.recip(), -1.0);
assert_eq!(tf64::ZERO.recip(), tf64::INFINITY);
assert_eq!(tf64::NEG_ZERO.recip(), tf64::NEG_INFINITY);
assert_is_positive_zero!(tf64::INFINITY.recip());
assert_is_negative_zero!(tf64::NEG_INFINITY.recip());
See f64::recip()
for more details.
source§impl NonZeroNonNaN<f32>
impl NonZeroNonNaN<f32>
sourcepub fn powi(self, n: i32) -> NonNaN<f32>
pub fn powi(self, n: i32) -> NonNaN<f32>
Raises a number to an integer power.
Using this function is generally faster than using powf
.
It might have a different sequence of rounding operations than powf
,
so the results are not guaranteed to agree.
§Examples
let x: NonNaN = (-2.0).try_into().unwrap();
assert_eq!(x.powi(3), -8.0);
assert_eq!(x.powi(2), 4.0);
assert_eq!(x.powi(1), -2.0);
assert_eq!(x.powi(0), 1.0);
assert_eq!(x.powi(-1), -0.5);
assert_eq!(x.powi(-2), 0.25);
assert_eq!(x.powi(-3), -0.125);
See f64::powi()
for more details.
Trait Implementations§
source§impl Add<NegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Add<NegativeFinite<f32>> for NonZeroNonNaN<f32>
source§impl Add<NegativeFinite> for NonZeroNonNaN<f64>
impl Add<NegativeFinite> for NonZeroNonNaN<f64>
source§impl Add<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Add<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§impl Add<NonNaNFinite> for NonZeroNonNaN<f64>
impl Add<NonNaNFinite> for NonZeroNonNaN<f64>
source§impl Add<NonZeroNonNaN<f32>> for NegativeFinite<f32>
impl Add<NonZeroNonNaN<f32>> for NegativeFinite<f32>
source§impl Add<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
impl Add<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
source§impl Add<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
impl Add<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
source§impl Add<NonZeroNonNaN<f32>> for PositiveFinite<f32>
impl Add<NonZeroNonNaN<f32>> for PositiveFinite<f32>
source§impl Add<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
impl Add<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
source§impl Add<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
impl Add<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
source§impl Add<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl Add<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§impl Add<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
impl Add<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
source§impl Add<NonZeroNonNaN> for NegativeFinite<f64>
impl Add<NonZeroNonNaN> for NegativeFinite<f64>
source§impl Add<NonZeroNonNaN> for NonNaNFinite<f64>
impl Add<NonZeroNonNaN> for NonNaNFinite<f64>
source§impl Add<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
impl Add<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
source§impl Add<NonZeroNonNaN> for PositiveFinite<f64>
impl Add<NonZeroNonNaN> for PositiveFinite<f64>
source§impl Add<NonZeroNonNaN> for StrictlyNegative<f64>
impl Add<NonZeroNonNaN> for StrictlyNegative<f64>
source§impl Add<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
impl Add<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
source§impl Add<NonZeroNonNaN> for StrictlyPositive<f64>
impl Add<NonZeroNonNaN> for StrictlyPositive<f64>
source§impl Add<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
impl Add<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
source§impl Add<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Add<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§impl Add<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
impl Add<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
source§impl Add<PositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Add<PositiveFinite<f32>> for NonZeroNonNaN<f32>
source§impl Add<PositiveFinite> for NonZeroNonNaN<f64>
impl Add<PositiveFinite> for NonZeroNonNaN<f64>
source§impl Add<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
impl Add<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
source§impl Add<StrictlyNegative> for NonZeroNonNaN<f64>
impl Add<StrictlyNegative> for NonZeroNonNaN<f64>
source§impl Add<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Add<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
source§impl Add<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
impl Add<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
source§impl Add<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl Add<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§impl Add<StrictlyPositive> for NonZeroNonNaN<f64>
impl Add<StrictlyPositive> for NonZeroNonNaN<f64>
source§impl Add<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Add<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
source§impl Add<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
impl Add<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
source§impl Add for NonZeroNonNaN<f64>
impl Add for NonZeroNonNaN<f64>
source§impl Add for NonZeroNonNaN<f32>
impl Add for NonZeroNonNaN<f32>
source§impl Atan2<NegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Atan2<NegativeFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<NegativeFinite> for NonZeroNonNaN<f64>
impl Atan2<NegativeFinite> for NonZeroNonNaN<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Atan2<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<NonNaNFinite> for NonZeroNonNaN<f64>
impl Atan2<NonNaNFinite> for NonZeroNonNaN<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN<f32>> for Negative<f32>
impl Atan2<NonZeroNonNaN<f32>> for Negative<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN<f32>> for NegativeFinite<f32>
impl Atan2<NonZeroNonNaN<f32>> for NegativeFinite<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN<f32>> for NonNaN<f32>
impl Atan2<NonZeroNonNaN<f32>> for NonNaN<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
impl Atan2<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN<f32>> for NonZeroNonNaN<f32>
impl Atan2<NonZeroNonNaN<f32>> for NonZeroNonNaN<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
impl Atan2<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN<f32>> for Positive<f32>
impl Atan2<NonZeroNonNaN<f32>> for Positive<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN<f32>> for PositiveFinite<f32>
impl Atan2<NonZeroNonNaN<f32>> for PositiveFinite<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
impl Atan2<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
impl Atan2<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl Atan2<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
impl Atan2<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN> for Negative<f64>
impl Atan2<NonZeroNonNaN> for Negative<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN> for NegativeFinite<f64>
impl Atan2<NonZeroNonNaN> for NegativeFinite<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN> for NonNaN<f64>
impl Atan2<NonZeroNonNaN> for NonNaN<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN> for NonNaNFinite<f64>
impl Atan2<NonZeroNonNaN> for NonNaNFinite<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN> for NonZeroNonNaN<f64>
impl Atan2<NonZeroNonNaN> for NonZeroNonNaN<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
impl Atan2<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN> for Positive<f64>
impl Atan2<NonZeroNonNaN> for Positive<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN> for PositiveFinite<f64>
impl Atan2<NonZeroNonNaN> for PositiveFinite<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN> for StrictlyNegative<f64>
impl Atan2<NonZeroNonNaN> for StrictlyNegative<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
impl Atan2<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN> for StrictlyPositive<f64>
impl Atan2<NonZeroNonNaN> for StrictlyPositive<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
impl Atan2<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Atan2<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
impl Atan2<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<PositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Atan2<PositiveFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<PositiveFinite> for NonZeroNonNaN<f64>
impl Atan2<PositiveFinite> for NonZeroNonNaN<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
impl Atan2<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<StrictlyNegative> for NonZeroNonNaN<f64>
impl Atan2<StrictlyNegative> for NonZeroNonNaN<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Atan2<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
impl Atan2<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl Atan2<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<StrictlyPositive> for NonZeroNonNaN<f64>
impl Atan2<StrictlyPositive> for NonZeroNonNaN<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Atan2<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
impl Atan2<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl<T: Clone> Clone for NonZeroNonNaN<T>
impl<T: Clone> Clone for NonZeroNonNaN<T>
source§fn clone(&self) -> NonZeroNonNaN<T>
fn clone(&self) -> NonZeroNonNaN<T>
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresource§impl Copysign<Negative<f32>> for NonZeroNonNaN<f32>
impl Copysign<Negative<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyNegative<f32>
type Output = StrictlyNegative<f32>
Copysign::copysign()
.source§impl Copysign<Negative> for NonZeroNonNaN<f64>
impl Copysign<Negative> for NonZeroNonNaN<f64>
source§type Output = StrictlyNegative
type Output = StrictlyNegative
Copysign::copysign()
.source§impl Copysign<NegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Copysign<NegativeFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyNegative<f32>
type Output = StrictlyNegative<f32>
Copysign::copysign()
.source§impl Copysign<NegativeFinite> for NonZeroNonNaN<f64>
impl Copysign<NegativeFinite> for NonZeroNonNaN<f64>
source§type Output = StrictlyNegative
type Output = StrictlyNegative
Copysign::copysign()
.source§impl Copysign<NonNaN<f32>> for NonZeroNonNaN<f32>
impl Copysign<NonNaN<f32>> for NonZeroNonNaN<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Copysign::copysign()
.source§impl Copysign<NonNaN> for NonZeroNonNaN<f64>
impl Copysign<NonNaN> for NonZeroNonNaN<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Copysign::copysign()
.source§impl Copysign<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Copysign<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Copysign::copysign()
.source§impl Copysign<NonNaNFinite> for NonZeroNonNaN<f64>
impl Copysign<NonNaNFinite> for NonZeroNonNaN<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN<f32>> for NegativeFinite<f32>
impl Copysign<NonZeroNonNaN<f32>> for NegativeFinite<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
impl Copysign<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN<f32>> for NonZeroNonNaN<f32>
impl Copysign<NonZeroNonNaN<f32>> for NonZeroNonNaN<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
impl Copysign<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
source§type Output = NonZeroNonNaNFinite<f32>
type Output = NonZeroNonNaNFinite<f32>
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN<f32>> for PositiveFinite<f32>
impl Copysign<NonZeroNonNaN<f32>> for PositiveFinite<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
impl Copysign<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
impl Copysign<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
source§type Output = NonZeroNonNaNFinite<f32>
type Output = NonZeroNonNaNFinite<f32>
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl Copysign<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
impl Copysign<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
source§type Output = NonZeroNonNaNFinite<f32>
type Output = NonZeroNonNaNFinite<f32>
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN> for Negative<f64>
impl Copysign<NonZeroNonNaN> for Negative<f64>
source§type Output = NonNaN
type Output = NonNaN
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN> for NegativeFinite<f64>
impl Copysign<NonZeroNonNaN> for NegativeFinite<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN> for NonNaN<f64>
impl Copysign<NonZeroNonNaN> for NonNaN<f64>
source§type Output = NonNaN
type Output = NonNaN
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN> for NonNaNFinite<f64>
impl Copysign<NonZeroNonNaN> for NonNaNFinite<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN> for NonZeroNonNaN<f64>
impl Copysign<NonZeroNonNaN> for NonZeroNonNaN<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
impl Copysign<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
source§type Output = NonZeroNonNaNFinite
type Output = NonZeroNonNaNFinite
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN> for Positive<f64>
impl Copysign<NonZeroNonNaN> for Positive<f64>
source§type Output = NonNaN
type Output = NonNaN
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN> for PositiveFinite<f64>
impl Copysign<NonZeroNonNaN> for PositiveFinite<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN> for StrictlyNegative<f64>
impl Copysign<NonZeroNonNaN> for StrictlyNegative<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
impl Copysign<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
source§type Output = NonZeroNonNaNFinite
type Output = NonZeroNonNaNFinite
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN> for StrictlyPositive<f64>
impl Copysign<NonZeroNonNaN> for StrictlyPositive<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
impl Copysign<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
source§type Output = NonZeroNonNaNFinite
type Output = NonZeroNonNaNFinite
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Copysign<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
impl Copysign<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Copysign::copysign()
.source§impl Copysign<Positive<f32>> for NonZeroNonNaN<f32>
impl Copysign<Positive<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Copysign::copysign()
.source§impl Copysign<Positive> for NonZeroNonNaN<f64>
impl Copysign<Positive> for NonZeroNonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Copysign::copysign()
.source§impl Copysign<PositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Copysign<PositiveFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Copysign::copysign()
.source§impl Copysign<PositiveFinite> for NonZeroNonNaN<f64>
impl Copysign<PositiveFinite> for NonZeroNonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Copysign::copysign()
.source§impl Copysign<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
impl Copysign<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyNegative<f32>
type Output = StrictlyNegative<f32>
Copysign::copysign()
.source§impl Copysign<StrictlyNegative> for NonZeroNonNaN<f64>
impl Copysign<StrictlyNegative> for NonZeroNonNaN<f64>
source§type Output = StrictlyNegative
type Output = StrictlyNegative
Copysign::copysign()
.source§impl Copysign<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Copysign<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyNegative<f32>
type Output = StrictlyNegative<f32>
Copysign::copysign()
.source§impl Copysign<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
impl Copysign<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
source§type Output = StrictlyNegative
type Output = StrictlyNegative
Copysign::copysign()
.source§impl Copysign<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl Copysign<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Copysign::copysign()
.source§impl Copysign<StrictlyPositive> for NonZeroNonNaN<f64>
impl Copysign<StrictlyPositive> for NonZeroNonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Copysign::copysign()
.source§impl Copysign<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Copysign<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Copysign::copysign()
.source§impl Copysign<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
impl Copysign<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Copysign::copysign()
.source§impl<T: Debug> Debug for NonZeroNonNaN<T>
impl<T: Debug> Debug for NonZeroNonNaN<T>
source§impl<'de> Deserialize<'de> for NonZeroNonNaN<f64>
impl<'de> Deserialize<'de> for NonZeroNonNaN<f64>
source§fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
D: Deserializer<'de>,
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
D: Deserializer<'de>,
source§impl<'de> Deserialize<'de> for NonZeroNonNaN<f32>
impl<'de> Deserialize<'de> for NonZeroNonNaN<f32>
source§fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
D: Deserializer<'de>,
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
D: Deserializer<'de>,
source§impl Display for NonZeroNonNaN<f64>
impl Display for NonZeroNonNaN<f64>
source§impl Display for NonZeroNonNaN<f32>
impl Display for NonZeroNonNaN<f32>
source§impl Div<NegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Div<NegativeFinite<f32>> for NonZeroNonNaN<f32>
source§impl Div<NegativeFinite> for NonZeroNonNaN<f64>
impl Div<NegativeFinite> for NonZeroNonNaN<f64>
source§impl Div<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Div<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§impl Div<NonNaNFinite> for NonZeroNonNaN<f64>
impl Div<NonNaNFinite> for NonZeroNonNaN<f64>
source§impl Div<NonZeroNonNaN<f32>> for NegativeFinite<f32>
impl Div<NonZeroNonNaN<f32>> for NegativeFinite<f32>
source§impl Div<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
impl Div<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
source§impl Div<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
impl Div<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
source§impl Div<NonZeroNonNaN<f32>> for PositiveFinite<f32>
impl Div<NonZeroNonNaN<f32>> for PositiveFinite<f32>
source§impl Div<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
impl Div<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
source§impl Div<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
impl Div<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
source§impl Div<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl Div<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§impl Div<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
impl Div<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
source§impl Div<NonZeroNonNaN> for NegativeFinite<f64>
impl Div<NonZeroNonNaN> for NegativeFinite<f64>
source§impl Div<NonZeroNonNaN> for NonNaNFinite<f64>
impl Div<NonZeroNonNaN> for NonNaNFinite<f64>
source§impl Div<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
impl Div<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
source§impl Div<NonZeroNonNaN> for PositiveFinite<f64>
impl Div<NonZeroNonNaN> for PositiveFinite<f64>
source§impl Div<NonZeroNonNaN> for StrictlyNegative<f64>
impl Div<NonZeroNonNaN> for StrictlyNegative<f64>
source§impl Div<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
impl Div<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
source§impl Div<NonZeroNonNaN> for StrictlyPositive<f64>
impl Div<NonZeroNonNaN> for StrictlyPositive<f64>
source§impl Div<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
impl Div<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
source§impl Div<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Div<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§impl Div<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
impl Div<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
source§impl Div<PositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Div<PositiveFinite<f32>> for NonZeroNonNaN<f32>
source§impl Div<PositiveFinite> for NonZeroNonNaN<f64>
impl Div<PositiveFinite> for NonZeroNonNaN<f64>
source§impl Div<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
impl Div<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
source§impl Div<StrictlyNegative> for NonZeroNonNaN<f64>
impl Div<StrictlyNegative> for NonZeroNonNaN<f64>
source§impl Div<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Div<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
source§impl Div<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
impl Div<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
source§impl Div<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl Div<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§impl Div<StrictlyPositive> for NonZeroNonNaN<f64>
impl Div<StrictlyPositive> for NonZeroNonNaN<f64>
source§impl Div<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Div<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
source§impl Div<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
impl Div<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
source§impl Div for NonZeroNonNaN<f64>
impl Div for NonZeroNonNaN<f64>
source§impl Div for NonZeroNonNaN<f32>
impl Div for NonZeroNonNaN<f32>
source§impl DivEuclid<Negative<f32>> for NonZeroNonNaN<f32>
impl DivEuclid<Negative<f32>> for NonZeroNonNaN<f32>
source§type Output = f32
type Output = f32
DivEuclid::div_euclid()
.source§impl DivEuclid<Negative> for NonZeroNonNaN<f64>
impl DivEuclid<Negative> for NonZeroNonNaN<f64>
source§type Output = f64
type Output = f64
DivEuclid::div_euclid()
.source§impl DivEuclid<NegativeFinite<f32>> for NonZeroNonNaN<f32>
impl DivEuclid<NegativeFinite<f32>> for NonZeroNonNaN<f32>
source§fn div_euclid(self, rhs: NegativeFinite<f32>) -> Self::Output
fn div_euclid(self, rhs: NegativeFinite<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NegativeFinite> for NonZeroNonNaN<f64>
impl DivEuclid<NegativeFinite> for NonZeroNonNaN<f64>
source§type Output = NonNaN
type Output = NonNaN
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NegativeFinite<f64>) -> Self::Output
fn div_euclid(self, rhs: NegativeFinite<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonNaN<f32>> for NonZeroNonNaN<f32>
impl DivEuclid<NonNaN<f32>> for NonZeroNonNaN<f32>
source§type Output = f32
type Output = f32
DivEuclid::div_euclid()
.source§impl DivEuclid<NonNaN> for NonZeroNonNaN<f64>
impl DivEuclid<NonNaN> for NonZeroNonNaN<f64>
source§type Output = f64
type Output = f64
DivEuclid::div_euclid()
.source§impl DivEuclid<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl DivEuclid<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§fn div_euclid(self, rhs: NonNaNFinite<f32>) -> Self::Output
fn div_euclid(self, rhs: NonNaNFinite<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonNaNFinite> for NonZeroNonNaN<f64>
impl DivEuclid<NonNaNFinite> for NonZeroNonNaN<f64>
source§type Output = NonNaN
type Output = NonNaN
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonNaNFinite<f64>) -> Self::Output
fn div_euclid(self, rhs: NonNaNFinite<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN<f32>> for Negative<f32>
impl DivEuclid<NonZeroNonNaN<f32>> for Negative<f32>
source§type Output = f32
type Output = f32
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN<f32>> for NegativeFinite<f32>
impl DivEuclid<NonZeroNonNaN<f32>> for NegativeFinite<f32>
source§fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN<f32>> for NonNaN<f32>
impl DivEuclid<NonZeroNonNaN<f32>> for NonNaN<f32>
source§type Output = f32
type Output = f32
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
impl DivEuclid<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
source§fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN<f32>> for NonZeroNonNaN<f32>
impl DivEuclid<NonZeroNonNaN<f32>> for NonZeroNonNaN<f32>
source§type Output = f32
type Output = f32
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
impl DivEuclid<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
source§fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN<f32>> for Positive<f32>
impl DivEuclid<NonZeroNonNaN<f32>> for Positive<f32>
source§type Output = f32
type Output = f32
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN<f32>> for PositiveFinite<f32>
impl DivEuclid<NonZeroNonNaN<f32>> for PositiveFinite<f32>
source§fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
impl DivEuclid<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
source§type Output = f32
type Output = f32
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
impl DivEuclid<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
source§fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl DivEuclid<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§type Output = f32
type Output = f32
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
impl DivEuclid<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
source§fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN> for Negative<f64>
impl DivEuclid<NonZeroNonNaN> for Negative<f64>
source§type Output = f64
type Output = f64
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN> for NegativeFinite<f64>
impl DivEuclid<NonZeroNonNaN> for NegativeFinite<f64>
source§type Output = NonNaN
type Output = NonNaN
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN> for NonNaN<f64>
impl DivEuclid<NonZeroNonNaN> for NonNaN<f64>
source§type Output = f64
type Output = f64
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN> for NonNaNFinite<f64>
impl DivEuclid<NonZeroNonNaN> for NonNaNFinite<f64>
source§type Output = NonNaN
type Output = NonNaN
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN> for NonZeroNonNaN<f64>
impl DivEuclid<NonZeroNonNaN> for NonZeroNonNaN<f64>
source§type Output = f64
type Output = f64
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
impl DivEuclid<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
source§type Output = NonNaN
type Output = NonNaN
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN> for Positive<f64>
impl DivEuclid<NonZeroNonNaN> for Positive<f64>
source§type Output = f64
type Output = f64
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN> for PositiveFinite<f64>
impl DivEuclid<NonZeroNonNaN> for PositiveFinite<f64>
source§type Output = NonNaN
type Output = NonNaN
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN> for StrictlyNegative<f64>
impl DivEuclid<NonZeroNonNaN> for StrictlyNegative<f64>
source§type Output = f64
type Output = f64
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
impl DivEuclid<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
source§type Output = NonNaN
type Output = NonNaN
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN> for StrictlyPositive<f64>
impl DivEuclid<NonZeroNonNaN> for StrictlyPositive<f64>
source§type Output = f64
type Output = f64
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
impl DivEuclid<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
source§type Output = NonNaN
type Output = NonNaN
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl DivEuclid<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§fn div_euclid(self, rhs: NonZeroNonNaNFinite<f32>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaNFinite<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
impl DivEuclid<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
source§type Output = NonNaN
type Output = NonNaN
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: NonZeroNonNaNFinite<f64>) -> Self::Output
fn div_euclid(self, rhs: NonZeroNonNaNFinite<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<Positive<f32>> for NonZeroNonNaN<f32>
impl DivEuclid<Positive<f32>> for NonZeroNonNaN<f32>
source§type Output = f32
type Output = f32
DivEuclid::div_euclid()
.source§impl DivEuclid<Positive> for NonZeroNonNaN<f64>
impl DivEuclid<Positive> for NonZeroNonNaN<f64>
source§type Output = f64
type Output = f64
DivEuclid::div_euclid()
.source§impl DivEuclid<PositiveFinite<f32>> for NonZeroNonNaN<f32>
impl DivEuclid<PositiveFinite<f32>> for NonZeroNonNaN<f32>
source§fn div_euclid(self, rhs: PositiveFinite<f32>) -> Self::Output
fn div_euclid(self, rhs: PositiveFinite<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<PositiveFinite> for NonZeroNonNaN<f64>
impl DivEuclid<PositiveFinite> for NonZeroNonNaN<f64>
source§type Output = NonNaN
type Output = NonNaN
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: PositiveFinite<f64>) -> Self::Output
fn div_euclid(self, rhs: PositiveFinite<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
impl DivEuclid<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
source§type Output = f32
type Output = f32
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: StrictlyNegative<f32>) -> Self::Output
fn div_euclid(self, rhs: StrictlyNegative<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<StrictlyNegative> for NonZeroNonNaN<f64>
impl DivEuclid<StrictlyNegative> for NonZeroNonNaN<f64>
source§type Output = f64
type Output = f64
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: StrictlyNegative<f64>) -> Self::Output
fn div_euclid(self, rhs: StrictlyNegative<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
impl DivEuclid<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
source§fn div_euclid(self, rhs: StrictlyNegativeFinite<f32>) -> Self::Output
fn div_euclid(self, rhs: StrictlyNegativeFinite<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
impl DivEuclid<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
source§type Output = NonNaN
type Output = NonNaN
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: StrictlyNegativeFinite<f64>) -> Self::Output
fn div_euclid(self, rhs: StrictlyNegativeFinite<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl DivEuclid<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§type Output = f32
type Output = f32
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: StrictlyPositive<f32>) -> Self::Output
fn div_euclid(self, rhs: StrictlyPositive<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<StrictlyPositive> for NonZeroNonNaN<f64>
impl DivEuclid<StrictlyPositive> for NonZeroNonNaN<f64>
source§type Output = f64
type Output = f64
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: StrictlyPositive<f64>) -> Self::Output
fn div_euclid(self, rhs: StrictlyPositive<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
impl DivEuclid<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
source§fn div_euclid(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output
fn div_euclid(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl DivEuclid<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
impl DivEuclid<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
source§type Output = NonNaN
type Output = NonNaN
DivEuclid::div_euclid()
.source§fn div_euclid(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output
fn div_euclid(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output
rem_euclid
.
Equal to self if the sign of self and sign are the same, otherwise equal to -self. Read moresource§impl From<NonZero<i16>> for NonZeroNonNaN<f64>
impl From<NonZero<i16>> for NonZeroNonNaN<f64>
source§fn from(value: NonZeroI16) -> Self
fn from(value: NonZeroI16) -> Self
source§impl From<NonZero<i16>> for NonZeroNonNaN<f32>
impl From<NonZero<i16>> for NonZeroNonNaN<f32>
source§fn from(value: NonZeroI16) -> Self
fn from(value: NonZeroI16) -> Self
source§impl From<NonZero<i32>> for NonZeroNonNaN<f64>
impl From<NonZero<i32>> for NonZeroNonNaN<f64>
source§fn from(value: NonZeroI32) -> Self
fn from(value: NonZeroI32) -> Self
source§impl From<NonZero<i32>> for NonZeroNonNaN<f32>
impl From<NonZero<i32>> for NonZeroNonNaN<f32>
source§fn from(value: NonZeroI32) -> Self
fn from(value: NonZeroI32) -> Self
source§impl From<NonZero<i64>> for NonZeroNonNaN<f64>
impl From<NonZero<i64>> for NonZeroNonNaN<f64>
source§fn from(value: NonZeroI64) -> Self
fn from(value: NonZeroI64) -> Self
source§impl From<NonZero<i64>> for NonZeroNonNaN<f32>
impl From<NonZero<i64>> for NonZeroNonNaN<f32>
source§fn from(value: NonZeroI64) -> Self
fn from(value: NonZeroI64) -> Self
source§impl From<NonZero<u16>> for NonZeroNonNaN<f64>
impl From<NonZero<u16>> for NonZeroNonNaN<f64>
source§fn from(value: NonZeroU16) -> Self
fn from(value: NonZeroU16) -> Self
source§impl From<NonZero<u16>> for NonZeroNonNaN<f32>
impl From<NonZero<u16>> for NonZeroNonNaN<f32>
source§fn from(value: NonZeroU16) -> Self
fn from(value: NonZeroU16) -> Self
source§impl From<NonZero<u32>> for NonZeroNonNaN<f64>
impl From<NonZero<u32>> for NonZeroNonNaN<f64>
source§fn from(value: NonZeroU32) -> Self
fn from(value: NonZeroU32) -> Self
source§impl From<NonZero<u32>> for NonZeroNonNaN<f32>
impl From<NonZero<u32>> for NonZeroNonNaN<f32>
source§fn from(value: NonZeroU32) -> Self
fn from(value: NonZeroU32) -> Self
source§impl From<NonZero<u64>> for NonZeroNonNaN<f64>
impl From<NonZero<u64>> for NonZeroNonNaN<f64>
source§fn from(value: NonZeroU64) -> Self
fn from(value: NonZeroU64) -> Self
source§impl From<NonZero<u64>> for NonZeroNonNaN<f32>
impl From<NonZero<u64>> for NonZeroNonNaN<f32>
source§fn from(value: NonZeroU64) -> Self
fn from(value: NonZeroU64) -> Self
source§impl From<NonZeroNonNaN<f32>> for NonNaN<f32>
impl From<NonZeroNonNaN<f32>> for NonNaN<f32>
source§fn from(value: NonZeroNonNaN<f32>) -> Self
fn from(value: NonZeroNonNaN<f32>) -> Self
source§impl From<NonZeroNonNaN<f32>> for f32
impl From<NonZeroNonNaN<f32>> for f32
source§fn from(value: NonZeroNonNaN<Self>) -> Self
fn from(value: NonZeroNonNaN<Self>) -> Self
source§impl From<NonZeroNonNaN> for NonNaN<f64>
impl From<NonZeroNonNaN> for NonNaN<f64>
source§fn from(value: NonZeroNonNaN<f64>) -> Self
fn from(value: NonZeroNonNaN<f64>) -> Self
source§impl From<NonZeroNonNaN> for f64
impl From<NonZeroNonNaN> for f64
source§fn from(value: NonZeroNonNaN<Self>) -> Self
fn from(value: NonZeroNonNaN<Self>) -> Self
source§impl From<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl From<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§fn from(value: NonZeroNonNaNFinite<f32>) -> Self
fn from(value: NonZeroNonNaNFinite<f32>) -> Self
source§impl From<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
impl From<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
source§fn from(value: NonZeroNonNaNFinite<f64>) -> Self
fn from(value: NonZeroNonNaNFinite<f64>) -> Self
source§impl From<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
impl From<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
source§fn from(value: StrictlyNegative<f32>) -> Self
fn from(value: StrictlyNegative<f32>) -> Self
source§impl From<StrictlyNegative> for NonZeroNonNaN<f64>
impl From<StrictlyNegative> for NonZeroNonNaN<f64>
source§fn from(value: StrictlyNegative<f64>) -> Self
fn from(value: StrictlyNegative<f64>) -> Self
source§impl From<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
impl From<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
source§fn from(value: StrictlyNegativeFinite<f32>) -> Self
fn from(value: StrictlyNegativeFinite<f32>) -> Self
source§impl From<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
impl From<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
source§fn from(value: StrictlyNegativeFinite<f64>) -> Self
fn from(value: StrictlyNegativeFinite<f64>) -> Self
source§impl From<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl From<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§fn from(value: StrictlyPositive<f32>) -> Self
fn from(value: StrictlyPositive<f32>) -> Self
source§impl From<StrictlyPositive> for NonZeroNonNaN<f64>
impl From<StrictlyPositive> for NonZeroNonNaN<f64>
source§fn from(value: StrictlyPositive<f64>) -> Self
fn from(value: StrictlyPositive<f64>) -> Self
source§impl From<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
impl From<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
source§fn from(value: StrictlyPositiveFinite<f32>) -> Self
fn from(value: StrictlyPositiveFinite<f32>) -> Self
source§impl From<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
impl From<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
source§fn from(value: StrictlyPositiveFinite<f64>) -> Self
fn from(value: StrictlyPositiveFinite<f64>) -> Self
source§impl FromStr for NonZeroNonNaN<f64>
impl FromStr for NonZeroNonNaN<f64>
source§impl FromStr for NonZeroNonNaN<f32>
impl FromStr for NonZeroNonNaN<f32>
source§impl Hash for NonZeroNonNaN<f64>
impl Hash for NonZeroNonNaN<f64>
source§impl Hash for NonZeroNonNaN<f32>
impl Hash for NonZeroNonNaN<f32>
source§impl Hypot<Negative<f32>> for NonZeroNonNaN<f32>
impl Hypot<Negative<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<Negative> for NonZeroNonNaN<f64>
impl Hypot<Negative> for NonZeroNonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Hypot<NegativeFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NegativeFinite> for NonZeroNonNaN<f64>
impl Hypot<NegativeFinite> for NonZeroNonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NonNaN<f32>> for NonZeroNonNaN<f32>
impl Hypot<NonNaN<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NonNaN> for NonZeroNonNaN<f64>
impl Hypot<NonNaN> for NonZeroNonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Hypot<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NonNaNFinite> for NonZeroNonNaN<f64>
impl Hypot<NonNaNFinite> for NonZeroNonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN<f32>> for Negative<f32>
impl Hypot<NonZeroNonNaN<f32>> for Negative<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN<f32>> for NegativeFinite<f32>
impl Hypot<NonZeroNonNaN<f32>> for NegativeFinite<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN<f32>> for NonNaN<f32>
impl Hypot<NonZeroNonNaN<f32>> for NonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
impl Hypot<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN<f32>> for NonZeroNonNaN<f32>
impl Hypot<NonZeroNonNaN<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
impl Hypot<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN<f32>> for Positive<f32>
impl Hypot<NonZeroNonNaN<f32>> for Positive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN<f32>> for PositiveFinite<f32>
impl Hypot<NonZeroNonNaN<f32>> for PositiveFinite<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
impl Hypot<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
impl Hypot<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl Hypot<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
impl Hypot<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN> for Negative<f64>
impl Hypot<NonZeroNonNaN> for Negative<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN> for NegativeFinite<f64>
impl Hypot<NonZeroNonNaN> for NegativeFinite<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN> for NonNaN<f64>
impl Hypot<NonZeroNonNaN> for NonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN> for NonNaNFinite<f64>
impl Hypot<NonZeroNonNaN> for NonNaNFinite<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN> for NonZeroNonNaN<f64>
impl Hypot<NonZeroNonNaN> for NonZeroNonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
impl Hypot<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN> for Positive<f64>
impl Hypot<NonZeroNonNaN> for Positive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN> for PositiveFinite<f64>
impl Hypot<NonZeroNonNaN> for PositiveFinite<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN> for StrictlyNegative<f64>
impl Hypot<NonZeroNonNaN> for StrictlyNegative<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
impl Hypot<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN> for StrictlyPositive<f64>
impl Hypot<NonZeroNonNaN> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
impl Hypot<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Hypot<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
impl Hypot<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<Positive<f32>> for NonZeroNonNaN<f32>
impl Hypot<Positive<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<Positive> for NonZeroNonNaN<f64>
impl Hypot<Positive> for NonZeroNonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<PositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Hypot<PositiveFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<PositiveFinite> for NonZeroNonNaN<f64>
impl Hypot<PositiveFinite> for NonZeroNonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
impl Hypot<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<StrictlyNegative> for NonZeroNonNaN<f64>
impl Hypot<StrictlyNegative> for NonZeroNonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Hypot<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
impl Hypot<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl Hypot<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<StrictlyPositive> for NonZeroNonNaN<f64>
impl Hypot<StrictlyPositive> for NonZeroNonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Hypot<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
impl Hypot<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Max<NegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Max<NegativeFinite<f32>> for NonZeroNonNaN<f32>
source§impl Max<NegativeFinite> for NonZeroNonNaN<f64>
impl Max<NegativeFinite> for NonZeroNonNaN<f64>
source§impl Max<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Max<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§impl Max<NonNaNFinite> for NonZeroNonNaN<f64>
impl Max<NonNaNFinite> for NonZeroNonNaN<f64>
source§impl Max<NonZeroNonNaN<f32>> for NegativeFinite<f32>
impl Max<NonZeroNonNaN<f32>> for NegativeFinite<f32>
source§impl Max<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
impl Max<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
source§impl Max<NonZeroNonNaN<f32>> for NonZeroNonNaN<f32>
impl Max<NonZeroNonNaN<f32>> for NonZeroNonNaN<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Max::max()
.source§impl Max<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
impl Max<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Max::max()
.source§impl Max<NonZeroNonNaN<f32>> for PositiveFinite<f32>
impl Max<NonZeroNonNaN<f32>> for PositiveFinite<f32>
source§impl Max<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
impl Max<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Max::max()
.source§impl Max<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
impl Max<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Max::max()
.source§impl Max<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl Max<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
impl Max<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<NonZeroNonNaN> for NegativeFinite<f64>
impl Max<NonZeroNonNaN> for NegativeFinite<f64>
source§impl Max<NonZeroNonNaN> for NonNaNFinite<f64>
impl Max<NonZeroNonNaN> for NonNaNFinite<f64>
source§impl Max<NonZeroNonNaN> for NonZeroNonNaN<f64>
impl Max<NonZeroNonNaN> for NonZeroNonNaN<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Max::max()
.source§impl Max<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
impl Max<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Max::max()
.source§impl Max<NonZeroNonNaN> for PositiveFinite<f64>
impl Max<NonZeroNonNaN> for PositiveFinite<f64>
source§impl Max<NonZeroNonNaN> for StrictlyNegative<f64>
impl Max<NonZeroNonNaN> for StrictlyNegative<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Max::max()
.source§impl Max<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
impl Max<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Max::max()
.source§impl Max<NonZeroNonNaN> for StrictlyPositive<f64>
impl Max<NonZeroNonNaN> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Max<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
impl Max<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Max<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Max<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Max::max()
.source§impl Max<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
impl Max<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Max::max()
.source§impl Max<PositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Max<PositiveFinite<f32>> for NonZeroNonNaN<f32>
source§impl Max<PositiveFinite> for NonZeroNonNaN<f64>
impl Max<PositiveFinite> for NonZeroNonNaN<f64>
source§impl Max<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
impl Max<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Max::max()
.source§impl Max<StrictlyNegative> for NonZeroNonNaN<f64>
impl Max<StrictlyNegative> for NonZeroNonNaN<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Max::max()
.source§impl Max<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Max<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Max::max()
.source§impl Max<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
impl Max<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Max::max()
.source§impl Max<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl Max<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<StrictlyPositive> for NonZeroNonNaN<f64>
impl Max<StrictlyPositive> for NonZeroNonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Max<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Max<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
impl Max<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Min<NegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Min<NegativeFinite<f32>> for NonZeroNonNaN<f32>
source§impl Min<NegativeFinite> for NonZeroNonNaN<f64>
impl Min<NegativeFinite> for NonZeroNonNaN<f64>
source§impl Min<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Min<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§impl Min<NonNaNFinite> for NonZeroNonNaN<f64>
impl Min<NonNaNFinite> for NonZeroNonNaN<f64>
source§impl Min<NonZeroNonNaN<f32>> for NegativeFinite<f32>
impl Min<NonZeroNonNaN<f32>> for NegativeFinite<f32>
source§impl Min<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
impl Min<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
source§impl Min<NonZeroNonNaN<f32>> for NonZeroNonNaN<f32>
impl Min<NonZeroNonNaN<f32>> for NonZeroNonNaN<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Min::min()
.source§impl Min<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
impl Min<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Min::min()
.source§impl Min<NonZeroNonNaN<f32>> for PositiveFinite<f32>
impl Min<NonZeroNonNaN<f32>> for PositiveFinite<f32>
source§impl Min<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
impl Min<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
source§type Output = StrictlyNegative<f32>
type Output = StrictlyNegative<f32>
Min::min()
.source§impl Min<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
impl Min<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
source§type Output = StrictlyNegative<f32>
type Output = StrictlyNegative<f32>
Min::min()
.source§impl Min<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl Min<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Min::min()
.source§impl Min<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
impl Min<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Min::min()
.source§impl Min<NonZeroNonNaN> for NegativeFinite<f64>
impl Min<NonZeroNonNaN> for NegativeFinite<f64>
source§impl Min<NonZeroNonNaN> for NonNaNFinite<f64>
impl Min<NonZeroNonNaN> for NonNaNFinite<f64>
source§impl Min<NonZeroNonNaN> for NonZeroNonNaN<f64>
impl Min<NonZeroNonNaN> for NonZeroNonNaN<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Min::min()
.source§impl Min<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
impl Min<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Min::min()
.source§impl Min<NonZeroNonNaN> for PositiveFinite<f64>
impl Min<NonZeroNonNaN> for PositiveFinite<f64>
source§impl Min<NonZeroNonNaN> for StrictlyNegative<f64>
impl Min<NonZeroNonNaN> for StrictlyNegative<f64>
source§type Output = StrictlyNegative
type Output = StrictlyNegative
Min::min()
.source§impl Min<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
impl Min<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
source§type Output = StrictlyNegative
type Output = StrictlyNegative
Min::min()
.source§impl Min<NonZeroNonNaN> for StrictlyPositive<f64>
impl Min<NonZeroNonNaN> for StrictlyPositive<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Min::min()
.source§impl Min<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
impl Min<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Min::min()
.source§impl Min<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Min<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Min::min()
.source§impl Min<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
impl Min<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Min::min()
.source§impl Min<PositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Min<PositiveFinite<f32>> for NonZeroNonNaN<f32>
source§impl Min<PositiveFinite> for NonZeroNonNaN<f64>
impl Min<PositiveFinite> for NonZeroNonNaN<f64>
source§impl Min<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
impl Min<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyNegative<f32>
type Output = StrictlyNegative<f32>
Min::min()
.source§impl Min<StrictlyNegative> for NonZeroNonNaN<f64>
impl Min<StrictlyNegative> for NonZeroNonNaN<f64>
source§type Output = StrictlyNegative
type Output = StrictlyNegative
Min::min()
.source§impl Min<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Min<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = StrictlyNegative<f32>
type Output = StrictlyNegative<f32>
Min::min()
.source§impl Min<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
impl Min<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
source§type Output = StrictlyNegative
type Output = StrictlyNegative
Min::min()
.source§impl Min<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl Min<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Min::min()
.source§impl Min<StrictlyPositive> for NonZeroNonNaN<f64>
impl Min<StrictlyPositive> for NonZeroNonNaN<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Min::min()
.source§impl Min<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Min<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Min::min()
.source§impl Min<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
impl Min<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Min::min()
.source§impl Mul<NegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Mul<NegativeFinite<f32>> for NonZeroNonNaN<f32>
source§impl Mul<NegativeFinite> for NonZeroNonNaN<f64>
impl Mul<NegativeFinite> for NonZeroNonNaN<f64>
source§impl Mul<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Mul<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§impl Mul<NonNaNFinite> for NonZeroNonNaN<f64>
impl Mul<NonNaNFinite> for NonZeroNonNaN<f64>
source§impl Mul<NonZeroNonNaN<f32>> for NegativeFinite<f32>
impl Mul<NonZeroNonNaN<f32>> for NegativeFinite<f32>
source§impl Mul<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
impl Mul<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
source§impl Mul<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
impl Mul<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
source§impl Mul<NonZeroNonNaN<f32>> for PositiveFinite<f32>
impl Mul<NonZeroNonNaN<f32>> for PositiveFinite<f32>
source§impl Mul<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
impl Mul<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
source§impl Mul<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
impl Mul<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
source§impl Mul<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl Mul<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§impl Mul<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
impl Mul<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
source§impl Mul<NonZeroNonNaN> for NegativeFinite<f64>
impl Mul<NonZeroNonNaN> for NegativeFinite<f64>
source§impl Mul<NonZeroNonNaN> for NonNaNFinite<f64>
impl Mul<NonZeroNonNaN> for NonNaNFinite<f64>
source§impl Mul<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
impl Mul<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
source§impl Mul<NonZeroNonNaN> for PositiveFinite<f64>
impl Mul<NonZeroNonNaN> for PositiveFinite<f64>
source§impl Mul<NonZeroNonNaN> for StrictlyNegative<f64>
impl Mul<NonZeroNonNaN> for StrictlyNegative<f64>
source§impl Mul<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
impl Mul<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
source§impl Mul<NonZeroNonNaN> for StrictlyPositive<f64>
impl Mul<NonZeroNonNaN> for StrictlyPositive<f64>
source§impl Mul<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
impl Mul<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
source§impl Mul<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Mul<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§impl Mul<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
impl Mul<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
source§impl Mul<PositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Mul<PositiveFinite<f32>> for NonZeroNonNaN<f32>
source§impl Mul<PositiveFinite> for NonZeroNonNaN<f64>
impl Mul<PositiveFinite> for NonZeroNonNaN<f64>
source§impl Mul<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
impl Mul<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
source§impl Mul<StrictlyNegative> for NonZeroNonNaN<f64>
impl Mul<StrictlyNegative> for NonZeroNonNaN<f64>
source§impl Mul<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Mul<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
source§impl Mul<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
impl Mul<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
source§impl Mul<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl Mul<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§impl Mul<StrictlyPositive> for NonZeroNonNaN<f64>
impl Mul<StrictlyPositive> for NonZeroNonNaN<f64>
source§impl Mul<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Mul<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
source§impl Mul<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
impl Mul<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
source§impl Mul for NonZeroNonNaN<f64>
impl Mul for NonZeroNonNaN<f64>
source§impl Mul for NonZeroNonNaN<f32>
impl Mul for NonZeroNonNaN<f32>
source§impl Neg for NonZeroNonNaN<f64>
impl Neg for NonZeroNonNaN<f64>
source§impl Neg for NonZeroNonNaN<f32>
impl Neg for NonZeroNonNaN<f32>
source§impl Ord for NonZeroNonNaN<f64>
impl Ord for NonZeroNonNaN<f64>
source§impl Ord for NonZeroNonNaN<f32>
impl Ord for NonZeroNonNaN<f32>
source§impl PartialEq<NegativeFinite<f32>> for NonZeroNonNaN<f32>
impl PartialEq<NegativeFinite<f32>> for NonZeroNonNaN<f32>
source§impl PartialEq<NegativeFinite> for NonZeroNonNaN<f64>
impl PartialEq<NegativeFinite> for NonZeroNonNaN<f64>
source§impl PartialEq<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl PartialEq<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§impl PartialEq<NonNaNFinite> for NonZeroNonNaN<f64>
impl PartialEq<NonNaNFinite> for NonZeroNonNaN<f64>
source§impl PartialEq<NonZeroNonNaN<f32>> for NegativeFinite<f32>
impl PartialEq<NonZeroNonNaN<f32>> for NegativeFinite<f32>
source§impl PartialEq<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
impl PartialEq<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
source§impl PartialEq<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
impl PartialEq<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
source§impl PartialEq<NonZeroNonNaN<f32>> for PositiveFinite<f32>
impl PartialEq<NonZeroNonNaN<f32>> for PositiveFinite<f32>
source§impl PartialEq<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
impl PartialEq<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
source§impl PartialEq<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
impl PartialEq<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
source§impl PartialEq<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl PartialEq<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§impl PartialEq<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
impl PartialEq<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
source§impl PartialEq<NonZeroNonNaN> for NegativeFinite<f64>
impl PartialEq<NonZeroNonNaN> for NegativeFinite<f64>
source§impl PartialEq<NonZeroNonNaN> for NonNaNFinite<f64>
impl PartialEq<NonZeroNonNaN> for NonNaNFinite<f64>
source§impl PartialEq<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
impl PartialEq<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
source§impl PartialEq<NonZeroNonNaN> for PositiveFinite<f64>
impl PartialEq<NonZeroNonNaN> for PositiveFinite<f64>
source§impl PartialEq<NonZeroNonNaN> for StrictlyNegative<f64>
impl PartialEq<NonZeroNonNaN> for StrictlyNegative<f64>
source§impl PartialEq<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
impl PartialEq<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
source§impl PartialEq<NonZeroNonNaN> for StrictlyPositive<f64>
impl PartialEq<NonZeroNonNaN> for StrictlyPositive<f64>
source§impl PartialEq<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
impl PartialEq<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
source§impl PartialEq<NonZeroNonNaN> for f64
impl PartialEq<NonZeroNonNaN> for f64
source§impl PartialEq<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl PartialEq<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§impl PartialEq<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
impl PartialEq<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
source§impl PartialEq<PositiveFinite<f32>> for NonZeroNonNaN<f32>
impl PartialEq<PositiveFinite<f32>> for NonZeroNonNaN<f32>
source§impl PartialEq<PositiveFinite> for NonZeroNonNaN<f64>
impl PartialEq<PositiveFinite> for NonZeroNonNaN<f64>
source§impl PartialEq<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
impl PartialEq<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
source§impl PartialEq<StrictlyNegative> for NonZeroNonNaN<f64>
impl PartialEq<StrictlyNegative> for NonZeroNonNaN<f64>
source§impl PartialEq<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
impl PartialEq<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
source§impl PartialEq<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
impl PartialEq<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
source§impl PartialEq<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl PartialEq<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§impl PartialEq<StrictlyPositive> for NonZeroNonNaN<f64>
impl PartialEq<StrictlyPositive> for NonZeroNonNaN<f64>
source§impl PartialEq<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
impl PartialEq<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
source§impl PartialEq<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
impl PartialEq<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
source§impl PartialEq for NonZeroNonNaN<f64>
impl PartialEq for NonZeroNonNaN<f64>
source§impl PartialEq for NonZeroNonNaN<f32>
impl PartialEq for NonZeroNonNaN<f32>
source§impl PartialOrd<Negative<f32>> for NonZeroNonNaN<f32>
impl PartialOrd<Negative<f32>> for NonZeroNonNaN<f32>
source§impl PartialOrd<Negative> for NonZeroNonNaN<f64>
impl PartialOrd<Negative> for NonZeroNonNaN<f64>
source§impl PartialOrd<NegativeFinite<f32>> for NonZeroNonNaN<f32>
impl PartialOrd<NegativeFinite<f32>> for NonZeroNonNaN<f32>
source§impl PartialOrd<NegativeFinite> for NonZeroNonNaN<f64>
impl PartialOrd<NegativeFinite> for NonZeroNonNaN<f64>
source§impl PartialOrd<NonNaN<f32>> for NonZeroNonNaN<f32>
impl PartialOrd<NonNaN<f32>> for NonZeroNonNaN<f32>
source§impl PartialOrd<NonNaN> for NonZeroNonNaN<f64>
impl PartialOrd<NonNaN> for NonZeroNonNaN<f64>
source§impl PartialOrd<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl PartialOrd<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§impl PartialOrd<NonNaNFinite> for NonZeroNonNaN<f64>
impl PartialOrd<NonNaNFinite> for NonZeroNonNaN<f64>
source§impl PartialOrd<NonZeroNonNaN<f32>> for Negative<f32>
impl PartialOrd<NonZeroNonNaN<f32>> for Negative<f32>
source§impl PartialOrd<NonZeroNonNaN<f32>> for NegativeFinite<f32>
impl PartialOrd<NonZeroNonNaN<f32>> for NegativeFinite<f32>
source§impl PartialOrd<NonZeroNonNaN<f32>> for NonNaN<f32>
impl PartialOrd<NonZeroNonNaN<f32>> for NonNaN<f32>
source§impl PartialOrd<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
impl PartialOrd<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
source§impl PartialOrd<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
impl PartialOrd<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
source§impl PartialOrd<NonZeroNonNaN<f32>> for Positive<f32>
impl PartialOrd<NonZeroNonNaN<f32>> for Positive<f32>
source§impl PartialOrd<NonZeroNonNaN<f32>> for PositiveFinite<f32>
impl PartialOrd<NonZeroNonNaN<f32>> for PositiveFinite<f32>
source§impl PartialOrd<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
impl PartialOrd<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
source§impl PartialOrd<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
impl PartialOrd<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
source§impl PartialOrd<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl PartialOrd<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§impl PartialOrd<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
impl PartialOrd<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
source§impl PartialOrd<NonZeroNonNaN<f32>> for f32
impl PartialOrd<NonZeroNonNaN<f32>> for f32
source§impl PartialOrd<NonZeroNonNaN> for Negative<f64>
impl PartialOrd<NonZeroNonNaN> for Negative<f64>
source§impl PartialOrd<NonZeroNonNaN> for NegativeFinite<f64>
impl PartialOrd<NonZeroNonNaN> for NegativeFinite<f64>
source§impl PartialOrd<NonZeroNonNaN> for NonNaN<f64>
impl PartialOrd<NonZeroNonNaN> for NonNaN<f64>
source§impl PartialOrd<NonZeroNonNaN> for NonNaNFinite<f64>
impl PartialOrd<NonZeroNonNaN> for NonNaNFinite<f64>
source§impl PartialOrd<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
impl PartialOrd<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
source§impl PartialOrd<NonZeroNonNaN> for Positive<f64>
impl PartialOrd<NonZeroNonNaN> for Positive<f64>
source§impl PartialOrd<NonZeroNonNaN> for PositiveFinite<f64>
impl PartialOrd<NonZeroNonNaN> for PositiveFinite<f64>
source§impl PartialOrd<NonZeroNonNaN> for StrictlyNegative<f64>
impl PartialOrd<NonZeroNonNaN> for StrictlyNegative<f64>
source§impl PartialOrd<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
impl PartialOrd<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
source§impl PartialOrd<NonZeroNonNaN> for StrictlyPositive<f64>
impl PartialOrd<NonZeroNonNaN> for StrictlyPositive<f64>
source§impl PartialOrd<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
impl PartialOrd<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
source§impl PartialOrd<NonZeroNonNaN> for f64
impl PartialOrd<NonZeroNonNaN> for f64
source§impl PartialOrd<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl PartialOrd<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§impl PartialOrd<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
impl PartialOrd<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
source§impl PartialOrd<Positive<f32>> for NonZeroNonNaN<f32>
impl PartialOrd<Positive<f32>> for NonZeroNonNaN<f32>
source§impl PartialOrd<Positive> for NonZeroNonNaN<f64>
impl PartialOrd<Positive> for NonZeroNonNaN<f64>
source§impl PartialOrd<PositiveFinite<f32>> for NonZeroNonNaN<f32>
impl PartialOrd<PositiveFinite<f32>> for NonZeroNonNaN<f32>
source§impl PartialOrd<PositiveFinite> for NonZeroNonNaN<f64>
impl PartialOrd<PositiveFinite> for NonZeroNonNaN<f64>
source§impl PartialOrd<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
impl PartialOrd<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
source§impl PartialOrd<StrictlyNegative> for NonZeroNonNaN<f64>
impl PartialOrd<StrictlyNegative> for NonZeroNonNaN<f64>
source§impl PartialOrd<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
impl PartialOrd<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
source§impl PartialOrd<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
impl PartialOrd<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
source§impl PartialOrd<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl PartialOrd<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§impl PartialOrd<StrictlyPositive> for NonZeroNonNaN<f64>
impl PartialOrd<StrictlyPositive> for NonZeroNonNaN<f64>
source§impl PartialOrd<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
impl PartialOrd<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
source§impl PartialOrd<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
impl PartialOrd<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
source§impl PartialOrd<f32> for NonZeroNonNaN<f32>
impl PartialOrd<f32> for NonZeroNonNaN<f32>
source§impl PartialOrd<f64> for NonZeroNonNaN<f64>
impl PartialOrd<f64> for NonZeroNonNaN<f64>
source§impl PartialOrd for NonZeroNonNaN<f64>
impl PartialOrd for NonZeroNonNaN<f64>
source§impl PartialOrd for NonZeroNonNaN<f32>
impl PartialOrd for NonZeroNonNaN<f32>
source§impl Powf<NegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Powf<NegativeFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = f32
type Output = f32
Powf::powf()
.source§fn powf(self, rhs: NegativeFinite<f32>) -> Self::Output
fn powf(self, rhs: NegativeFinite<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NegativeFinite> for NonZeroNonNaN<f64>
impl Powf<NegativeFinite> for NonZeroNonNaN<f64>
source§type Output = f64
type Output = f64
Powf::powf()
.source§fn powf(self, rhs: NegativeFinite<f64>) -> Self::Output
fn powf(self, rhs: NegativeFinite<f64>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Powf<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = f32
type Output = f32
Powf::powf()
.source§fn powf(self, rhs: NonNaNFinite<f32>) -> Self::Output
fn powf(self, rhs: NonNaNFinite<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonNaNFinite> for NonZeroNonNaN<f64>
impl Powf<NonNaNFinite> for NonZeroNonNaN<f64>
source§type Output = f64
type Output = f64
Powf::powf()
.source§fn powf(self, rhs: NonNaNFinite<f64>) -> Self::Output
fn powf(self, rhs: NonNaNFinite<f64>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN<f32>> for Negative<f32>
impl Powf<NonZeroNonNaN<f32>> for Negative<f32>
source§type Output = f32
type Output = f32
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN<f32>> for NegativeFinite<f32>
impl Powf<NonZeroNonNaN<f32>> for NegativeFinite<f32>
source§type Output = f32
type Output = f32
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN<f32>> for NonNaN<f32>
impl Powf<NonZeroNonNaN<f32>> for NonNaN<f32>
source§type Output = f32
type Output = f32
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
impl Powf<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
source§type Output = f32
type Output = f32
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN<f32>> for NonZeroNonNaN<f32>
impl Powf<NonZeroNonNaN<f32>> for NonZeroNonNaN<f32>
source§type Output = f32
type Output = f32
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
impl Powf<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
source§type Output = f32
type Output = f32
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN<f32>> for Positive<f32>
impl Powf<NonZeroNonNaN<f32>> for Positive<f32>
source§fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN<f32>> for PositiveFinite<f32>
impl Powf<NonZeroNonNaN<f32>> for PositiveFinite<f32>
source§fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
impl Powf<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
source§type Output = f32
type Output = f32
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
impl Powf<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
source§type Output = f32
type Output = f32
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl Powf<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
impl Powf<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
source§fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN> for Negative<f64>
impl Powf<NonZeroNonNaN> for Negative<f64>
source§type Output = f64
type Output = f64
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN> for NegativeFinite<f64>
impl Powf<NonZeroNonNaN> for NegativeFinite<f64>
source§type Output = f64
type Output = f64
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN> for NonNaN<f64>
impl Powf<NonZeroNonNaN> for NonNaN<f64>
source§type Output = f64
type Output = f64
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN> for NonNaNFinite<f64>
impl Powf<NonZeroNonNaN> for NonNaNFinite<f64>
source§type Output = f64
type Output = f64
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN> for NonZeroNonNaN<f64>
impl Powf<NonZeroNonNaN> for NonZeroNonNaN<f64>
source§type Output = f64
type Output = f64
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
impl Powf<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
source§type Output = f64
type Output = f64
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN> for Positive<f64>
impl Powf<NonZeroNonNaN> for Positive<f64>
source§type Output = Positive
type Output = Positive
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN> for PositiveFinite<f64>
impl Powf<NonZeroNonNaN> for PositiveFinite<f64>
source§type Output = Positive
type Output = Positive
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN> for StrictlyNegative<f64>
impl Powf<NonZeroNonNaN> for StrictlyNegative<f64>
source§type Output = f64
type Output = f64
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
impl Powf<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
source§type Output = f64
type Output = f64
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN> for StrictlyPositive<f64>
impl Powf<NonZeroNonNaN> for StrictlyPositive<f64>
source§type Output = Positive
type Output = Positive
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
impl Powf<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
source§type Output = Positive
type Output = Positive
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Powf<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = f32
type Output = f32
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaNFinite<f32>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaNFinite<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
impl Powf<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
source§type Output = f64
type Output = f64
Powf::powf()
.source§fn powf(self, rhs: NonZeroNonNaNFinite<f64>) -> Self::Output
fn powf(self, rhs: NonZeroNonNaNFinite<f64>) -> Self::Output
f64::powf()
for more details.source§impl Powf<PositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Powf<PositiveFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = f32
type Output = f32
Powf::powf()
.source§fn powf(self, rhs: PositiveFinite<f32>) -> Self::Output
fn powf(self, rhs: PositiveFinite<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<PositiveFinite> for NonZeroNonNaN<f64>
impl Powf<PositiveFinite> for NonZeroNonNaN<f64>
source§type Output = f64
type Output = f64
Powf::powf()
.source§fn powf(self, rhs: PositiveFinite<f64>) -> Self::Output
fn powf(self, rhs: PositiveFinite<f64>) -> Self::Output
f64::powf()
for more details.source§impl Powf<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
impl Powf<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
source§type Output = f32
type Output = f32
Powf::powf()
.source§fn powf(self, rhs: StrictlyNegative<f32>) -> Self::Output
fn powf(self, rhs: StrictlyNegative<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<StrictlyNegative> for NonZeroNonNaN<f64>
impl Powf<StrictlyNegative> for NonZeroNonNaN<f64>
source§type Output = f64
type Output = f64
Powf::powf()
.source§fn powf(self, rhs: StrictlyNegative<f64>) -> Self::Output
fn powf(self, rhs: StrictlyNegative<f64>) -> Self::Output
f64::powf()
for more details.source§impl Powf<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Powf<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = f32
type Output = f32
Powf::powf()
.source§fn powf(self, rhs: StrictlyNegativeFinite<f32>) -> Self::Output
fn powf(self, rhs: StrictlyNegativeFinite<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
impl Powf<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
source§type Output = f64
type Output = f64
Powf::powf()
.source§fn powf(self, rhs: StrictlyNegativeFinite<f64>) -> Self::Output
fn powf(self, rhs: StrictlyNegativeFinite<f64>) -> Self::Output
f64::powf()
for more details.source§impl Powf<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl Powf<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§type Output = f32
type Output = f32
Powf::powf()
.source§fn powf(self, rhs: StrictlyPositive<f32>) -> Self::Output
fn powf(self, rhs: StrictlyPositive<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<StrictlyPositive> for NonZeroNonNaN<f64>
impl Powf<StrictlyPositive> for NonZeroNonNaN<f64>
source§type Output = f64
type Output = f64
Powf::powf()
.source§fn powf(self, rhs: StrictlyPositive<f64>) -> Self::Output
fn powf(self, rhs: StrictlyPositive<f64>) -> Self::Output
f64::powf()
for more details.source§impl Powf<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Powf<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
source§type Output = f32
type Output = f32
Powf::powf()
.source§fn powf(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output
fn powf(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output
f64::powf()
for more details.source§impl Powf<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
impl Powf<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
source§type Output = f64
type Output = f64
Powf::powf()
.source§fn powf(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output
fn powf(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output
f64::powf()
for more details.source§impl Rem<NegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Rem<NegativeFinite<f32>> for NonZeroNonNaN<f32>
source§impl Rem<NegativeFinite> for NonZeroNonNaN<f64>
impl Rem<NegativeFinite> for NonZeroNonNaN<f64>
source§impl Rem<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Rem<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§impl Rem<NonNaNFinite> for NonZeroNonNaN<f64>
impl Rem<NonNaNFinite> for NonZeroNonNaN<f64>
source§impl Rem<NonZeroNonNaN<f32>> for NegativeFinite<f32>
impl Rem<NonZeroNonNaN<f32>> for NegativeFinite<f32>
source§impl Rem<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
impl Rem<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
source§impl Rem<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
impl Rem<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
source§impl Rem<NonZeroNonNaN<f32>> for PositiveFinite<f32>
impl Rem<NonZeroNonNaN<f32>> for PositiveFinite<f32>
source§impl Rem<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
impl Rem<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
source§impl Rem<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
impl Rem<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
source§impl Rem<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl Rem<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§impl Rem<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
impl Rem<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
source§impl Rem<NonZeroNonNaN> for NegativeFinite<f64>
impl Rem<NonZeroNonNaN> for NegativeFinite<f64>
source§impl Rem<NonZeroNonNaN> for NonNaNFinite<f64>
impl Rem<NonZeroNonNaN> for NonNaNFinite<f64>
source§impl Rem<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
impl Rem<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
source§impl Rem<NonZeroNonNaN> for PositiveFinite<f64>
impl Rem<NonZeroNonNaN> for PositiveFinite<f64>
source§impl Rem<NonZeroNonNaN> for StrictlyNegative<f64>
impl Rem<NonZeroNonNaN> for StrictlyNegative<f64>
source§impl Rem<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
impl Rem<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
source§impl Rem<NonZeroNonNaN> for StrictlyPositive<f64>
impl Rem<NonZeroNonNaN> for StrictlyPositive<f64>
source§impl Rem<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
impl Rem<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
source§impl Rem<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Rem<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§impl Rem<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
impl Rem<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
source§impl Rem<PositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Rem<PositiveFinite<f32>> for NonZeroNonNaN<f32>
source§impl Rem<PositiveFinite> for NonZeroNonNaN<f64>
impl Rem<PositiveFinite> for NonZeroNonNaN<f64>
source§impl Rem<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
impl Rem<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
source§impl Rem<StrictlyNegative> for NonZeroNonNaN<f64>
impl Rem<StrictlyNegative> for NonZeroNonNaN<f64>
source§impl Rem<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Rem<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
source§impl Rem<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
impl Rem<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
source§impl Rem<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl Rem<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§impl Rem<StrictlyPositive> for NonZeroNonNaN<f64>
impl Rem<StrictlyPositive> for NonZeroNonNaN<f64>
source§impl Rem<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Rem<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
source§impl Rem<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
impl Rem<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
source§impl Rem for NonZeroNonNaN<f64>
impl Rem for NonZeroNonNaN<f64>
source§impl Rem for NonZeroNonNaN<f32>
impl Rem for NonZeroNonNaN<f32>
source§impl RemAssign<NonZeroNonNaN<f32>> for NegativeFinite<f32>
impl RemAssign<NonZeroNonNaN<f32>> for NegativeFinite<f32>
source§fn rem_assign(&mut self, rhs: NonZeroNonNaN<f32>)
fn rem_assign(&mut self, rhs: NonZeroNonNaN<f32>)
%=
operation. Read moresource§impl RemAssign<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
impl RemAssign<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
source§fn rem_assign(&mut self, rhs: NonZeroNonNaN<f32>)
fn rem_assign(&mut self, rhs: NonZeroNonNaN<f32>)
%=
operation. Read moresource§impl RemAssign<NonZeroNonNaN<f32>> for PositiveFinite<f32>
impl RemAssign<NonZeroNonNaN<f32>> for PositiveFinite<f32>
source§fn rem_assign(&mut self, rhs: NonZeroNonNaN<f32>)
fn rem_assign(&mut self, rhs: NonZeroNonNaN<f32>)
%=
operation. Read moresource§impl RemAssign<NonZeroNonNaN> for NegativeFinite<f64>
impl RemAssign<NonZeroNonNaN> for NegativeFinite<f64>
source§fn rem_assign(&mut self, rhs: NonZeroNonNaN<f64>)
fn rem_assign(&mut self, rhs: NonZeroNonNaN<f64>)
%=
operation. Read moresource§impl RemAssign<NonZeroNonNaN> for NonNaNFinite<f64>
impl RemAssign<NonZeroNonNaN> for NonNaNFinite<f64>
source§fn rem_assign(&mut self, rhs: NonZeroNonNaN<f64>)
fn rem_assign(&mut self, rhs: NonZeroNonNaN<f64>)
%=
operation. Read moresource§impl RemAssign<NonZeroNonNaN> for PositiveFinite<f64>
impl RemAssign<NonZeroNonNaN> for PositiveFinite<f64>
source§fn rem_assign(&mut self, rhs: NonZeroNonNaN<f64>)
fn rem_assign(&mut self, rhs: NonZeroNonNaN<f64>)
%=
operation. Read moresource§impl<T> Serialize for NonZeroNonNaN<T>where
T: Serialize,
impl<T> Serialize for NonZeroNonNaN<T>where
T: Serialize,
source§impl Sub<NegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Sub<NegativeFinite<f32>> for NonZeroNonNaN<f32>
source§impl Sub<NegativeFinite> for NonZeroNonNaN<f64>
impl Sub<NegativeFinite> for NonZeroNonNaN<f64>
source§impl Sub<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Sub<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§impl Sub<NonNaNFinite> for NonZeroNonNaN<f64>
impl Sub<NonNaNFinite> for NonZeroNonNaN<f64>
source§impl Sub<NonZeroNonNaN<f32>> for NegativeFinite<f32>
impl Sub<NonZeroNonNaN<f32>> for NegativeFinite<f32>
source§impl Sub<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
impl Sub<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
source§impl Sub<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
impl Sub<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
source§impl Sub<NonZeroNonNaN<f32>> for PositiveFinite<f32>
impl Sub<NonZeroNonNaN<f32>> for PositiveFinite<f32>
source§impl Sub<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
impl Sub<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
source§impl Sub<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
impl Sub<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
source§impl Sub<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl Sub<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§impl Sub<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
impl Sub<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
source§impl Sub<NonZeroNonNaN> for NegativeFinite<f64>
impl Sub<NonZeroNonNaN> for NegativeFinite<f64>
source§impl Sub<NonZeroNonNaN> for NonNaNFinite<f64>
impl Sub<NonZeroNonNaN> for NonNaNFinite<f64>
source§impl Sub<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
impl Sub<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
source§impl Sub<NonZeroNonNaN> for PositiveFinite<f64>
impl Sub<NonZeroNonNaN> for PositiveFinite<f64>
source§impl Sub<NonZeroNonNaN> for StrictlyNegative<f64>
impl Sub<NonZeroNonNaN> for StrictlyNegative<f64>
source§impl Sub<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
impl Sub<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
source§impl Sub<NonZeroNonNaN> for StrictlyPositive<f64>
impl Sub<NonZeroNonNaN> for StrictlyPositive<f64>
source§impl Sub<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
impl Sub<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
source§impl Sub<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl Sub<NonZeroNonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§impl Sub<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
impl Sub<NonZeroNonNaNFinite> for NonZeroNonNaN<f64>
source§impl Sub<PositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Sub<PositiveFinite<f32>> for NonZeroNonNaN<f32>
source§impl Sub<PositiveFinite> for NonZeroNonNaN<f64>
impl Sub<PositiveFinite> for NonZeroNonNaN<f64>
source§impl Sub<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
impl Sub<StrictlyNegative<f32>> for NonZeroNonNaN<f32>
source§impl Sub<StrictlyNegative> for NonZeroNonNaN<f64>
impl Sub<StrictlyNegative> for NonZeroNonNaN<f64>
source§impl Sub<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
impl Sub<StrictlyNegativeFinite<f32>> for NonZeroNonNaN<f32>
source§impl Sub<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
impl Sub<StrictlyNegativeFinite> for NonZeroNonNaN<f64>
source§impl Sub<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl Sub<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§impl Sub<StrictlyPositive> for NonZeroNonNaN<f64>
impl Sub<StrictlyPositive> for NonZeroNonNaN<f64>
source§impl Sub<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
impl Sub<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>
source§impl Sub<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
impl Sub<StrictlyPositiveFinite> for NonZeroNonNaN<f64>
source§impl Sub for NonZeroNonNaN<f64>
impl Sub for NonZeroNonNaN<f64>
source§impl Sub for NonZeroNonNaN<f32>
impl Sub for NonZeroNonNaN<f32>
source§impl TryFrom<NegativeFinite<f32>> for NonZeroNonNaN<f32>
impl TryFrom<NegativeFinite<f32>> for NonZeroNonNaN<f32>
source§impl TryFrom<NegativeFinite> for NonZeroNonNaN<f64>
impl TryFrom<NegativeFinite> for NonZeroNonNaN<f64>
source§impl TryFrom<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
impl TryFrom<NonNaNFinite<f32>> for NonZeroNonNaN<f32>
source§impl TryFrom<NonNaNFinite> for NonZeroNonNaN<f64>
impl TryFrom<NonNaNFinite> for NonZeroNonNaN<f64>
source§impl TryFrom<NonZeroNonNaN<f32>> for NegativeFinite<f32>
impl TryFrom<NonZeroNonNaN<f32>> for NegativeFinite<f32>
source§impl TryFrom<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
impl TryFrom<NonZeroNonNaN<f32>> for NonNaNFinite<f32>
source§impl TryFrom<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
impl TryFrom<NonZeroNonNaN<f32>> for NonZeroNonNaNFinite<f32>
source§impl TryFrom<NonZeroNonNaN<f32>> for PositiveFinite<f32>
impl TryFrom<NonZeroNonNaN<f32>> for PositiveFinite<f32>
source§impl TryFrom<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
impl TryFrom<NonZeroNonNaN<f32>> for StrictlyNegative<f32>
source§impl TryFrom<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
impl TryFrom<NonZeroNonNaN<f32>> for StrictlyNegativeFinite<f32>
source§impl TryFrom<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl TryFrom<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§impl TryFrom<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
impl TryFrom<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>
source§impl TryFrom<NonZeroNonNaN> for NegativeFinite<f64>
impl TryFrom<NonZeroNonNaN> for NegativeFinite<f64>
source§impl TryFrom<NonZeroNonNaN> for NonNaNFinite<f64>
impl TryFrom<NonZeroNonNaN> for NonNaNFinite<f64>
source§impl TryFrom<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
impl TryFrom<NonZeroNonNaN> for NonZeroNonNaNFinite<f64>
source§impl TryFrom<NonZeroNonNaN> for PositiveFinite<f64>
impl TryFrom<NonZeroNonNaN> for PositiveFinite<f64>
source§impl TryFrom<NonZeroNonNaN> for StrictlyNegative<f64>
impl TryFrom<NonZeroNonNaN> for StrictlyNegative<f64>
source§impl TryFrom<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
impl TryFrom<NonZeroNonNaN> for StrictlyNegativeFinite<f64>
source§impl TryFrom<NonZeroNonNaN> for StrictlyPositive<f64>
impl TryFrom<NonZeroNonNaN> for StrictlyPositive<f64>
source§impl TryFrom<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
impl TryFrom<NonZeroNonNaN> for StrictlyPositiveFinite<f64>
source§impl TryFrom<PositiveFinite<f32>> for NonZeroNonNaN<f32>
impl TryFrom<PositiveFinite<f32>> for NonZeroNonNaN<f32>
source§impl TryFrom<PositiveFinite> for NonZeroNonNaN<f64>
impl TryFrom<PositiveFinite> for NonZeroNonNaN<f64>
impl<T: Copy> Copy for NonZeroNonNaN<T>
impl Eq for NonZeroNonNaN<f64>
impl Eq for NonZeroNonNaN<f32>
Auto Trait Implementations§
impl<T> Freeze for NonZeroNonNaN<T>where
T: Freeze,
impl<T> RefUnwindSafe for NonZeroNonNaN<T>where
T: RefUnwindSafe,
impl<T> Send for NonZeroNonNaN<T>where
T: Send,
impl<T> Sync for NonZeroNonNaN<T>where
T: Sync,
impl<T> Unpin for NonZeroNonNaN<T>where
T: Unpin,
impl<T> UnwindSafe for NonZeroNonNaN<T>where
T: UnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)