Struct typed_floats::StrictlyPositive
source · pub struct StrictlyPositive<T = f64>(/* private fields */);
Expand description
A non-NaN strictly positive floating point number
It satisfies the following constraints:
- It is not NaN.
- It is not zero.
- It is not negative.
Implementations§
source§impl StrictlyPositive
impl StrictlyPositive
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 StrictlyPositive<f32>
impl StrictlyPositive<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 { StrictlyPositive::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::StrictlyPositive;
let x = StrictlyPositive::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::StrictlyPositive;
let x: StrictlyPositive = 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::StrictlyPositive;
let x: StrictlyPositive = 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::StrictlyPositive;
let x: StrictlyPositive = 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::StrictlyPositive;
let x: StrictlyPositive = 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::StrictlyPositive;
let x: StrictlyPositive = 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::StrictlyPositive;
let x: StrictlyPositive = 3.0.try_into().unwrap();
assert_eq!(x.classify(), core::num::FpCategory::Normal);
See f32::classify()
for more details.
sourcepub const fn is_sign_positive(&self) -> bool
pub const 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::StrictlyPositive;
let x: StrictlyPositive = 3.0.try_into().unwrap();
assert_eq!(x.is_sign_positive(), true);
See f32::is_sign_positive()
for more details.
sourcepub const fn is_sign_negative(&self) -> bool
pub const 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::StrictlyPositive;
let x: StrictlyPositive = 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::StrictlyPositive;
let x: StrictlyPositive = 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::StrictlyPositive;
let x: StrictlyPositive = 3.0.try_into().unwrap();
assert_eq!(x.is_positive_zero(), false);
source§impl StrictlyPositive<f64>
impl StrictlyPositive<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 { StrictlyPositive::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::StrictlyPositive;
let x = StrictlyPositive::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::StrictlyPositive;
let x: StrictlyPositive = 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::StrictlyPositive;
let x: StrictlyPositive = 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::StrictlyPositive;
let x: StrictlyPositive = 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::StrictlyPositive;
let x: StrictlyPositive = 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::StrictlyPositive;
let x: StrictlyPositive = 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::StrictlyPositive;
let x: StrictlyPositive = 3.0.try_into().unwrap();
assert_eq!(x.classify(), core::num::FpCategory::Normal);
See f64::classify()
for more details.
sourcepub const fn is_sign_positive(&self) -> bool
pub const 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::StrictlyPositive;
let x: StrictlyPositive = 3.0.try_into().unwrap();
assert_eq!(x.is_sign_positive(), true);
See f64::is_sign_positive()
for more details.
sourcepub const fn is_sign_negative(&self) -> bool
pub const 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::StrictlyPositive;
let x: StrictlyPositive = 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::StrictlyPositive;
let x: StrictlyPositive = 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::StrictlyPositive;
let x: StrictlyPositive = 3.0.try_into().unwrap();
assert_eq!(x.is_positive_zero(), false);
source§impl StrictlyPositive<f64>
impl StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn ceil(self) -> StrictlyPositive<f64>
pub fn ceil(self) -> StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn floor(self) -> Positive<f64>
pub fn floor(self) -> Positive<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn round(self) -> Positive<f64>
pub fn round(self) -> Positive<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn trunc(self) -> Positive<f64>
pub fn trunc(self) -> Positive<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 StrictlyPositive<f64>
impl StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn signum(self) -> StrictlyPositiveFinite<f64>
pub fn signum(self) -> StrictlyPositiveFinite<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn sqrt(self) -> StrictlyPositive<f64>
pub fn sqrt(self) -> StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn exp(self) -> StrictlyPositive<f64>
pub fn exp(self) -> StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn exp2(self) -> StrictlyPositive<f64>
pub fn exp2(self) -> StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn ln(self) -> NonNaN<f64>
pub fn ln(self) -> NonNaN<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn log2(self) -> NonNaN<f64>
pub fn log2(self) -> NonNaN<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn log10(self) -> NonNaN<f64>
pub fn log10(self) -> NonNaN<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn to_degrees(self) -> StrictlyPositive<f64>
pub fn to_degrees(self) -> StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn to_radians(self) -> StrictlyPositive<f64>
pub fn to_radians(self) -> StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn cbrt(self) -> StrictlyPositive<f64>
pub fn cbrt(self) -> StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn atan(self) -> StrictlyPositiveFinite<f64>
pub fn atan(self) -> StrictlyPositiveFinite<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn exp_m1(self) -> StrictlyPositive<f64>
pub fn exp_m1(self) -> StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn ln_1p(self) -> StrictlyPositive<f64>
pub fn ln_1p(self) -> StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn sinh(self) -> StrictlyPositive<f64>
pub fn sinh(self) -> StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn tanh(self) -> StrictlyPositiveFinite<f64>
pub fn tanh(self) -> StrictlyPositiveFinite<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn asinh(self) -> StrictlyPositive<f64>
pub fn asinh(self) -> StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn recip(self) -> PositiveFinite<f64>
pub fn recip(self) -> PositiveFinite<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 StrictlyPositive<f64>
impl StrictlyPositive<f64>
sourcepub fn powi(self, n: i32) -> Positive<f64>
pub fn powi(self, n: i32) -> Positive<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 StrictlyPositive<f32>
impl StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn ceil(self) -> StrictlyPositive<f32>
pub fn ceil(self) -> StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn floor(self) -> Positive<f32>
pub fn floor(self) -> Positive<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn round(self) -> Positive<f32>
pub fn round(self) -> Positive<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn trunc(self) -> Positive<f32>
pub fn trunc(self) -> Positive<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 StrictlyPositive<f32>
impl StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn signum(self) -> StrictlyPositiveFinite<f32>
pub fn signum(self) -> StrictlyPositiveFinite<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn sqrt(self) -> StrictlyPositive<f32>
pub fn sqrt(self) -> StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn exp(self) -> StrictlyPositive<f32>
pub fn exp(self) -> StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn exp2(self) -> StrictlyPositive<f32>
pub fn exp2(self) -> StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn ln(self) -> NonNaN<f32>
pub fn ln(self) -> NonNaN<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn log2(self) -> NonNaN<f32>
pub fn log2(self) -> NonNaN<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn log10(self) -> NonNaN<f32>
pub fn log10(self) -> NonNaN<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn to_degrees(self) -> StrictlyPositive<f32>
pub fn to_degrees(self) -> StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn to_radians(self) -> StrictlyPositive<f32>
pub fn to_radians(self) -> StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn cbrt(self) -> StrictlyPositive<f32>
pub fn cbrt(self) -> StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn atan(self) -> StrictlyPositiveFinite<f32>
pub fn atan(self) -> StrictlyPositiveFinite<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn exp_m1(self) -> StrictlyPositive<f32>
pub fn exp_m1(self) -> StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn ln_1p(self) -> StrictlyPositive<f32>
pub fn ln_1p(self) -> StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn sinh(self) -> StrictlyPositive<f32>
pub fn sinh(self) -> StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn tanh(self) -> StrictlyPositiveFinite<f32>
pub fn tanh(self) -> StrictlyPositiveFinite<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn asinh(self) -> StrictlyPositive<f32>
pub fn asinh(self) -> StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn recip(self) -> PositiveFinite<f32>
pub fn recip(self) -> PositiveFinite<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 StrictlyPositive<f32>
impl StrictlyPositive<f32>
sourcepub fn powi(self, n: i32) -> Positive<f32>
pub fn powi(self, n: i32) -> Positive<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 StrictlyPositive<f32>
impl Add<NegativeFinite<f32>> for StrictlyPositive<f32>
source§impl Add<NegativeFinite> for StrictlyPositive<f64>
impl Add<NegativeFinite> for StrictlyPositive<f64>
source§impl Add<NonNaNFinite<f32>> for StrictlyPositive<f32>
impl Add<NonNaNFinite<f32>> for StrictlyPositive<f32>
source§impl Add<NonNaNFinite> for StrictlyPositive<f64>
impl Add<NonNaNFinite> for StrictlyPositive<f64>
source§impl Add<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl Add<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§impl Add<NonZeroNonNaN> for StrictlyPositive<f64>
impl Add<NonZeroNonNaN> for StrictlyPositive<f64>
source§impl Add<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
impl Add<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
source§impl Add<NonZeroNonNaNFinite> for StrictlyPositive<f64>
impl Add<NonZeroNonNaNFinite> for StrictlyPositive<f64>
source§impl Add<PositiveFinite<f32>> for StrictlyPositive<f32>
impl Add<PositiveFinite<f32>> for StrictlyPositive<f32>
source§impl Add<PositiveFinite> for StrictlyPositive<f64>
impl Add<PositiveFinite> for StrictlyPositive<f64>
source§impl Add<StrictlyNegative<f32>> for StrictlyPositive<f32>
impl Add<StrictlyNegative<f32>> for StrictlyPositive<f32>
source§impl Add<StrictlyNegative> for StrictlyPositive<f64>
impl Add<StrictlyNegative> for StrictlyPositive<f64>
source§impl Add<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
impl Add<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
source§impl Add<StrictlyNegativeFinite> for StrictlyPositive<f64>
impl Add<StrictlyNegativeFinite> for StrictlyPositive<f64>
source§impl Add<StrictlyPositive<f32>> for NegativeFinite<f32>
impl Add<StrictlyPositive<f32>> for NegativeFinite<f32>
source§impl Add<StrictlyPositive<f32>> for NonNaNFinite<f32>
impl Add<StrictlyPositive<f32>> for NonNaNFinite<f32>
source§impl Add<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl Add<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§impl Add<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
impl Add<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
source§impl Add<StrictlyPositive<f32>> for PositiveFinite<f32>
impl Add<StrictlyPositive<f32>> for PositiveFinite<f32>
source§impl Add<StrictlyPositive<f32>> for StrictlyNegative<f32>
impl Add<StrictlyPositive<f32>> for StrictlyNegative<f32>
source§impl Add<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
impl Add<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
source§impl Add<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
impl Add<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
source§impl Add<StrictlyPositive> for NegativeFinite<f64>
impl Add<StrictlyPositive> for NegativeFinite<f64>
source§impl Add<StrictlyPositive> for NonNaNFinite<f64>
impl Add<StrictlyPositive> for NonNaNFinite<f64>
source§impl Add<StrictlyPositive> for NonZeroNonNaN<f64>
impl Add<StrictlyPositive> for NonZeroNonNaN<f64>
source§impl Add<StrictlyPositive> for NonZeroNonNaNFinite<f64>
impl Add<StrictlyPositive> for NonZeroNonNaNFinite<f64>
source§impl Add<StrictlyPositive> for PositiveFinite<f64>
impl Add<StrictlyPositive> for PositiveFinite<f64>
source§impl Add<StrictlyPositive> for StrictlyNegative<f64>
impl Add<StrictlyPositive> for StrictlyNegative<f64>
source§impl Add<StrictlyPositive> for StrictlyNegativeFinite<f64>
impl Add<StrictlyPositive> for StrictlyNegativeFinite<f64>
source§impl Add<StrictlyPositive> for StrictlyPositiveFinite<f64>
impl Add<StrictlyPositive> for StrictlyPositiveFinite<f64>
source§impl Add<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
impl Add<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
source§impl Add<StrictlyPositiveFinite> for StrictlyPositive<f64>
impl Add<StrictlyPositiveFinite> for StrictlyPositive<f64>
source§impl Add for StrictlyPositive<f64>
impl Add for StrictlyPositive<f64>
source§impl Add for StrictlyPositive<f32>
impl Add for StrictlyPositive<f32>
source§impl AddAssign<PositiveFinite<f32>> for StrictlyPositive<f32>
impl AddAssign<PositiveFinite<f32>> for StrictlyPositive<f32>
source§fn add_assign(&mut self, rhs: PositiveFinite<f32>)
fn add_assign(&mut self, rhs: PositiveFinite<f32>)
+=
operation. Read moresource§impl AddAssign<PositiveFinite> for StrictlyPositive<f64>
impl AddAssign<PositiveFinite> for StrictlyPositive<f64>
source§fn add_assign(&mut self, rhs: PositiveFinite<f64>)
fn add_assign(&mut self, rhs: PositiveFinite<f64>)
+=
operation. Read moresource§impl AddAssign<StrictlyPositive<f32>> for Positive<f32>
impl AddAssign<StrictlyPositive<f32>> for Positive<f32>
source§fn add_assign(&mut self, rhs: StrictlyPositive<f32>)
fn add_assign(&mut self, rhs: StrictlyPositive<f32>)
+=
operation. Read moresource§impl AddAssign<StrictlyPositive> for Positive<f64>
impl AddAssign<StrictlyPositive> for Positive<f64>
source§fn add_assign(&mut self, rhs: StrictlyPositive<f64>)
fn add_assign(&mut self, rhs: StrictlyPositive<f64>)
+=
operation. Read moresource§impl AddAssign<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
impl AddAssign<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
source§fn add_assign(&mut self, rhs: StrictlyPositiveFinite<f32>)
fn add_assign(&mut self, rhs: StrictlyPositiveFinite<f32>)
+=
operation. Read moresource§impl AddAssign<StrictlyPositiveFinite> for StrictlyPositive<f64>
impl AddAssign<StrictlyPositiveFinite> for StrictlyPositive<f64>
source§fn add_assign(&mut self, rhs: StrictlyPositiveFinite<f64>)
fn add_assign(&mut self, rhs: StrictlyPositiveFinite<f64>)
+=
operation. Read moresource§impl AddAssign for StrictlyPositive<f64>
impl AddAssign for StrictlyPositive<f64>
source§fn add_assign(&mut self, rhs: StrictlyPositive<f64>)
fn add_assign(&mut self, rhs: StrictlyPositive<f64>)
+=
operation. Read moresource§impl AddAssign for StrictlyPositive<f32>
impl AddAssign for StrictlyPositive<f32>
source§fn add_assign(&mut self, rhs: StrictlyPositive<f32>)
fn add_assign(&mut self, rhs: StrictlyPositive<f32>)
+=
operation. Read moresource§impl Atan2<NegativeFinite<f32>> for StrictlyPositive<f32>
impl Atan2<NegativeFinite<f32>> for StrictlyPositive<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<NegativeFinite> for StrictlyPositive<f64>
impl Atan2<NegativeFinite> for StrictlyPositive<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<NonNaNFinite<f32>> for StrictlyPositive<f32>
impl Atan2<NonNaNFinite<f32>> for StrictlyPositive<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<NonNaNFinite> for StrictlyPositive<f64>
impl Atan2<NonNaNFinite> for StrictlyPositive<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
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> for StrictlyPositive<f64>
impl Atan2<NonZeroNonNaN> for StrictlyPositive<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
impl Atan2<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<NonZeroNonNaNFinite> for StrictlyPositive<f64>
impl Atan2<NonZeroNonNaNFinite> for StrictlyPositive<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<PositiveFinite<f32>> for StrictlyPositive<f32>
impl Atan2<PositiveFinite<f32>> for StrictlyPositive<f32>
source§type Output = PositiveFinite<f32>
type Output = PositiveFinite<f32>
Atan2::atan2()
.source§impl Atan2<PositiveFinite> for StrictlyPositive<f64>
impl Atan2<PositiveFinite> for StrictlyPositive<f64>
source§type Output = PositiveFinite
type Output = PositiveFinite
Atan2::atan2()
.source§impl Atan2<StrictlyNegative<f32>> for StrictlyPositive<f32>
impl Atan2<StrictlyNegative<f32>> for StrictlyPositive<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<StrictlyNegative> for StrictlyPositive<f64>
impl Atan2<StrictlyNegative> for StrictlyPositive<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
impl Atan2<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<StrictlyNegativeFinite> for StrictlyPositive<f64>
impl Atan2<StrictlyNegativeFinite> for StrictlyPositive<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<StrictlyPositive<f32>> for Negative<f32>
impl Atan2<StrictlyPositive<f32>> for Negative<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<StrictlyPositive<f32>> for NegativeFinite<f32>
impl Atan2<StrictlyPositive<f32>> for NegativeFinite<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<StrictlyPositive<f32>> for NonNaN<f32>
impl Atan2<StrictlyPositive<f32>> for NonNaN<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<StrictlyPositive<f32>> for NonNaNFinite<f32>
impl Atan2<StrictlyPositive<f32>> for NonNaNFinite<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
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<f32>> for NonZeroNonNaNFinite<f32>
impl Atan2<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<StrictlyPositive<f32>> for Positive<f32>
impl Atan2<StrictlyPositive<f32>> for Positive<f32>
source§type Output = PositiveFinite<f32>
type Output = PositiveFinite<f32>
Atan2::atan2()
.source§impl Atan2<StrictlyPositive<f32>> for PositiveFinite<f32>
impl Atan2<StrictlyPositive<f32>> for PositiveFinite<f32>
source§type Output = PositiveFinite<f32>
type Output = PositiveFinite<f32>
Atan2::atan2()
.source§impl Atan2<StrictlyPositive<f32>> for StrictlyNegative<f32>
impl Atan2<StrictlyPositive<f32>> for StrictlyNegative<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
impl Atan2<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Atan2::atan2()
.source§impl Atan2<StrictlyPositive<f32>> for StrictlyPositive<f32>
impl Atan2<StrictlyPositive<f32>> for StrictlyPositive<f32>
source§type Output = PositiveFinite<f32>
type Output = PositiveFinite<f32>
Atan2::atan2()
.source§impl Atan2<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
impl Atan2<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
source§type Output = PositiveFinite<f32>
type Output = PositiveFinite<f32>
Atan2::atan2()
.source§impl Atan2<StrictlyPositive> for Negative<f64>
impl Atan2<StrictlyPositive> for Negative<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<StrictlyPositive> for NegativeFinite<f64>
impl Atan2<StrictlyPositive> for NegativeFinite<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<StrictlyPositive> for NonNaN<f64>
impl Atan2<StrictlyPositive> for NonNaN<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<StrictlyPositive> for NonNaNFinite<f64>
impl Atan2<StrictlyPositive> for NonNaNFinite<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
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<StrictlyPositive> for NonZeroNonNaNFinite<f64>
impl Atan2<StrictlyPositive> for NonZeroNonNaNFinite<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<StrictlyPositive> for Positive<f64>
impl Atan2<StrictlyPositive> for Positive<f64>
source§type Output = PositiveFinite
type Output = PositiveFinite
Atan2::atan2()
.source§impl Atan2<StrictlyPositive> for PositiveFinite<f64>
impl Atan2<StrictlyPositive> for PositiveFinite<f64>
source§type Output = PositiveFinite
type Output = PositiveFinite
Atan2::atan2()
.source§impl Atan2<StrictlyPositive> for StrictlyNegative<f64>
impl Atan2<StrictlyPositive> for StrictlyNegative<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<StrictlyPositive> for StrictlyNegativeFinite<f64>
impl Atan2<StrictlyPositive> for StrictlyNegativeFinite<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Atan2::atan2()
.source§impl Atan2<StrictlyPositive> for StrictlyPositive<f64>
impl Atan2<StrictlyPositive> for StrictlyPositive<f64>
source§type Output = PositiveFinite
type Output = PositiveFinite
Atan2::atan2()
.source§impl Atan2<StrictlyPositive> for StrictlyPositiveFinite<f64>
impl Atan2<StrictlyPositive> for StrictlyPositiveFinite<f64>
source§type Output = PositiveFinite
type Output = PositiveFinite
Atan2::atan2()
.source§impl Atan2<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
impl Atan2<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
source§type Output = PositiveFinite<f32>
type Output = PositiveFinite<f32>
Atan2::atan2()
.source§impl Atan2<StrictlyPositiveFinite> for StrictlyPositive<f64>
impl Atan2<StrictlyPositiveFinite> for StrictlyPositive<f64>
source§type Output = PositiveFinite
type Output = PositiveFinite
Atan2::atan2()
.source§impl<T: Clone> Clone for StrictlyPositive<T>
impl<T: Clone> Clone for StrictlyPositive<T>
source§fn clone(&self) -> StrictlyPositive<T>
fn clone(&self) -> StrictlyPositive<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 StrictlyPositive<f32>
impl Copysign<Negative<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyNegative<f32>
type Output = StrictlyNegative<f32>
Copysign::copysign()
.source§impl Copysign<Negative> for StrictlyPositive<f64>
impl Copysign<Negative> for StrictlyPositive<f64>
source§type Output = StrictlyNegative
type Output = StrictlyNegative
Copysign::copysign()
.source§impl Copysign<NegativeFinite<f32>> for StrictlyPositive<f32>
impl Copysign<NegativeFinite<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyNegative<f32>
type Output = StrictlyNegative<f32>
Copysign::copysign()
.source§impl Copysign<NegativeFinite> for StrictlyPositive<f64>
impl Copysign<NegativeFinite> for StrictlyPositive<f64>
source§type Output = StrictlyNegative
type Output = StrictlyNegative
Copysign::copysign()
.source§impl Copysign<NonNaN<f32>> for StrictlyPositive<f32>
impl Copysign<NonNaN<f32>> for StrictlyPositive<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Copysign::copysign()
.source§impl Copysign<NonNaN> for StrictlyPositive<f64>
impl Copysign<NonNaN> for StrictlyPositive<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Copysign::copysign()
.source§impl Copysign<NonNaNFinite<f32>> for StrictlyPositive<f32>
impl Copysign<NonNaNFinite<f32>> for StrictlyPositive<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Copysign::copysign()
.source§impl Copysign<NonNaNFinite> for StrictlyPositive<f64>
impl Copysign<NonNaNFinite> for StrictlyPositive<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
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> for StrictlyPositive<f64>
impl Copysign<NonZeroNonNaN> for StrictlyPositive<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
impl Copysign<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
source§type Output = NonZeroNonNaN<f32>
type Output = NonZeroNonNaN<f32>
Copysign::copysign()
.source§impl Copysign<NonZeroNonNaNFinite> for StrictlyPositive<f64>
impl Copysign<NonZeroNonNaNFinite> for StrictlyPositive<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Copysign::copysign()
.source§impl Copysign<Positive<f32>> for StrictlyPositive<f32>
impl Copysign<Positive<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Copysign::copysign()
.source§impl Copysign<Positive> for StrictlyPositive<f64>
impl Copysign<Positive> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Copysign::copysign()
.source§impl Copysign<PositiveFinite<f32>> for StrictlyPositive<f32>
impl Copysign<PositiveFinite<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Copysign::copysign()
.source§impl Copysign<PositiveFinite> for StrictlyPositive<f64>
impl Copysign<PositiveFinite> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Copysign::copysign()
.source§impl Copysign<StrictlyNegative<f32>> for StrictlyPositive<f32>
impl Copysign<StrictlyNegative<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyNegative<f32>
type Output = StrictlyNegative<f32>
Copysign::copysign()
.source§impl Copysign<StrictlyNegative> for StrictlyPositive<f64>
impl Copysign<StrictlyNegative> for StrictlyPositive<f64>
source§type Output = StrictlyNegative
type Output = StrictlyNegative
Copysign::copysign()
.source§impl Copysign<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
impl Copysign<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyNegative<f32>
type Output = StrictlyNegative<f32>
Copysign::copysign()
.source§impl Copysign<StrictlyNegativeFinite> for StrictlyPositive<f64>
impl Copysign<StrictlyNegativeFinite> for StrictlyPositive<f64>
source§type Output = StrictlyNegative
type Output = StrictlyNegative
Copysign::copysign()
.source§impl Copysign<StrictlyPositive<f32>> for NegativeFinite<f32>
impl Copysign<StrictlyPositive<f32>> for NegativeFinite<f32>
source§type Output = PositiveFinite<f32>
type Output = PositiveFinite<f32>
Copysign::copysign()
.source§impl Copysign<StrictlyPositive<f32>> for NonNaNFinite<f32>
impl Copysign<StrictlyPositive<f32>> for NonNaNFinite<f32>
source§type Output = PositiveFinite<f32>
type Output = PositiveFinite<f32>
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<f32>> for NonZeroNonNaNFinite<f32>
impl Copysign<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
source§type Output = StrictlyPositiveFinite<f32>
type Output = StrictlyPositiveFinite<f32>
Copysign::copysign()
.source§impl Copysign<StrictlyPositive<f32>> for PositiveFinite<f32>
impl Copysign<StrictlyPositive<f32>> for PositiveFinite<f32>
source§type Output = PositiveFinite<f32>
type Output = PositiveFinite<f32>
Copysign::copysign()
.source§impl Copysign<StrictlyPositive<f32>> for StrictlyNegative<f32>
impl Copysign<StrictlyPositive<f32>> for StrictlyNegative<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Copysign::copysign()
.source§impl Copysign<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
impl Copysign<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
source§type Output = StrictlyPositiveFinite<f32>
type Output = StrictlyPositiveFinite<f32>
Copysign::copysign()
.source§impl Copysign<StrictlyPositive<f32>> for StrictlyPositive<f32>
impl Copysign<StrictlyPositive<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Copysign::copysign()
.source§impl Copysign<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
impl Copysign<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
source§type Output = StrictlyPositiveFinite<f32>
type Output = StrictlyPositiveFinite<f32>
Copysign::copysign()
.source§impl Copysign<StrictlyPositive> for Negative<f64>
impl Copysign<StrictlyPositive> for Negative<f64>
source§type Output = Positive
type Output = Positive
Copysign::copysign()
.source§impl Copysign<StrictlyPositive> for NegativeFinite<f64>
impl Copysign<StrictlyPositive> for NegativeFinite<f64>
source§type Output = PositiveFinite
type Output = PositiveFinite
Copysign::copysign()
.source§impl Copysign<StrictlyPositive> for NonNaN<f64>
impl Copysign<StrictlyPositive> for NonNaN<f64>
source§type Output = Positive
type Output = Positive
Copysign::copysign()
.source§impl Copysign<StrictlyPositive> for NonNaNFinite<f64>
impl Copysign<StrictlyPositive> for NonNaNFinite<f64>
source§type Output = PositiveFinite
type Output = PositiveFinite
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<StrictlyPositive> for NonZeroNonNaNFinite<f64>
impl Copysign<StrictlyPositive> for NonZeroNonNaNFinite<f64>
source§type Output = StrictlyPositiveFinite
type Output = StrictlyPositiveFinite
Copysign::copysign()
.source§impl Copysign<StrictlyPositive> for Positive<f64>
impl Copysign<StrictlyPositive> for Positive<f64>
source§type Output = Positive
type Output = Positive
Copysign::copysign()
.source§impl Copysign<StrictlyPositive> for PositiveFinite<f64>
impl Copysign<StrictlyPositive> for PositiveFinite<f64>
source§type Output = PositiveFinite
type Output = PositiveFinite
Copysign::copysign()
.source§impl Copysign<StrictlyPositive> for StrictlyNegative<f64>
impl Copysign<StrictlyPositive> for StrictlyNegative<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Copysign::copysign()
.source§impl Copysign<StrictlyPositive> for StrictlyNegativeFinite<f64>
impl Copysign<StrictlyPositive> for StrictlyNegativeFinite<f64>
source§type Output = StrictlyPositiveFinite
type Output = StrictlyPositiveFinite
Copysign::copysign()
.source§impl Copysign<StrictlyPositive> for StrictlyPositive<f64>
impl Copysign<StrictlyPositive> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Copysign::copysign()
.source§impl Copysign<StrictlyPositive> for StrictlyPositiveFinite<f64>
impl Copysign<StrictlyPositive> for StrictlyPositiveFinite<f64>
source§type Output = StrictlyPositiveFinite
type Output = StrictlyPositiveFinite
Copysign::copysign()
.source§impl Copysign<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
impl Copysign<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Copysign::copysign()
.source§impl Copysign<StrictlyPositiveFinite> for StrictlyPositive<f64>
impl Copysign<StrictlyPositiveFinite> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Copysign::copysign()
.source§impl<T: Debug> Debug for StrictlyPositive<T>
impl<T: Debug> Debug for StrictlyPositive<T>
source§impl<'de> Deserialize<'de> for StrictlyPositive<f64>
impl<'de> Deserialize<'de> for StrictlyPositive<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 StrictlyPositive<f32>
impl<'de> Deserialize<'de> for StrictlyPositive<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 StrictlyPositive<f64>
impl Display for StrictlyPositive<f64>
source§impl Display for StrictlyPositive<f32>
impl Display for StrictlyPositive<f32>
source§impl Div<NegativeFinite<f32>> for StrictlyPositive<f32>
impl Div<NegativeFinite<f32>> for StrictlyPositive<f32>
source§impl Div<NegativeFinite> for StrictlyPositive<f64>
impl Div<NegativeFinite> for StrictlyPositive<f64>
source§impl Div<NonNaNFinite<f32>> for StrictlyPositive<f32>
impl Div<NonNaNFinite<f32>> for StrictlyPositive<f32>
source§impl Div<NonNaNFinite> for StrictlyPositive<f64>
impl Div<NonNaNFinite> for StrictlyPositive<f64>
source§impl Div<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl Div<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§impl Div<NonZeroNonNaN> for StrictlyPositive<f64>
impl Div<NonZeroNonNaN> for StrictlyPositive<f64>
source§impl Div<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
impl Div<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
source§impl Div<NonZeroNonNaNFinite> for StrictlyPositive<f64>
impl Div<NonZeroNonNaNFinite> for StrictlyPositive<f64>
source§impl Div<PositiveFinite<f32>> for StrictlyPositive<f32>
impl Div<PositiveFinite<f32>> for StrictlyPositive<f32>
source§impl Div<PositiveFinite> for StrictlyPositive<f64>
impl Div<PositiveFinite> for StrictlyPositive<f64>
source§impl Div<StrictlyNegative<f32>> for StrictlyPositive<f32>
impl Div<StrictlyNegative<f32>> for StrictlyPositive<f32>
source§impl Div<StrictlyNegative> for StrictlyPositive<f64>
impl Div<StrictlyNegative> for StrictlyPositive<f64>
source§impl Div<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
impl Div<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
source§impl Div<StrictlyNegativeFinite> for StrictlyPositive<f64>
impl Div<StrictlyNegativeFinite> for StrictlyPositive<f64>
source§impl Div<StrictlyPositive<f32>> for NegativeFinite<f32>
impl Div<StrictlyPositive<f32>> for NegativeFinite<f32>
source§impl Div<StrictlyPositive<f32>> for NonNaNFinite<f32>
impl Div<StrictlyPositive<f32>> for NonNaNFinite<f32>
source§impl Div<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl Div<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§impl Div<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
impl Div<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
source§impl Div<StrictlyPositive<f32>> for PositiveFinite<f32>
impl Div<StrictlyPositive<f32>> for PositiveFinite<f32>
source§impl Div<StrictlyPositive<f32>> for StrictlyNegative<f32>
impl Div<StrictlyPositive<f32>> for StrictlyNegative<f32>
source§impl Div<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
impl Div<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
source§impl Div<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
impl Div<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
source§impl Div<StrictlyPositive> for NegativeFinite<f64>
impl Div<StrictlyPositive> for NegativeFinite<f64>
source§impl Div<StrictlyPositive> for NonNaNFinite<f64>
impl Div<StrictlyPositive> for NonNaNFinite<f64>
source§impl Div<StrictlyPositive> for NonZeroNonNaN<f64>
impl Div<StrictlyPositive> for NonZeroNonNaN<f64>
source§impl Div<StrictlyPositive> for NonZeroNonNaNFinite<f64>
impl Div<StrictlyPositive> for NonZeroNonNaNFinite<f64>
source§impl Div<StrictlyPositive> for PositiveFinite<f64>
impl Div<StrictlyPositive> for PositiveFinite<f64>
source§impl Div<StrictlyPositive> for StrictlyNegative<f64>
impl Div<StrictlyPositive> for StrictlyNegative<f64>
source§impl Div<StrictlyPositive> for StrictlyNegativeFinite<f64>
impl Div<StrictlyPositive> for StrictlyNegativeFinite<f64>
source§impl Div<StrictlyPositive> for StrictlyPositiveFinite<f64>
impl Div<StrictlyPositive> for StrictlyPositiveFinite<f64>
source§impl Div<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
impl Div<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
source§impl Div<StrictlyPositiveFinite> for StrictlyPositive<f64>
impl Div<StrictlyPositiveFinite> for StrictlyPositive<f64>
source§impl Div for StrictlyPositive<f64>
impl Div for StrictlyPositive<f64>
source§impl Div for StrictlyPositive<f32>
impl Div for StrictlyPositive<f32>
source§impl DivEuclid<Negative<f32>> for StrictlyPositive<f32>
impl DivEuclid<Negative<f32>> for StrictlyPositive<f32>
source§type Output = f32
type Output = f32
DivEuclid::div_euclid()
.source§impl DivEuclid<Negative> for StrictlyPositive<f64>
impl DivEuclid<Negative> for StrictlyPositive<f64>
source§type Output = f64
type Output = f64
DivEuclid::div_euclid()
.source§impl DivEuclid<NegativeFinite<f32>> for StrictlyPositive<f32>
impl DivEuclid<NegativeFinite<f32>> for StrictlyPositive<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 StrictlyPositive<f64>
impl DivEuclid<NegativeFinite> for StrictlyPositive<f64>
source§type Output = Negative
type Output = Negative
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 StrictlyPositive<f32>
impl DivEuclid<NonNaN<f32>> for StrictlyPositive<f32>
source§type Output = f32
type Output = f32
DivEuclid::div_euclid()
.source§impl DivEuclid<NonNaN> for StrictlyPositive<f64>
impl DivEuclid<NonNaN> for StrictlyPositive<f64>
source§type Output = f64
type Output = f64
DivEuclid::div_euclid()
.source§impl DivEuclid<NonNaNFinite<f32>> for StrictlyPositive<f32>
impl DivEuclid<NonNaNFinite<f32>> for StrictlyPositive<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 StrictlyPositive<f64>
impl DivEuclid<NonNaNFinite> for StrictlyPositive<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 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> 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<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
impl DivEuclid<NonZeroNonNaNFinite<f32>> for StrictlyPositive<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 StrictlyPositive<f64>
impl DivEuclid<NonZeroNonNaNFinite> for StrictlyPositive<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 StrictlyPositive<f32>
impl DivEuclid<Positive<f32>> for StrictlyPositive<f32>
source§type Output = f32
type Output = f32
DivEuclid::div_euclid()
.source§impl DivEuclid<Positive> for StrictlyPositive<f64>
impl DivEuclid<Positive> for StrictlyPositive<f64>
source§type Output = f64
type Output = f64
DivEuclid::div_euclid()
.source§impl DivEuclid<PositiveFinite<f32>> for StrictlyPositive<f32>
impl DivEuclid<PositiveFinite<f32>> for StrictlyPositive<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 StrictlyPositive<f64>
impl DivEuclid<PositiveFinite> for StrictlyPositive<f64>
source§type Output = Positive
type Output = Positive
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 StrictlyPositive<f32>
impl DivEuclid<StrictlyNegative<f32>> for StrictlyPositive<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 StrictlyPositive<f64>
impl DivEuclid<StrictlyNegative> for StrictlyPositive<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 StrictlyPositive<f32>
impl DivEuclid<StrictlyNegativeFinite<f32>> for StrictlyPositive<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 StrictlyPositive<f64>
impl DivEuclid<StrictlyNegativeFinite> for StrictlyPositive<f64>
source§type Output = Negative
type Output = Negative
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 Negative<f32>
impl DivEuclid<StrictlyPositive<f32>> for Negative<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<f32>> for NegativeFinite<f32>
impl DivEuclid<StrictlyPositive<f32>> for NegativeFinite<f32>
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<f32>> for NonNaN<f32>
impl DivEuclid<StrictlyPositive<f32>> for NonNaN<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<f32>> for NonNaNFinite<f32>
impl DivEuclid<StrictlyPositive<f32>> for NonNaNFinite<f32>
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<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<f32>> for NonZeroNonNaNFinite<f32>
impl DivEuclid<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
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<f32>> for Positive<f32>
impl DivEuclid<StrictlyPositive<f32>> for Positive<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<f32>> for PositiveFinite<f32>
impl DivEuclid<StrictlyPositive<f32>> for PositiveFinite<f32>
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<f32>> for StrictlyNegative<f32>
impl DivEuclid<StrictlyPositive<f32>> for StrictlyNegative<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<f32>> for StrictlyNegativeFinite<f32>
impl DivEuclid<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
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<f32>> for StrictlyPositive<f32>
impl DivEuclid<StrictlyPositive<f32>> for StrictlyPositive<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<f32>> for StrictlyPositiveFinite<f32>
impl DivEuclid<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
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 Negative<f64>
impl DivEuclid<StrictlyPositive> for Negative<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<StrictlyPositive> for NegativeFinite<f64>
impl DivEuclid<StrictlyPositive> for NegativeFinite<f64>
source§type Output = Negative
type Output = Negative
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<StrictlyPositive> for NonNaN<f64>
impl DivEuclid<StrictlyPositive> for NonNaN<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<StrictlyPositive> for NonNaNFinite<f64>
impl DivEuclid<StrictlyPositive> for NonNaNFinite<f64>
source§type Output = NonNaN
type Output = NonNaN
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<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<StrictlyPositive> for NonZeroNonNaNFinite<f64>
impl DivEuclid<StrictlyPositive> for NonZeroNonNaNFinite<f64>
source§type Output = NonNaN
type Output = NonNaN
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<StrictlyPositive> for Positive<f64>
impl DivEuclid<StrictlyPositive> for Positive<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<StrictlyPositive> for PositiveFinite<f64>
impl DivEuclid<StrictlyPositive> for PositiveFinite<f64>
source§type Output = Positive
type Output = Positive
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<StrictlyPositive> for StrictlyNegative<f64>
impl DivEuclid<StrictlyPositive> for StrictlyNegative<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<StrictlyPositive> for StrictlyNegativeFinite<f64>
impl DivEuclid<StrictlyPositive> for StrictlyNegativeFinite<f64>
source§type Output = Negative
type Output = Negative
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<StrictlyPositive> for StrictlyPositive<f64>
impl DivEuclid<StrictlyPositive> for StrictlyPositive<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<StrictlyPositive> for StrictlyPositiveFinite<f64>
impl DivEuclid<StrictlyPositive> for StrictlyPositiveFinite<f64>
source§type Output = Positive
type Output = Positive
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 StrictlyPositive<f32>
impl DivEuclid<StrictlyPositiveFinite<f32>> for StrictlyPositive<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 StrictlyPositive<f64>
impl DivEuclid<StrictlyPositiveFinite> for StrictlyPositive<f64>
source§type Output = Positive
type Output = Positive
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<u16>> for StrictlyPositive<f64>
impl From<NonZero<u16>> for StrictlyPositive<f64>
source§fn from(value: NonZeroU16) -> Self
fn from(value: NonZeroU16) -> Self
source§impl From<NonZero<u16>> for StrictlyPositive<f32>
impl From<NonZero<u16>> for StrictlyPositive<f32>
source§fn from(value: NonZeroU16) -> Self
fn from(value: NonZeroU16) -> Self
source§impl From<NonZero<u32>> for StrictlyPositive<f64>
impl From<NonZero<u32>> for StrictlyPositive<f64>
source§fn from(value: NonZeroU32) -> Self
fn from(value: NonZeroU32) -> Self
source§impl From<NonZero<u32>> for StrictlyPositive<f32>
impl From<NonZero<u32>> for StrictlyPositive<f32>
source§fn from(value: NonZeroU32) -> Self
fn from(value: NonZeroU32) -> Self
source§impl From<NonZero<u64>> for StrictlyPositive<f64>
impl From<NonZero<u64>> for StrictlyPositive<f64>
source§fn from(value: NonZeroU64) -> Self
fn from(value: NonZeroU64) -> Self
source§impl From<NonZero<u64>> for StrictlyPositive<f32>
impl From<NonZero<u64>> for StrictlyPositive<f32>
source§fn from(value: NonZeroU64) -> Self
fn from(value: NonZeroU64) -> Self
source§impl From<StrictlyPositive<f32>> for NonNaN<f32>
impl From<StrictlyPositive<f32>> for NonNaN<f32>
source§fn from(value: StrictlyPositive<f32>) -> Self
fn from(value: StrictlyPositive<f32>) -> 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<f32>> for Positive<f32>
impl From<StrictlyPositive<f32>> for Positive<f32>
source§fn from(value: StrictlyPositive<f32>) -> Self
fn from(value: StrictlyPositive<f32>) -> Self
source§impl From<StrictlyPositive<f32>> for f32
impl From<StrictlyPositive<f32>> for f32
source§fn from(value: StrictlyPositive<Self>) -> Self
fn from(value: StrictlyPositive<Self>) -> Self
source§impl From<StrictlyPositive> for NonNaN<f64>
impl From<StrictlyPositive> for NonNaN<f64>
source§fn from(value: StrictlyPositive<f64>) -> Self
fn from(value: StrictlyPositive<f64>) -> 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<StrictlyPositive> for Positive<f64>
impl From<StrictlyPositive> for Positive<f64>
source§fn from(value: StrictlyPositive<f64>) -> Self
fn from(value: StrictlyPositive<f64>) -> Self
source§impl From<StrictlyPositive> for f64
impl From<StrictlyPositive> for f64
source§fn from(value: StrictlyPositive<Self>) -> Self
fn from(value: StrictlyPositive<Self>) -> Self
source§impl From<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
impl From<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
source§fn from(value: StrictlyPositiveFinite<f32>) -> Self
fn from(value: StrictlyPositiveFinite<f32>) -> Self
source§impl From<StrictlyPositiveFinite> for StrictlyPositive<f64>
impl From<StrictlyPositiveFinite> for StrictlyPositive<f64>
source§fn from(value: StrictlyPositiveFinite<f64>) -> Self
fn from(value: StrictlyPositiveFinite<f64>) -> Self
source§impl FromStr for StrictlyPositive<f64>
impl FromStr for StrictlyPositive<f64>
source§impl FromStr for StrictlyPositive<f32>
impl FromStr for StrictlyPositive<f32>
source§impl Hash for StrictlyPositive<f64>
impl Hash for StrictlyPositive<f64>
source§impl Hash for StrictlyPositive<f32>
impl Hash for StrictlyPositive<f32>
source§impl Hypot<Negative<f32>> for StrictlyPositive<f32>
impl Hypot<Negative<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<Negative> for StrictlyPositive<f64>
impl Hypot<Negative> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NegativeFinite<f32>> for StrictlyPositive<f32>
impl Hypot<NegativeFinite<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NegativeFinite> for StrictlyPositive<f64>
impl Hypot<NegativeFinite> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NonNaN<f32>> for StrictlyPositive<f32>
impl Hypot<NonNaN<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NonNaN> for StrictlyPositive<f64>
impl Hypot<NonNaN> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NonNaNFinite<f32>> for StrictlyPositive<f32>
impl Hypot<NonNaNFinite<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NonNaNFinite> for StrictlyPositive<f64>
impl Hypot<NonNaNFinite> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
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> for StrictlyPositive<f64>
impl Hypot<NonZeroNonNaN> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
impl Hypot<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<NonZeroNonNaNFinite> for StrictlyPositive<f64>
impl Hypot<NonZeroNonNaNFinite> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<Positive<f32>> for StrictlyPositive<f32>
impl Hypot<Positive<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<Positive> for StrictlyPositive<f64>
impl Hypot<Positive> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<PositiveFinite<f32>> for StrictlyPositive<f32>
impl Hypot<PositiveFinite<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<PositiveFinite> for StrictlyPositive<f64>
impl Hypot<PositiveFinite> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<StrictlyNegative<f32>> for StrictlyPositive<f32>
impl Hypot<StrictlyNegative<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<StrictlyNegative> for StrictlyPositive<f64>
impl Hypot<StrictlyNegative> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
impl Hypot<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<StrictlyNegativeFinite> for StrictlyPositive<f64>
impl Hypot<StrictlyNegativeFinite> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<StrictlyPositive<f32>> for Negative<f32>
impl Hypot<StrictlyPositive<f32>> for Negative<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<StrictlyPositive<f32>> for NegativeFinite<f32>
impl Hypot<StrictlyPositive<f32>> for NegativeFinite<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<StrictlyPositive<f32>> for NonNaN<f32>
impl Hypot<StrictlyPositive<f32>> for NonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<StrictlyPositive<f32>> for NonNaNFinite<f32>
impl Hypot<StrictlyPositive<f32>> for NonNaNFinite<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
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<f32>> for NonZeroNonNaNFinite<f32>
impl Hypot<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<StrictlyPositive<f32>> for Positive<f32>
impl Hypot<StrictlyPositive<f32>> for Positive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<StrictlyPositive<f32>> for PositiveFinite<f32>
impl Hypot<StrictlyPositive<f32>> for PositiveFinite<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<StrictlyPositive<f32>> for StrictlyNegative<f32>
impl Hypot<StrictlyPositive<f32>> for StrictlyNegative<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
impl Hypot<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<StrictlyPositive<f32>> for StrictlyPositive<f32>
impl Hypot<StrictlyPositive<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
impl Hypot<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<StrictlyPositive> for Negative<f64>
impl Hypot<StrictlyPositive> for Negative<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<StrictlyPositive> for NegativeFinite<f64>
impl Hypot<StrictlyPositive> for NegativeFinite<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<StrictlyPositive> for NonNaN<f64>
impl Hypot<StrictlyPositive> for NonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<StrictlyPositive> for NonNaNFinite<f64>
impl Hypot<StrictlyPositive> for NonNaNFinite<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
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<StrictlyPositive> for NonZeroNonNaNFinite<f64>
impl Hypot<StrictlyPositive> for NonZeroNonNaNFinite<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<StrictlyPositive> for Positive<f64>
impl Hypot<StrictlyPositive> for Positive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<StrictlyPositive> for PositiveFinite<f64>
impl Hypot<StrictlyPositive> for PositiveFinite<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<StrictlyPositive> for StrictlyNegative<f64>
impl Hypot<StrictlyPositive> for StrictlyNegative<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<StrictlyPositive> for StrictlyNegativeFinite<f64>
impl Hypot<StrictlyPositive> for StrictlyNegativeFinite<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<StrictlyPositive> for StrictlyPositive<f64>
impl Hypot<StrictlyPositive> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<StrictlyPositive> for StrictlyPositiveFinite<f64>
impl Hypot<StrictlyPositive> for StrictlyPositiveFinite<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Hypot<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
impl Hypot<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Hypot::hypot()
.source§impl Hypot<StrictlyPositiveFinite> for StrictlyPositive<f64>
impl Hypot<StrictlyPositiveFinite> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Hypot::hypot()
.source§impl Max<NegativeFinite<f32>> for StrictlyPositive<f32>
impl Max<NegativeFinite<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<NegativeFinite> for StrictlyPositive<f64>
impl Max<NegativeFinite> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Max<NonNaNFinite<f32>> for StrictlyPositive<f32>
impl Max<NonNaNFinite<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<NonNaNFinite> for StrictlyPositive<f64>
impl Max<NonNaNFinite> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
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> for StrictlyPositive<f64>
impl Max<NonZeroNonNaN> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Max<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
impl Max<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<NonZeroNonNaNFinite> for StrictlyPositive<f64>
impl Max<NonZeroNonNaNFinite> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Max<PositiveFinite<f32>> for StrictlyPositive<f32>
impl Max<PositiveFinite<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<PositiveFinite> for StrictlyPositive<f64>
impl Max<PositiveFinite> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Max<StrictlyNegative<f32>> for StrictlyPositive<f32>
impl Max<StrictlyNegative<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<StrictlyNegative> for StrictlyPositive<f64>
impl Max<StrictlyNegative> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Max<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
impl Max<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<StrictlyNegativeFinite> for StrictlyPositive<f64>
impl Max<StrictlyNegativeFinite> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Max<StrictlyPositive<f32>> for Negative<f32>
impl Max<StrictlyPositive<f32>> for Negative<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<StrictlyPositive<f32>> for NegativeFinite<f32>
impl Max<StrictlyPositive<f32>> for NegativeFinite<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<StrictlyPositive<f32>> for NonNaN<f32>
impl Max<StrictlyPositive<f32>> for NonNaN<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<StrictlyPositive<f32>> for NonNaNFinite<f32>
impl Max<StrictlyPositive<f32>> for NonNaNFinite<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
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<f32>> for NonZeroNonNaNFinite<f32>
impl Max<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<StrictlyPositive<f32>> for Positive<f32>
impl Max<StrictlyPositive<f32>> for Positive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<StrictlyPositive<f32>> for PositiveFinite<f32>
impl Max<StrictlyPositive<f32>> for PositiveFinite<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<StrictlyPositive<f32>> for StrictlyNegative<f32>
impl Max<StrictlyPositive<f32>> for StrictlyNegative<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
impl Max<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<StrictlyPositive<f32>> for StrictlyPositive<f32>
impl Max<StrictlyPositive<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
impl Max<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<StrictlyPositive> for Negative<f64>
impl Max<StrictlyPositive> for Negative<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Max<StrictlyPositive> for NegativeFinite<f64>
impl Max<StrictlyPositive> for NegativeFinite<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Max<StrictlyPositive> for NonNaN<f64>
impl Max<StrictlyPositive> for NonNaN<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Max<StrictlyPositive> for NonNaNFinite<f64>
impl Max<StrictlyPositive> for NonNaNFinite<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
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<StrictlyPositive> for NonZeroNonNaNFinite<f64>
impl Max<StrictlyPositive> for NonZeroNonNaNFinite<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Max<StrictlyPositive> for Positive<f64>
impl Max<StrictlyPositive> for Positive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Max<StrictlyPositive> for PositiveFinite<f64>
impl Max<StrictlyPositive> for PositiveFinite<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Max<StrictlyPositive> for StrictlyNegative<f64>
impl Max<StrictlyPositive> for StrictlyNegative<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Max<StrictlyPositive> for StrictlyNegativeFinite<f64>
impl Max<StrictlyPositive> for StrictlyNegativeFinite<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Max<StrictlyPositive> for StrictlyPositive<f64>
impl Max<StrictlyPositive> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Max<StrictlyPositive> for StrictlyPositiveFinite<f64>
impl Max<StrictlyPositive> for StrictlyPositiveFinite<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Max<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
impl Max<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Max::max()
.source§impl Max<StrictlyPositiveFinite> for StrictlyPositive<f64>
impl Max<StrictlyPositiveFinite> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Max::max()
.source§impl Min<NegativeFinite<f32>> for StrictlyPositive<f32>
impl Min<NegativeFinite<f32>> for StrictlyPositive<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Min::min()
.source§impl Min<NegativeFinite> for StrictlyPositive<f64>
impl Min<NegativeFinite> for StrictlyPositive<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Min::min()
.source§impl Min<NonNaNFinite<f32>> for StrictlyPositive<f32>
impl Min<NonNaNFinite<f32>> for StrictlyPositive<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Min::min()
.source§impl Min<NonNaNFinite> for StrictlyPositive<f64>
impl Min<NonNaNFinite> for StrictlyPositive<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
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> for StrictlyPositive<f64>
impl Min<NonZeroNonNaN> for StrictlyPositive<f64>
source§type Output = NonZeroNonNaN
type Output = NonZeroNonNaN
Min::min()
.source§impl Min<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
impl Min<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
source§type Output = NonZeroNonNaNFinite<f32>
type Output = NonZeroNonNaNFinite<f32>
Min::min()
.source§impl Min<NonZeroNonNaNFinite> for StrictlyPositive<f64>
impl Min<NonZeroNonNaNFinite> for StrictlyPositive<f64>
source§type Output = NonZeroNonNaNFinite
type Output = NonZeroNonNaNFinite
Min::min()
.source§impl Min<PositiveFinite<f32>> for StrictlyPositive<f32>
impl Min<PositiveFinite<f32>> for StrictlyPositive<f32>
source§type Output = PositiveFinite<f32>
type Output = PositiveFinite<f32>
Min::min()
.source§impl Min<PositiveFinite> for StrictlyPositive<f64>
impl Min<PositiveFinite> for StrictlyPositive<f64>
source§type Output = PositiveFinite
type Output = PositiveFinite
Min::min()
.source§impl Min<StrictlyNegative<f32>> for StrictlyPositive<f32>
impl Min<StrictlyNegative<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyNegative<f32>
type Output = StrictlyNegative<f32>
Min::min()
.source§impl Min<StrictlyNegative> for StrictlyPositive<f64>
impl Min<StrictlyNegative> for StrictlyPositive<f64>
source§type Output = StrictlyNegative
type Output = StrictlyNegative
Min::min()
.source§impl Min<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
impl Min<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyNegativeFinite<f32>
type Output = StrictlyNegativeFinite<f32>
Min::min()
.source§impl Min<StrictlyNegativeFinite> for StrictlyPositive<f64>
impl Min<StrictlyNegativeFinite> for StrictlyPositive<f64>
source§type Output = StrictlyNegativeFinite
type Output = StrictlyNegativeFinite
Min::min()
.source§impl Min<StrictlyPositive<f32>> for NegativeFinite<f32>
impl Min<StrictlyPositive<f32>> for NegativeFinite<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
Min::min()
.source§impl Min<StrictlyPositive<f32>> for NonNaNFinite<f32>
impl Min<StrictlyPositive<f32>> for NonNaNFinite<f32>
source§type Output = NonNaNFinite<f32>
type Output = NonNaNFinite<f32>
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<f32>> for NonZeroNonNaNFinite<f32>
impl Min<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
source§type Output = NonZeroNonNaNFinite<f32>
type Output = NonZeroNonNaNFinite<f32>
Min::min()
.source§impl Min<StrictlyPositive<f32>> for PositiveFinite<f32>
impl Min<StrictlyPositive<f32>> for PositiveFinite<f32>
source§type Output = PositiveFinite<f32>
type Output = PositiveFinite<f32>
Min::min()
.source§impl Min<StrictlyPositive<f32>> for StrictlyNegative<f32>
impl Min<StrictlyPositive<f32>> for StrictlyNegative<f32>
source§type Output = StrictlyNegative<f32>
type Output = StrictlyNegative<f32>
Min::min()
.source§impl Min<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
impl Min<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
source§type Output = StrictlyNegativeFinite<f32>
type Output = StrictlyNegativeFinite<f32>
Min::min()
.source§impl Min<StrictlyPositive<f32>> for StrictlyPositive<f32>
impl Min<StrictlyPositive<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositive<f32>
type Output = StrictlyPositive<f32>
Min::min()
.source§impl Min<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
impl Min<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
source§type Output = StrictlyPositiveFinite<f32>
type Output = StrictlyPositiveFinite<f32>
Min::min()
.source§impl Min<StrictlyPositive> for NegativeFinite<f64>
impl Min<StrictlyPositive> for NegativeFinite<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
Min::min()
.source§impl Min<StrictlyPositive> for NonNaNFinite<f64>
impl Min<StrictlyPositive> for NonNaNFinite<f64>
source§type Output = NonNaNFinite
type Output = NonNaNFinite
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<StrictlyPositive> for NonZeroNonNaNFinite<f64>
impl Min<StrictlyPositive> for NonZeroNonNaNFinite<f64>
source§type Output = NonZeroNonNaNFinite
type Output = NonZeroNonNaNFinite
Min::min()
.source§impl Min<StrictlyPositive> for PositiveFinite<f64>
impl Min<StrictlyPositive> for PositiveFinite<f64>
source§type Output = PositiveFinite
type Output = PositiveFinite
Min::min()
.source§impl Min<StrictlyPositive> for StrictlyNegative<f64>
impl Min<StrictlyPositive> for StrictlyNegative<f64>
source§type Output = StrictlyNegative
type Output = StrictlyNegative
Min::min()
.source§impl Min<StrictlyPositive> for StrictlyNegativeFinite<f64>
impl Min<StrictlyPositive> for StrictlyNegativeFinite<f64>
source§type Output = StrictlyNegativeFinite
type Output = StrictlyNegativeFinite
Min::min()
.source§impl Min<StrictlyPositive> for StrictlyPositive<f64>
impl Min<StrictlyPositive> for StrictlyPositive<f64>
source§type Output = StrictlyPositive
type Output = StrictlyPositive
Min::min()
.source§impl Min<StrictlyPositive> for StrictlyPositiveFinite<f64>
impl Min<StrictlyPositive> for StrictlyPositiveFinite<f64>
source§type Output = StrictlyPositiveFinite
type Output = StrictlyPositiveFinite
Min::min()
.source§impl Min<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
impl Min<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
source§type Output = StrictlyPositiveFinite<f32>
type Output = StrictlyPositiveFinite<f32>
Min::min()
.source§impl Min<StrictlyPositiveFinite> for StrictlyPositive<f64>
impl Min<StrictlyPositiveFinite> for StrictlyPositive<f64>
source§type Output = StrictlyPositiveFinite
type Output = StrictlyPositiveFinite
Min::min()
.source§impl Mul<NegativeFinite<f32>> for StrictlyPositive<f32>
impl Mul<NegativeFinite<f32>> for StrictlyPositive<f32>
source§impl Mul<NegativeFinite> for StrictlyPositive<f64>
impl Mul<NegativeFinite> for StrictlyPositive<f64>
source§impl Mul<NonNaNFinite<f32>> for StrictlyPositive<f32>
impl Mul<NonNaNFinite<f32>> for StrictlyPositive<f32>
source§impl Mul<NonNaNFinite> for StrictlyPositive<f64>
impl Mul<NonNaNFinite> for StrictlyPositive<f64>
source§impl Mul<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl Mul<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§impl Mul<NonZeroNonNaN> for StrictlyPositive<f64>
impl Mul<NonZeroNonNaN> for StrictlyPositive<f64>
source§impl Mul<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
impl Mul<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
source§impl Mul<NonZeroNonNaNFinite> for StrictlyPositive<f64>
impl Mul<NonZeroNonNaNFinite> for StrictlyPositive<f64>
source§impl Mul<PositiveFinite<f32>> for StrictlyPositive<f32>
impl Mul<PositiveFinite<f32>> for StrictlyPositive<f32>
source§impl Mul<PositiveFinite> for StrictlyPositive<f64>
impl Mul<PositiveFinite> for StrictlyPositive<f64>
source§impl Mul<StrictlyNegative<f32>> for StrictlyPositive<f32>
impl Mul<StrictlyNegative<f32>> for StrictlyPositive<f32>
source§impl Mul<StrictlyNegative> for StrictlyPositive<f64>
impl Mul<StrictlyNegative> for StrictlyPositive<f64>
source§impl Mul<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
impl Mul<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
source§impl Mul<StrictlyNegativeFinite> for StrictlyPositive<f64>
impl Mul<StrictlyNegativeFinite> for StrictlyPositive<f64>
source§impl Mul<StrictlyPositive<f32>> for NegativeFinite<f32>
impl Mul<StrictlyPositive<f32>> for NegativeFinite<f32>
source§impl Mul<StrictlyPositive<f32>> for NonNaNFinite<f32>
impl Mul<StrictlyPositive<f32>> for NonNaNFinite<f32>
source§impl Mul<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl Mul<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§impl Mul<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
impl Mul<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
source§impl Mul<StrictlyPositive<f32>> for PositiveFinite<f32>
impl Mul<StrictlyPositive<f32>> for PositiveFinite<f32>
source§impl Mul<StrictlyPositive<f32>> for StrictlyNegative<f32>
impl Mul<StrictlyPositive<f32>> for StrictlyNegative<f32>
source§impl Mul<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
impl Mul<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
source§impl Mul<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
impl Mul<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
source§impl Mul<StrictlyPositive> for NegativeFinite<f64>
impl Mul<StrictlyPositive> for NegativeFinite<f64>
source§impl Mul<StrictlyPositive> for NonNaNFinite<f64>
impl Mul<StrictlyPositive> for NonNaNFinite<f64>
source§impl Mul<StrictlyPositive> for NonZeroNonNaN<f64>
impl Mul<StrictlyPositive> for NonZeroNonNaN<f64>
source§impl Mul<StrictlyPositive> for NonZeroNonNaNFinite<f64>
impl Mul<StrictlyPositive> for NonZeroNonNaNFinite<f64>
source§impl Mul<StrictlyPositive> for PositiveFinite<f64>
impl Mul<StrictlyPositive> for PositiveFinite<f64>
source§impl Mul<StrictlyPositive> for StrictlyNegative<f64>
impl Mul<StrictlyPositive> for StrictlyNegative<f64>
source§impl Mul<StrictlyPositive> for StrictlyNegativeFinite<f64>
impl Mul<StrictlyPositive> for StrictlyNegativeFinite<f64>
source§impl Mul<StrictlyPositive> for StrictlyPositiveFinite<f64>
impl Mul<StrictlyPositive> for StrictlyPositiveFinite<f64>
source§impl Mul<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
impl Mul<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
source§impl Mul<StrictlyPositiveFinite> for StrictlyPositive<f64>
impl Mul<StrictlyPositiveFinite> for StrictlyPositive<f64>
source§impl Mul for StrictlyPositive<f64>
impl Mul for StrictlyPositive<f64>
source§impl Mul for StrictlyPositive<f32>
impl Mul for StrictlyPositive<f32>
source§impl Neg for StrictlyPositive<f64>
impl Neg for StrictlyPositive<f64>
source§impl Neg for StrictlyPositive<f32>
impl Neg for StrictlyPositive<f32>
source§impl Ord for StrictlyPositive<f64>
impl Ord for StrictlyPositive<f64>
source§impl Ord for StrictlyPositive<f32>
impl Ord for StrictlyPositive<f32>
source§impl PartialEq<NegativeFinite<f32>> for StrictlyPositive<f32>
impl PartialEq<NegativeFinite<f32>> for StrictlyPositive<f32>
source§impl PartialEq<NegativeFinite> for StrictlyPositive<f64>
impl PartialEq<NegativeFinite> for StrictlyPositive<f64>
source§impl PartialEq<NonNaNFinite<f32>> for StrictlyPositive<f32>
impl PartialEq<NonNaNFinite<f32>> for StrictlyPositive<f32>
source§impl PartialEq<NonNaNFinite> for StrictlyPositive<f64>
impl PartialEq<NonNaNFinite> for StrictlyPositive<f64>
source§impl PartialEq<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl PartialEq<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§impl PartialEq<NonZeroNonNaN> for StrictlyPositive<f64>
impl PartialEq<NonZeroNonNaN> for StrictlyPositive<f64>
source§impl PartialEq<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
impl PartialEq<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
source§impl PartialEq<NonZeroNonNaNFinite> for StrictlyPositive<f64>
impl PartialEq<NonZeroNonNaNFinite> for StrictlyPositive<f64>
source§impl PartialEq<PositiveFinite<f32>> for StrictlyPositive<f32>
impl PartialEq<PositiveFinite<f32>> for StrictlyPositive<f32>
source§impl PartialEq<PositiveFinite> for StrictlyPositive<f64>
impl PartialEq<PositiveFinite> for StrictlyPositive<f64>
source§impl PartialEq<StrictlyNegative<f32>> for StrictlyPositive<f32>
impl PartialEq<StrictlyNegative<f32>> for StrictlyPositive<f32>
source§impl PartialEq<StrictlyNegative> for StrictlyPositive<f64>
impl PartialEq<StrictlyNegative> for StrictlyPositive<f64>
source§impl PartialEq<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
impl PartialEq<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
source§impl PartialEq<StrictlyPositive<f32>> for NegativeFinite<f32>
impl PartialEq<StrictlyPositive<f32>> for NegativeFinite<f32>
source§impl PartialEq<StrictlyPositive<f32>> for NonNaNFinite<f32>
impl PartialEq<StrictlyPositive<f32>> for NonNaNFinite<f32>
source§impl PartialEq<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl PartialEq<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§impl PartialEq<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
impl PartialEq<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
source§impl PartialEq<StrictlyPositive<f32>> for PositiveFinite<f32>
impl PartialEq<StrictlyPositive<f32>> for PositiveFinite<f32>
source§impl PartialEq<StrictlyPositive<f32>> for StrictlyNegative<f32>
impl PartialEq<StrictlyPositive<f32>> for StrictlyNegative<f32>
source§impl PartialEq<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
impl PartialEq<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
source§impl PartialEq<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
impl PartialEq<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
source§impl PartialEq<StrictlyPositive> for NegativeFinite<f64>
impl PartialEq<StrictlyPositive> for NegativeFinite<f64>
source§impl PartialEq<StrictlyPositive> for NonNaNFinite<f64>
impl PartialEq<StrictlyPositive> for NonNaNFinite<f64>
source§impl PartialEq<StrictlyPositive> for NonZeroNonNaN<f64>
impl PartialEq<StrictlyPositive> for NonZeroNonNaN<f64>
source§impl PartialEq<StrictlyPositive> for NonZeroNonNaNFinite<f64>
impl PartialEq<StrictlyPositive> for NonZeroNonNaNFinite<f64>
source§impl PartialEq<StrictlyPositive> for PositiveFinite<f64>
impl PartialEq<StrictlyPositive> for PositiveFinite<f64>
source§impl PartialEq<StrictlyPositive> for StrictlyNegative<f64>
impl PartialEq<StrictlyPositive> for StrictlyNegative<f64>
source§impl PartialEq<StrictlyPositive> for f64
impl PartialEq<StrictlyPositive> for f64
source§impl PartialEq<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
impl PartialEq<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
source§impl PartialEq for StrictlyPositive<f64>
impl PartialEq for StrictlyPositive<f64>
source§impl PartialEq for StrictlyPositive<f32>
impl PartialEq for StrictlyPositive<f32>
source§impl PartialOrd<Negative<f32>> for StrictlyPositive<f32>
impl PartialOrd<Negative<f32>> for StrictlyPositive<f32>
source§impl PartialOrd<Negative> for StrictlyPositive<f64>
impl PartialOrd<Negative> for StrictlyPositive<f64>
source§impl PartialOrd<NegativeFinite<f32>> for StrictlyPositive<f32>
impl PartialOrd<NegativeFinite<f32>> for StrictlyPositive<f32>
source§impl PartialOrd<NegativeFinite> for StrictlyPositive<f64>
impl PartialOrd<NegativeFinite> for StrictlyPositive<f64>
source§impl PartialOrd<NonNaN<f32>> for StrictlyPositive<f32>
impl PartialOrd<NonNaN<f32>> for StrictlyPositive<f32>
source§impl PartialOrd<NonNaN> for StrictlyPositive<f64>
impl PartialOrd<NonNaN> for StrictlyPositive<f64>
source§impl PartialOrd<NonNaNFinite<f32>> for StrictlyPositive<f32>
impl PartialOrd<NonNaNFinite<f32>> for StrictlyPositive<f32>
source§impl PartialOrd<NonNaNFinite> for StrictlyPositive<f64>
impl PartialOrd<NonNaNFinite> for StrictlyPositive<f64>
source§impl PartialOrd<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl PartialOrd<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§impl PartialOrd<NonZeroNonNaN> for StrictlyPositive<f64>
impl PartialOrd<NonZeroNonNaN> for StrictlyPositive<f64>
source§impl PartialOrd<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
impl PartialOrd<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
source§impl PartialOrd<NonZeroNonNaNFinite> for StrictlyPositive<f64>
impl PartialOrd<NonZeroNonNaNFinite> for StrictlyPositive<f64>
source§impl PartialOrd<Positive<f32>> for StrictlyPositive<f32>
impl PartialOrd<Positive<f32>> for StrictlyPositive<f32>
source§impl PartialOrd<Positive> for StrictlyPositive<f64>
impl PartialOrd<Positive> for StrictlyPositive<f64>
source§impl PartialOrd<PositiveFinite<f32>> for StrictlyPositive<f32>
impl PartialOrd<PositiveFinite<f32>> for StrictlyPositive<f32>
source§impl PartialOrd<PositiveFinite> for StrictlyPositive<f64>
impl PartialOrd<PositiveFinite> for StrictlyPositive<f64>
source§impl PartialOrd<StrictlyNegative<f32>> for StrictlyPositive<f32>
impl PartialOrd<StrictlyNegative<f32>> for StrictlyPositive<f32>
source§impl PartialOrd<StrictlyNegative> for StrictlyPositive<f64>
impl PartialOrd<StrictlyNegative> for StrictlyPositive<f64>
source§impl PartialOrd<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
impl PartialOrd<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
source§impl PartialOrd<StrictlyNegativeFinite> for StrictlyPositive<f64>
impl PartialOrd<StrictlyNegativeFinite> for StrictlyPositive<f64>
source§impl PartialOrd<StrictlyPositive<f32>> for Negative<f32>
impl PartialOrd<StrictlyPositive<f32>> for Negative<f32>
source§impl PartialOrd<StrictlyPositive<f32>> for NegativeFinite<f32>
impl PartialOrd<StrictlyPositive<f32>> for NegativeFinite<f32>
source§impl PartialOrd<StrictlyPositive<f32>> for NonNaN<f32>
impl PartialOrd<StrictlyPositive<f32>> for NonNaN<f32>
source§impl PartialOrd<StrictlyPositive<f32>> for NonNaNFinite<f32>
impl PartialOrd<StrictlyPositive<f32>> for NonNaNFinite<f32>
source§impl PartialOrd<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl PartialOrd<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§impl PartialOrd<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
impl PartialOrd<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
source§impl PartialOrd<StrictlyPositive<f32>> for Positive<f32>
impl PartialOrd<StrictlyPositive<f32>> for Positive<f32>
source§impl PartialOrd<StrictlyPositive<f32>> for PositiveFinite<f32>
impl PartialOrd<StrictlyPositive<f32>> for PositiveFinite<f32>
source§impl PartialOrd<StrictlyPositive<f32>> for StrictlyNegative<f32>
impl PartialOrd<StrictlyPositive<f32>> for StrictlyNegative<f32>
source§impl PartialOrd<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
impl PartialOrd<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
source§impl PartialOrd<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
impl PartialOrd<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
source§impl PartialOrd<StrictlyPositive<f32>> for f32
impl PartialOrd<StrictlyPositive<f32>> for f32
source§impl PartialOrd<StrictlyPositive> for Negative<f64>
impl PartialOrd<StrictlyPositive> for Negative<f64>
source§impl PartialOrd<StrictlyPositive> for NegativeFinite<f64>
impl PartialOrd<StrictlyPositive> for NegativeFinite<f64>
source§impl PartialOrd<StrictlyPositive> for NonNaN<f64>
impl PartialOrd<StrictlyPositive> for NonNaN<f64>
source§impl PartialOrd<StrictlyPositive> for NonNaNFinite<f64>
impl PartialOrd<StrictlyPositive> for NonNaNFinite<f64>
source§impl PartialOrd<StrictlyPositive> for NonZeroNonNaN<f64>
impl PartialOrd<StrictlyPositive> for NonZeroNonNaN<f64>
source§impl PartialOrd<StrictlyPositive> for NonZeroNonNaNFinite<f64>
impl PartialOrd<StrictlyPositive> for NonZeroNonNaNFinite<f64>
source§impl PartialOrd<StrictlyPositive> for Positive<f64>
impl PartialOrd<StrictlyPositive> for Positive<f64>
source§impl PartialOrd<StrictlyPositive> for PositiveFinite<f64>
impl PartialOrd<StrictlyPositive> for PositiveFinite<f64>
source§impl PartialOrd<StrictlyPositive> for StrictlyNegative<f64>
impl PartialOrd<StrictlyPositive> for StrictlyNegative<f64>
source§impl PartialOrd<StrictlyPositive> for StrictlyNegativeFinite<f64>
impl PartialOrd<StrictlyPositive> for StrictlyNegativeFinite<f64>
source§impl PartialOrd<StrictlyPositive> for StrictlyPositiveFinite<f64>
impl PartialOrd<StrictlyPositive> for StrictlyPositiveFinite<f64>
source§impl PartialOrd<StrictlyPositive> for f64
impl PartialOrd<StrictlyPositive> for f64
source§impl PartialOrd<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
impl PartialOrd<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
source§impl PartialOrd<StrictlyPositiveFinite> for StrictlyPositive<f64>
impl PartialOrd<StrictlyPositiveFinite> for StrictlyPositive<f64>
source§impl PartialOrd<f32> for StrictlyPositive<f32>
impl PartialOrd<f32> for StrictlyPositive<f32>
source§impl PartialOrd<f64> for StrictlyPositive<f64>
impl PartialOrd<f64> for StrictlyPositive<f64>
source§impl PartialOrd for StrictlyPositive<f64>
impl PartialOrd for StrictlyPositive<f64>
source§impl PartialOrd for StrictlyPositive<f32>
impl PartialOrd for StrictlyPositive<f32>
source§impl Powf<NegativeFinite<f32>> for StrictlyPositive<f32>
impl Powf<NegativeFinite<f32>> for StrictlyPositive<f32>
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 StrictlyPositive<f64>
impl Powf<NegativeFinite> for StrictlyPositive<f64>
source§type Output = Positive
type Output = Positive
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 StrictlyPositive<f32>
impl Powf<NonNaNFinite<f32>> for StrictlyPositive<f32>
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 StrictlyPositive<f64>
impl Powf<NonNaNFinite> for StrictlyPositive<f64>
source§type Output = Positive
type Output = Positive
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 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> 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<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
impl Powf<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
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 StrictlyPositive<f64>
impl Powf<NonZeroNonNaNFinite> for StrictlyPositive<f64>
source§type Output = Positive
type Output = Positive
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 StrictlyPositive<f32>
impl Powf<PositiveFinite<f32>> for StrictlyPositive<f32>
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 StrictlyPositive<f64>
impl Powf<PositiveFinite> for StrictlyPositive<f64>
source§type Output = Positive
type Output = Positive
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 StrictlyPositive<f32>
impl Powf<StrictlyNegative<f32>> for StrictlyPositive<f32>
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 StrictlyPositive<f64>
impl Powf<StrictlyNegative> for StrictlyPositive<f64>
source§type Output = Positive
type Output = Positive
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 StrictlyPositive<f32>
impl Powf<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
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 StrictlyPositive<f64>
impl Powf<StrictlyNegativeFinite> for StrictlyPositive<f64>
source§type Output = Positive
type Output = Positive
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 Negative<f32>
impl Powf<StrictlyPositive<f32>> for Negative<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<f32>> for NegativeFinite<f32>
impl Powf<StrictlyPositive<f32>> for NegativeFinite<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<f32>> for NonNaN<f32>
impl Powf<StrictlyPositive<f32>> for NonNaN<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<f32>> for NonNaNFinite<f32>
impl Powf<StrictlyPositive<f32>> for NonNaNFinite<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<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<f32>> for NonZeroNonNaNFinite<f32>
impl Powf<StrictlyPositive<f32>> for NonZeroNonNaNFinite<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<f32>> for Positive<f32>
impl Powf<StrictlyPositive<f32>> for Positive<f32>
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<f32>> for PositiveFinite<f32>
impl Powf<StrictlyPositive<f32>> for PositiveFinite<f32>
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<f32>> for StrictlyNegative<f32>
impl Powf<StrictlyPositive<f32>> for StrictlyNegative<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<f32>> for StrictlyNegativeFinite<f32>
impl Powf<StrictlyPositive<f32>> for StrictlyNegativeFinite<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<f32>> for StrictlyPositive<f32>
impl Powf<StrictlyPositive<f32>> for StrictlyPositive<f32>
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<f32>> for StrictlyPositiveFinite<f32>
impl Powf<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
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 Negative<f64>
impl Powf<StrictlyPositive> for Negative<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<StrictlyPositive> for NegativeFinite<f64>
impl Powf<StrictlyPositive> for NegativeFinite<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<StrictlyPositive> for NonNaN<f64>
impl Powf<StrictlyPositive> for NonNaN<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<StrictlyPositive> for NonNaNFinite<f64>
impl Powf<StrictlyPositive> for NonNaNFinite<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<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<StrictlyPositive> for NonZeroNonNaNFinite<f64>
impl Powf<StrictlyPositive> for NonZeroNonNaNFinite<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<StrictlyPositive> for Positive<f64>
impl Powf<StrictlyPositive> for Positive<f64>
source§type Output = Positive
type Output = Positive
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<StrictlyPositive> for PositiveFinite<f64>
impl Powf<StrictlyPositive> for PositiveFinite<f64>
source§type Output = Positive
type Output = Positive
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<StrictlyPositive> for StrictlyNegative<f64>
impl Powf<StrictlyPositive> for StrictlyNegative<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<StrictlyPositive> for StrictlyNegativeFinite<f64>
impl Powf<StrictlyPositive> for StrictlyNegativeFinite<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<StrictlyPositive> for StrictlyPositive<f64>
impl Powf<StrictlyPositive> for StrictlyPositive<f64>
source§type Output = Positive
type Output = Positive
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<StrictlyPositive> for StrictlyPositiveFinite<f64>
impl Powf<StrictlyPositive> for StrictlyPositiveFinite<f64>
source§type Output = Positive
type Output = Positive
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 StrictlyPositive<f32>
impl Powf<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
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 StrictlyPositive<f64>
impl Powf<StrictlyPositiveFinite> for StrictlyPositive<f64>
source§type Output = Positive
type Output = Positive
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 StrictlyPositive<f32>
impl Rem<NegativeFinite<f32>> for StrictlyPositive<f32>
source§impl Rem<NegativeFinite> for StrictlyPositive<f64>
impl Rem<NegativeFinite> for StrictlyPositive<f64>
source§impl Rem<NonNaNFinite<f32>> for StrictlyPositive<f32>
impl Rem<NonNaNFinite<f32>> for StrictlyPositive<f32>
source§impl Rem<NonNaNFinite> for StrictlyPositive<f64>
impl Rem<NonNaNFinite> for StrictlyPositive<f64>
source§impl Rem<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl Rem<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§impl Rem<NonZeroNonNaN> for StrictlyPositive<f64>
impl Rem<NonZeroNonNaN> for StrictlyPositive<f64>
source§impl Rem<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
impl Rem<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
source§impl Rem<NonZeroNonNaNFinite> for StrictlyPositive<f64>
impl Rem<NonZeroNonNaNFinite> for StrictlyPositive<f64>
source§impl Rem<PositiveFinite<f32>> for StrictlyPositive<f32>
impl Rem<PositiveFinite<f32>> for StrictlyPositive<f32>
source§impl Rem<PositiveFinite> for StrictlyPositive<f64>
impl Rem<PositiveFinite> for StrictlyPositive<f64>
source§impl Rem<StrictlyNegative<f32>> for StrictlyPositive<f32>
impl Rem<StrictlyNegative<f32>> for StrictlyPositive<f32>
source§impl Rem<StrictlyNegative> for StrictlyPositive<f64>
impl Rem<StrictlyNegative> for StrictlyPositive<f64>
source§impl Rem<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
impl Rem<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
source§impl Rem<StrictlyNegativeFinite> for StrictlyPositive<f64>
impl Rem<StrictlyNegativeFinite> for StrictlyPositive<f64>
source§impl Rem<StrictlyPositive<f32>> for NegativeFinite<f32>
impl Rem<StrictlyPositive<f32>> for NegativeFinite<f32>
source§impl Rem<StrictlyPositive<f32>> for NonNaNFinite<f32>
impl Rem<StrictlyPositive<f32>> for NonNaNFinite<f32>
source§impl Rem<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl Rem<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§impl Rem<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
impl Rem<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
source§impl Rem<StrictlyPositive<f32>> for PositiveFinite<f32>
impl Rem<StrictlyPositive<f32>> for PositiveFinite<f32>
source§impl Rem<StrictlyPositive<f32>> for StrictlyNegative<f32>
impl Rem<StrictlyPositive<f32>> for StrictlyNegative<f32>
source§impl Rem<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
impl Rem<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
source§impl Rem<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
impl Rem<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
source§impl Rem<StrictlyPositive> for NegativeFinite<f64>
impl Rem<StrictlyPositive> for NegativeFinite<f64>
source§impl Rem<StrictlyPositive> for NonNaNFinite<f64>
impl Rem<StrictlyPositive> for NonNaNFinite<f64>
source§impl Rem<StrictlyPositive> for NonZeroNonNaN<f64>
impl Rem<StrictlyPositive> for NonZeroNonNaN<f64>
source§impl Rem<StrictlyPositive> for NonZeroNonNaNFinite<f64>
impl Rem<StrictlyPositive> for NonZeroNonNaNFinite<f64>
source§impl Rem<StrictlyPositive> for PositiveFinite<f64>
impl Rem<StrictlyPositive> for PositiveFinite<f64>
source§impl Rem<StrictlyPositive> for StrictlyNegative<f64>
impl Rem<StrictlyPositive> for StrictlyNegative<f64>
source§impl Rem<StrictlyPositive> for StrictlyNegativeFinite<f64>
impl Rem<StrictlyPositive> for StrictlyNegativeFinite<f64>
source§impl Rem<StrictlyPositive> for StrictlyPositiveFinite<f64>
impl Rem<StrictlyPositive> for StrictlyPositiveFinite<f64>
source§impl Rem<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
impl Rem<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
source§impl Rem<StrictlyPositiveFinite> for StrictlyPositive<f64>
impl Rem<StrictlyPositiveFinite> for StrictlyPositive<f64>
source§impl Rem for StrictlyPositive<f64>
impl Rem for StrictlyPositive<f64>
source§impl Rem for StrictlyPositive<f32>
impl Rem for StrictlyPositive<f32>
source§impl RemAssign<StrictlyPositive<f32>> for NegativeFinite<f32>
impl RemAssign<StrictlyPositive<f32>> for NegativeFinite<f32>
source§fn rem_assign(&mut self, rhs: StrictlyPositive<f32>)
fn rem_assign(&mut self, rhs: StrictlyPositive<f32>)
%=
operation. Read moresource§impl RemAssign<StrictlyPositive<f32>> for NonNaNFinite<f32>
impl RemAssign<StrictlyPositive<f32>> for NonNaNFinite<f32>
source§fn rem_assign(&mut self, rhs: StrictlyPositive<f32>)
fn rem_assign(&mut self, rhs: StrictlyPositive<f32>)
%=
operation. Read moresource§impl RemAssign<StrictlyPositive<f32>> for PositiveFinite<f32>
impl RemAssign<StrictlyPositive<f32>> for PositiveFinite<f32>
source§fn rem_assign(&mut self, rhs: StrictlyPositive<f32>)
fn rem_assign(&mut self, rhs: StrictlyPositive<f32>)
%=
operation. Read moresource§impl RemAssign<StrictlyPositive> for NegativeFinite<f64>
impl RemAssign<StrictlyPositive> for NegativeFinite<f64>
source§fn rem_assign(&mut self, rhs: StrictlyPositive<f64>)
fn rem_assign(&mut self, rhs: StrictlyPositive<f64>)
%=
operation. Read moresource§impl RemAssign<StrictlyPositive> for NonNaNFinite<f64>
impl RemAssign<StrictlyPositive> for NonNaNFinite<f64>
source§fn rem_assign(&mut self, rhs: StrictlyPositive<f64>)
fn rem_assign(&mut self, rhs: StrictlyPositive<f64>)
%=
operation. Read moresource§impl RemAssign<StrictlyPositive> for PositiveFinite<f64>
impl RemAssign<StrictlyPositive> for PositiveFinite<f64>
source§fn rem_assign(&mut self, rhs: StrictlyPositive<f64>)
fn rem_assign(&mut self, rhs: StrictlyPositive<f64>)
%=
operation. Read moresource§impl<T> Serialize for StrictlyPositive<T>where
T: Serialize,
impl<T> Serialize for StrictlyPositive<T>where
T: Serialize,
source§impl Sub<NegativeFinite<f32>> for StrictlyPositive<f32>
impl Sub<NegativeFinite<f32>> for StrictlyPositive<f32>
source§impl Sub<NegativeFinite> for StrictlyPositive<f64>
impl Sub<NegativeFinite> for StrictlyPositive<f64>
source§impl Sub<NonNaNFinite<f32>> for StrictlyPositive<f32>
impl Sub<NonNaNFinite<f32>> for StrictlyPositive<f32>
source§impl Sub<NonNaNFinite> for StrictlyPositive<f64>
impl Sub<NonNaNFinite> for StrictlyPositive<f64>
source§impl Sub<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl Sub<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§impl Sub<NonZeroNonNaN> for StrictlyPositive<f64>
impl Sub<NonZeroNonNaN> for StrictlyPositive<f64>
source§impl Sub<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
impl Sub<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
source§impl Sub<NonZeroNonNaNFinite> for StrictlyPositive<f64>
impl Sub<NonZeroNonNaNFinite> for StrictlyPositive<f64>
source§impl Sub<PositiveFinite<f32>> for StrictlyPositive<f32>
impl Sub<PositiveFinite<f32>> for StrictlyPositive<f32>
source§impl Sub<PositiveFinite> for StrictlyPositive<f64>
impl Sub<PositiveFinite> for StrictlyPositive<f64>
source§impl Sub<StrictlyNegative<f32>> for StrictlyPositive<f32>
impl Sub<StrictlyNegative<f32>> for StrictlyPositive<f32>
source§impl Sub<StrictlyNegative> for StrictlyPositive<f64>
impl Sub<StrictlyNegative> for StrictlyPositive<f64>
source§impl Sub<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
impl Sub<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
source§impl Sub<StrictlyNegativeFinite> for StrictlyPositive<f64>
impl Sub<StrictlyNegativeFinite> for StrictlyPositive<f64>
source§impl Sub<StrictlyPositive<f32>> for NegativeFinite<f32>
impl Sub<StrictlyPositive<f32>> for NegativeFinite<f32>
source§impl Sub<StrictlyPositive<f32>> for NonNaNFinite<f32>
impl Sub<StrictlyPositive<f32>> for NonNaNFinite<f32>
source§impl Sub<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
impl Sub<StrictlyPositive<f32>> for NonZeroNonNaN<f32>
source§impl Sub<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
impl Sub<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
source§impl Sub<StrictlyPositive<f32>> for PositiveFinite<f32>
impl Sub<StrictlyPositive<f32>> for PositiveFinite<f32>
source§impl Sub<StrictlyPositive<f32>> for StrictlyNegative<f32>
impl Sub<StrictlyPositive<f32>> for StrictlyNegative<f32>
source§impl Sub<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
impl Sub<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
source§impl Sub<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
impl Sub<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
source§impl Sub<StrictlyPositive> for NegativeFinite<f64>
impl Sub<StrictlyPositive> for NegativeFinite<f64>
source§impl Sub<StrictlyPositive> for NonNaNFinite<f64>
impl Sub<StrictlyPositive> for NonNaNFinite<f64>
source§impl Sub<StrictlyPositive> for NonZeroNonNaN<f64>
impl Sub<StrictlyPositive> for NonZeroNonNaN<f64>
source§impl Sub<StrictlyPositive> for NonZeroNonNaNFinite<f64>
impl Sub<StrictlyPositive> for NonZeroNonNaNFinite<f64>
source§impl Sub<StrictlyPositive> for PositiveFinite<f64>
impl Sub<StrictlyPositive> for PositiveFinite<f64>
source§impl Sub<StrictlyPositive> for StrictlyNegative<f64>
impl Sub<StrictlyPositive> for StrictlyNegative<f64>
source§impl Sub<StrictlyPositive> for StrictlyNegativeFinite<f64>
impl Sub<StrictlyPositive> for StrictlyNegativeFinite<f64>
source§impl Sub<StrictlyPositive> for StrictlyPositiveFinite<f64>
impl Sub<StrictlyPositive> for StrictlyPositiveFinite<f64>
source§impl Sub<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
impl Sub<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>
source§impl Sub<StrictlyPositiveFinite> for StrictlyPositive<f64>
impl Sub<StrictlyPositiveFinite> for StrictlyPositive<f64>
source§impl Sub for StrictlyPositive<f64>
impl Sub for StrictlyPositive<f64>
source§impl Sub for StrictlyPositive<f32>
impl Sub for StrictlyPositive<f32>
source§impl SubAssign<NegativeFinite<f32>> for StrictlyPositive<f32>
impl SubAssign<NegativeFinite<f32>> for StrictlyPositive<f32>
source§fn sub_assign(&mut self, rhs: NegativeFinite<f32>)
fn sub_assign(&mut self, rhs: NegativeFinite<f32>)
-=
operation. Read moresource§impl SubAssign<NegativeFinite> for StrictlyPositive<f64>
impl SubAssign<NegativeFinite> for StrictlyPositive<f64>
source§fn sub_assign(&mut self, rhs: NegativeFinite<f64>)
fn sub_assign(&mut self, rhs: NegativeFinite<f64>)
-=
operation. Read moresource§impl SubAssign<StrictlyNegative<f32>> for StrictlyPositive<f32>
impl SubAssign<StrictlyNegative<f32>> for StrictlyPositive<f32>
source§fn sub_assign(&mut self, rhs: StrictlyNegative<f32>)
fn sub_assign(&mut self, rhs: StrictlyNegative<f32>)
-=
operation. Read moresource§impl SubAssign<StrictlyNegative> for StrictlyPositive<f64>
impl SubAssign<StrictlyNegative> for StrictlyPositive<f64>
source§fn sub_assign(&mut self, rhs: StrictlyNegative<f64>)
fn sub_assign(&mut self, rhs: StrictlyNegative<f64>)
-=
operation. Read moresource§impl SubAssign<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
impl SubAssign<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
source§fn sub_assign(&mut self, rhs: StrictlyNegativeFinite<f32>)
fn sub_assign(&mut self, rhs: StrictlyNegativeFinite<f32>)
-=
operation. Read moresource§impl SubAssign<StrictlyNegativeFinite> for StrictlyPositive<f64>
impl SubAssign<StrictlyNegativeFinite> for StrictlyPositive<f64>
source§fn sub_assign(&mut self, rhs: StrictlyNegativeFinite<f64>)
fn sub_assign(&mut self, rhs: StrictlyNegativeFinite<f64>)
-=
operation. Read moresource§impl SubAssign<StrictlyPositive<f32>> for Negative<f32>
impl SubAssign<StrictlyPositive<f32>> for Negative<f32>
source§fn sub_assign(&mut self, rhs: StrictlyPositive<f32>)
fn sub_assign(&mut self, rhs: StrictlyPositive<f32>)
-=
operation. Read moresource§impl SubAssign<StrictlyPositive<f32>> for StrictlyNegative<f32>
impl SubAssign<StrictlyPositive<f32>> for StrictlyNegative<f32>
source§fn sub_assign(&mut self, rhs: StrictlyPositive<f32>)
fn sub_assign(&mut self, rhs: StrictlyPositive<f32>)
-=
operation. Read moresource§impl SubAssign<StrictlyPositive> for Negative<f64>
impl SubAssign<StrictlyPositive> for Negative<f64>
source§fn sub_assign(&mut self, rhs: StrictlyPositive<f64>)
fn sub_assign(&mut self, rhs: StrictlyPositive<f64>)
-=
operation. Read moresource§impl SubAssign<StrictlyPositive> for StrictlyNegative<f64>
impl SubAssign<StrictlyPositive> for StrictlyNegative<f64>
source§fn sub_assign(&mut self, rhs: StrictlyPositive<f64>)
fn sub_assign(&mut self, rhs: StrictlyPositive<f64>)
-=
operation. Read moresource§impl TryFrom<NegativeFinite<f32>> for StrictlyPositive<f32>
impl TryFrom<NegativeFinite<f32>> for StrictlyPositive<f32>
source§impl TryFrom<NegativeFinite> for StrictlyPositive<f64>
impl TryFrom<NegativeFinite> for StrictlyPositive<f64>
source§impl TryFrom<NonNaNFinite<f32>> for StrictlyPositive<f32>
impl TryFrom<NonNaNFinite<f32>> for StrictlyPositive<f32>
source§impl TryFrom<NonNaNFinite> for StrictlyPositive<f64>
impl TryFrom<NonNaNFinite> for StrictlyPositive<f64>
source§impl TryFrom<NonZero<i16>> for StrictlyPositive<f64>
impl TryFrom<NonZero<i16>> for StrictlyPositive<f64>
source§type Error = InvalidNumber
type Error = InvalidNumber
source§impl TryFrom<NonZero<i16>> for StrictlyPositive<f32>
impl TryFrom<NonZero<i16>> for StrictlyPositive<f32>
source§type Error = InvalidNumber
type Error = InvalidNumber
source§impl TryFrom<NonZero<i32>> for StrictlyPositive<f64>
impl TryFrom<NonZero<i32>> for StrictlyPositive<f64>
source§type Error = InvalidNumber
type Error = InvalidNumber
source§impl TryFrom<NonZero<i32>> for StrictlyPositive<f32>
impl TryFrom<NonZero<i32>> for StrictlyPositive<f32>
source§type Error = InvalidNumber
type Error = InvalidNumber
source§impl TryFrom<NonZero<i64>> for StrictlyPositive<f64>
impl TryFrom<NonZero<i64>> for StrictlyPositive<f64>
source§type Error = InvalidNumber
type Error = InvalidNumber
source§impl TryFrom<NonZero<i64>> for StrictlyPositive<f32>
impl TryFrom<NonZero<i64>> for StrictlyPositive<f32>
source§type Error = InvalidNumber
type Error = InvalidNumber
source§impl TryFrom<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
impl TryFrom<NonZeroNonNaN<f32>> for StrictlyPositive<f32>
source§impl TryFrom<NonZeroNonNaN> for StrictlyPositive<f64>
impl TryFrom<NonZeroNonNaN> for StrictlyPositive<f64>
source§impl TryFrom<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
impl TryFrom<NonZeroNonNaNFinite<f32>> for StrictlyPositive<f32>
source§impl TryFrom<NonZeroNonNaNFinite> for StrictlyPositive<f64>
impl TryFrom<NonZeroNonNaNFinite> for StrictlyPositive<f64>
source§impl TryFrom<PositiveFinite<f32>> for StrictlyPositive<f32>
impl TryFrom<PositiveFinite<f32>> for StrictlyPositive<f32>
source§impl TryFrom<PositiveFinite> for StrictlyPositive<f64>
impl TryFrom<PositiveFinite> for StrictlyPositive<f64>
source§impl TryFrom<StrictlyNegative<f32>> for StrictlyPositive<f32>
impl TryFrom<StrictlyNegative<f32>> for StrictlyPositive<f32>
source§impl TryFrom<StrictlyNegative> for StrictlyPositive<f64>
impl TryFrom<StrictlyNegative> for StrictlyPositive<f64>
source§impl TryFrom<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
impl TryFrom<StrictlyNegativeFinite<f32>> for StrictlyPositive<f32>
source§impl TryFrom<StrictlyNegativeFinite> for StrictlyPositive<f64>
impl TryFrom<StrictlyNegativeFinite> for StrictlyPositive<f64>
source§impl TryFrom<StrictlyPositive<f32>> for NegativeFinite<f32>
impl TryFrom<StrictlyPositive<f32>> for NegativeFinite<f32>
source§impl TryFrom<StrictlyPositive<f32>> for NonNaNFinite<f32>
impl TryFrom<StrictlyPositive<f32>> for NonNaNFinite<f32>
source§impl TryFrom<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
impl TryFrom<StrictlyPositive<f32>> for NonZeroNonNaNFinite<f32>
source§impl TryFrom<StrictlyPositive<f32>> for PositiveFinite<f32>
impl TryFrom<StrictlyPositive<f32>> for PositiveFinite<f32>
source§impl TryFrom<StrictlyPositive<f32>> for StrictlyNegative<f32>
impl TryFrom<StrictlyPositive<f32>> for StrictlyNegative<f32>
source§impl TryFrom<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
impl TryFrom<StrictlyPositive<f32>> for StrictlyNegativeFinite<f32>
source§impl TryFrom<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
impl TryFrom<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>
source§impl TryFrom<StrictlyPositive> for NegativeFinite<f64>
impl TryFrom<StrictlyPositive> for NegativeFinite<f64>
source§impl TryFrom<StrictlyPositive> for NonNaNFinite<f64>
impl TryFrom<StrictlyPositive> for NonNaNFinite<f64>
source§impl TryFrom<StrictlyPositive> for NonZeroNonNaNFinite<f64>
impl TryFrom<StrictlyPositive> for NonZeroNonNaNFinite<f64>
source§impl TryFrom<StrictlyPositive> for PositiveFinite<f64>
impl TryFrom<StrictlyPositive> for PositiveFinite<f64>
source§impl TryFrom<StrictlyPositive> for StrictlyNegative<f64>
impl TryFrom<StrictlyPositive> for StrictlyNegative<f64>
source§impl TryFrom<StrictlyPositive> for StrictlyNegativeFinite<f64>
impl TryFrom<StrictlyPositive> for StrictlyNegativeFinite<f64>
source§impl TryFrom<StrictlyPositive> for StrictlyPositiveFinite<f64>
impl TryFrom<StrictlyPositive> for StrictlyPositiveFinite<f64>
impl<T: Copy> Copy for StrictlyPositive<T>
impl Eq for StrictlyPositive<f64>
impl Eq for StrictlyPositive<f32>
Auto Trait Implementations§
impl<T> Freeze for StrictlyPositive<T>where
T: Freeze,
impl<T> RefUnwindSafe for StrictlyPositive<T>where
T: RefUnwindSafe,
impl<T> Send for StrictlyPositive<T>where
T: Send,
impl<T> Sync for StrictlyPositive<T>where
T: Sync,
impl<T> Unpin for StrictlyPositive<T>where
T: Unpin,
impl<T> UnwindSafe for StrictlyPositive<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
)