Struct typed_floats::StrictlyPositiveFinite

pub struct StrictlyPositiveFinite<T = f64>(/* private fields */);

A non-NaN strictly positive finite floating point number

It satisfies the following constraints:

• It is not NaN.
• It is not negative.

Implementations

impl StrictlyPositiveFinite

pub const fn accept_infinity() -> bool

Returns true if the type can accept infinity

pub const fn accept_zero() -> bool

Returns true if the type can accept zero

pub const fn accept_negative() -> bool

Returns true if the type can accept negative values

pub const fn accept_positive() -> bool

Returns true if the type can accept positive values

impl StrictlyPositiveFinite<f32>

pub fn new(value: f32) -> Result<Self, InvalidNumber>

Creates a new value from a primitive type It adds a little overhead compared to new_unchecked because it checks that the value is valid

Examples

let x = StrictlyPositiveFinite::new(3.0).unwrap();

assert_eq!(x, 3.0);

Errors

Returns an error if the value is not valid

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 { StrictlyPositiveFinite::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

pub const fn get(&self) -> f32

Returns the value as a primitive type

Examples

use typed_floats::tf32::StrictlyPositiveFinite;

let x = StrictlyPositiveFinite::new(3.0).unwrap();

let y: f32 = x.into();

assert_eq!(y, 3.0);

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::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.is_nan(), false);

See f32::is_nan() for more details.

pub const fn is_infinite(&self) -> bool

Returns true if this value is positive infinity or negative infinity.

Examples

use typed_floats::tf32::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.is_infinite(), false);

See f32::is_infinite() for more details.

pub const fn is_finite(&self) -> bool

Returns true if this number is positive infinity nor negative infinity.

Examples

use typed_floats::tf32::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.is_finite(), true);

See f32::is_finite() for more details.

pub fn is_subnormal(&self) -> bool

Returns true if the number is subnormal.

Examples

use typed_floats::tf32::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.is_subnormal(), false);

See f32::is_subnormal() for more details.

pub fn is_normal(&self) -> bool

Returns true if the number is neither zero, infinite or subnormal.

Examples

use typed_floats::tf32::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.is_normal(), true);

See f32::is_normal() for more details.

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::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.classify(), core::num::FpCategory::Normal);

See f32::classify() for more details.

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::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.is_sign_positive(), true);

See f32::is_sign_positive() for more details.

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::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.is_sign_negative(), false);

See f32::is_sign_negative() for more details.

pub const fn is_negative_zero(&self) -> bool

Returns true if the number is negative zero.

Examples

use typed_floats::tf32::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.is_negative_zero(), false);

pub const fn is_positive_zero(&self) -> bool

Returns true if the number is positive zero.

Examples

use typed_floats::tf32::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.is_positive_zero(), false);

impl StrictlyPositiveFinite<f64>

pub fn new(value: f64) -> Result<Self, InvalidNumber>

Creates a new value from a primitive type It adds a little overhead compared to new_unchecked because it checks that the value is valid

Examples

let x = StrictlyPositiveFinite::new(3.0).unwrap();

assert_eq!(x, 3.0);

Errors

Returns an error if the value is not valid

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 { StrictlyPositiveFinite::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

pub const fn get(&self) -> f64

Returns the value as a primitive type

Examples

use typed_floats::tf64::StrictlyPositiveFinite;

let x = StrictlyPositiveFinite::new(3.0).unwrap();

let y: f64 = x.into();

assert_eq!(y, 3.0);

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::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.is_nan(), false);

See f64::is_nan() for more details.

pub const fn is_infinite(&self) -> bool

Returns true if this value is positive infinity or negative infinity.

Examples

use typed_floats::tf64::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.is_infinite(), false);

See f64::is_infinite() for more details.

pub const fn is_finite(&self) -> bool

Returns true if this number is positive infinity nor negative infinity.

Examples

use typed_floats::tf64::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.is_finite(), true);

See f64::is_finite() for more details.

pub fn is_subnormal(&self) -> bool

Returns true if the number is subnormal.

Examples

use typed_floats::tf64::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.is_subnormal(), false);

See f64::is_subnormal() for more details.

pub fn is_normal(&self) -> bool

Returns true if the number is neither zero, infinite or subnormal.

Examples

use typed_floats::tf64::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.is_normal(), true);

See f64::is_normal() for more details.

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::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.classify(), core::num::FpCategory::Normal);

See f64::classify() for more details.

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::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.is_sign_positive(), true);

See f64::is_sign_positive() for more details.

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::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.is_sign_negative(), false);

See f64::is_sign_negative() for more details.

pub const fn is_negative_zero(&self) -> bool

Returns true if the number is negative zero.

Examples

use typed_floats::tf64::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.is_negative_zero(), false);

pub const fn is_positive_zero(&self) -> bool

Returns true if the number is positive zero.

Examples

use typed_floats::tf64::StrictlyPositiveFinite;
let x: StrictlyPositiveFinite = 3.0.try_into().unwrap();

assert_eq!(x.is_positive_zero(), false);

impl StrictlyPositiveFinite<f64>

pub fn abs(self) -> StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<f64>

pub fn ceil(self) -> StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<f64>

pub fn floor(self) -> PositiveFinite<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.

impl StrictlyPositiveFinite<f64>

pub fn round(self) -> PositiveFinite<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.

impl StrictlyPositiveFinite<f64>

pub fn trunc(self) -> PositiveFinite<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.

impl StrictlyPositiveFinite<f64>

pub fn fract(self) -> PositiveFinite<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.

impl 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 or INFINITY
• -1.0 if the number is negative, -0.0 or NEG_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.

impl StrictlyPositiveFinite<f64>

pub fn sqrt(self) -> StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<f64>

pub fn ln(self) -> NonNaNFinite<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.

impl StrictlyPositiveFinite<f64>

pub fn log2(self) -> NonNaNFinite<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.

impl StrictlyPositiveFinite<f64>

pub fn log10(self) -> NonNaNFinite<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.

impl StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<f64>

pub fn to_radians(self) -> StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<f64>

pub fn cbrt(self) -> StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<f64>

pub fn sin(self) -> NonNaNFinite<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.

impl StrictlyPositiveFinite<f64>

pub fn cos(self) -> NonNaNFinite<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.

impl StrictlyPositiveFinite<f64>

pub fn tan(self) -> NonNaN<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.

impl StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<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.

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

impl StrictlyPositiveFinite<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(), core::f64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.exp_m1(), -1.0);

See f64::exp_m1() for more details.

impl StrictlyPositiveFinite<f64>

pub fn ln_1p(self) -> StrictlyPositiveFinite<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(), core::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(), core::f64::INFINITY);
assert_is_nan!(tf64::NEG_INFINITY.ln_1p());

See f64::ln_1p() for more details.

impl StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<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.

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

impl StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<f64>

pub fn recip(self) -> StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<f32>

pub fn abs(self) -> StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<f32>

pub fn ceil(self) -> StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<f32>

pub fn floor(self) -> PositiveFinite<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.

impl StrictlyPositiveFinite<f32>

pub fn round(self) -> PositiveFinite<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.

impl StrictlyPositiveFinite<f32>

pub fn trunc(self) -> PositiveFinite<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.

impl StrictlyPositiveFinite<f32>

pub fn fract(self) -> PositiveFinite<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.

impl 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 or INFINITY
• -1.0 if the number is negative, -0.0 or NEG_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.

impl StrictlyPositiveFinite<f32>

pub fn sqrt(self) -> StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<f32>

pub fn ln(self) -> NonNaNFinite<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.

impl StrictlyPositiveFinite<f32>

pub fn log2(self) -> NonNaNFinite<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.

impl StrictlyPositiveFinite<f32>

pub fn log10(self) -> NonNaNFinite<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.

impl StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<f32>

pub fn to_radians(self) -> StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<f32>

pub fn cbrt(self) -> StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<f32>

pub fn sin(self) -> NonNaNFinite<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.

impl StrictlyPositiveFinite<f32>

pub fn cos(self) -> NonNaNFinite<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.

impl StrictlyPositiveFinite<f32>

pub fn tan(self) -> NonNaN<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.

impl StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<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.

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

impl StrictlyPositiveFinite<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(), core::f64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.exp_m1(), -1.0);

See f64::exp_m1() for more details.

impl StrictlyPositiveFinite<f32>

pub fn ln_1p(self) -> StrictlyPositiveFinite<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(), core::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(), core::f64::INFINITY);
assert_is_nan!(tf64::NEG_INFINITY.ln_1p());

See f64::ln_1p() for more details.

impl StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<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.

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

impl StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<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.

impl StrictlyPositiveFinite<f32>

pub fn recip(self) -> StrictlyPositiveFinite<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.

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

impl Add<Negative<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the + operator.

fn add(self, rhs: Negative<f32>) -> Self::Output

Performs the + operation.

impl Add<Negative> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the + operator.

fn add(self, rhs: Negative<f64>) -> Self::Output

Performs the + operation.

impl Add<NegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying the + operator.

fn add(self, rhs: NegativeFinite<f32>) -> Self::Output

Performs the + operation.

impl Add<NegativeFinite> for StrictlyPositiveFinite<f64>

type Output = NonNaNFinite

The resulting type after applying the + operator.

fn add(self, rhs: NegativeFinite<f64>) -> Self::Output

Performs the + operation.

impl Add<NonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the + operator.

fn add(self, rhs: NonNaN<f32>) -> Self::Output

Performs the + operation.

impl Add<NonNaN> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the + operator.

fn add(self, rhs: NonNaN<f64>) -> Self::Output

Performs the + operation.

impl Add<NonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the + operator.

fn add(self, rhs: NonNaNFinite<f32>) -> Self::Output

Performs the + operation.

impl Add<NonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the + operator.

fn add(self, rhs: NonNaNFinite<f64>) -> Self::Output

Performs the + operation.

impl Add<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroNonNaN<f32>) -> Self::Output

Performs the + operation.

impl Add<NonZeroNonNaN> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroNonNaN<f64>) -> Self::Output

Performs the + operation.

impl Add<NonZeroNonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroNonNaNFinite<f32>) -> Self::Output

Performs the + operation.

impl Add<NonZeroNonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroNonNaNFinite<f64>) -> Self::Output

Performs the + operation.

impl Add<Positive<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying the + operator.

fn add(self, rhs: Positive<f32>) -> Self::Output

Performs the + operation.

impl Add<Positive> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying the + operator.

fn add(self, rhs: Positive<f64>) -> Self::Output

Performs the + operation.

impl Add<PositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying the + operator.

fn add(self, rhs: PositiveFinite<f32>) -> Self::Output

Performs the + operation.

impl Add<PositiveFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying the + operator.

fn add(self, rhs: PositiveFinite<f64>) -> Self::Output

Performs the + operation.

impl Add<StrictlyNegative<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyNegative<f32>) -> Self::Output

Performs the + operation.

impl Add<StrictlyNegative> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyNegative<f64>) -> Self::Output

Performs the + operation.

impl Add<StrictlyNegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyNegativeFinite<f32>) -> Self::Output

Performs the + operation.

impl Add<StrictlyNegativeFinite> for StrictlyPositiveFinite<f64>

type Output = NonNaNFinite

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyNegativeFinite<f64>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositive<f32>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositive> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositive<f64>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite<f32>> for Negative<f32>

type Output = NonNaN<f32>

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite<f32>> for NegativeFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite<f32>> for NonNaN<f32>

type Output = NonNaN<f32>

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite<f32>> for NonNaNFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>

type Output = NonNaN<f32>

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite<f32>> for NonZeroNonNaNFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite<f32>> for Positive<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite<f32>> for PositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite<f32>> for StrictlyNegative<f32>

type Output = NonNaN<f32>

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite<f32>> for StrictlyNegativeFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite> for Negative<f64>

type Output = NonNaN

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite> for NegativeFinite<f64>

type Output = NonNaNFinite

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite> for NonNaN<f64>

type Output = NonNaN

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite> for NonNaNFinite<f64>

type Output = NonNaN

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite> for NonZeroNonNaN<f64>

type Output = NonNaN

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite> for NonZeroNonNaNFinite<f64>

type Output = NonNaN

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite> for Positive<f64>

type Output = StrictlyPositive

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite> for PositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite> for StrictlyNegative<f64>

type Output = NonNaN

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite> for StrictlyNegativeFinite<f64>

type Output = NonNaNFinite

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the + operation.

impl Add<StrictlyPositiveFinite> for StrictlyPositive<f64>

type Output = StrictlyPositive

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the + operation.

impl Add for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the + operation.

impl Add for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the + operation.

impl AddAssign<StrictlyPositiveFinite<f32>> for NonNaN<f32>

fn add_assign(&mut self, rhs: StrictlyPositiveFinite<f32>)

Performs the += operation.

impl AddAssign<StrictlyPositiveFinite<f32>> for Positive<f32>

fn add_assign(&mut self, rhs: StrictlyPositiveFinite<f32>)

Performs the += operation.

impl AddAssign<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>

fn add_assign(&mut self, rhs: StrictlyPositiveFinite<f32>)

Performs the += operation.

impl AddAssign<StrictlyPositiveFinite> for NonNaN<f64>

fn add_assign(&mut self, rhs: StrictlyPositiveFinite<f64>)

Performs the += operation.

impl AddAssign<StrictlyPositiveFinite> for Positive<f64>

fn add_assign(&mut self, rhs: StrictlyPositiveFinite<f64>)

Performs the += operation.

impl AddAssign<StrictlyPositiveFinite> for StrictlyPositive<f64>

fn add_assign(&mut self, rhs: StrictlyPositiveFinite<f64>)

Performs the += operation.

impl Atan2<Negative<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: Negative<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<Negative> for StrictlyPositiveFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: Negative<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<NegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: NegativeFinite<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<NegativeFinite> for StrictlyPositiveFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: NegativeFinite<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<NonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: NonNaN<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<NonNaN> for StrictlyPositiveFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: NonNaN<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<NonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: NonNaNFinite<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<NonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: NonNaNFinite<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: NonZeroNonNaN<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<NonZeroNonNaN> for StrictlyPositiveFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: NonZeroNonNaN<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<NonZeroNonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: NonZeroNonNaNFinite<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<NonZeroNonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: NonZeroNonNaNFinite<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<Positive<f32>> for StrictlyPositiveFinite<f32>

type Output = PositiveFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: Positive<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<Positive> for StrictlyPositiveFinite<f64>

type Output = PositiveFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: Positive<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<PositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = PositiveFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: PositiveFinite<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<PositiveFinite> for StrictlyPositiveFinite<f64>

type Output = PositiveFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: PositiveFinite<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyNegative<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyNegative<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyNegative> for StrictlyPositiveFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyNegative<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyNegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyNegativeFinite<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyNegativeFinite> for StrictlyPositiveFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyNegativeFinite<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>

type Output = PositiveFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositive<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositive> for StrictlyPositiveFinite<f64>

type Output = PositiveFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositive<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite<f32>> for Negative<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite<f32>> for NegativeFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite<f32>> for NonNaN<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite<f32>> for NonNaNFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite<f32>> for NonZeroNonNaNFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite<f32>> for Positive<f32>

type Output = PositiveFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite<f32>> for PositiveFinite<f32>

type Output = PositiveFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite<f32>> for StrictlyNegative<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite<f32>> for StrictlyNegativeFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>

type Output = PositiveFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = PositiveFinite<f32>

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite> for Negative<f64>

type Output = NonNaNFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite> for NegativeFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite> for NonNaN<f64>

type Output = NonNaNFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite> for NonNaNFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite> for NonZeroNonNaN<f64>

type Output = NonNaNFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite> for NonZeroNonNaNFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite> for Positive<f64>

type Output = PositiveFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite> for PositiveFinite<f64>

type Output = PositiveFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite> for StrictlyNegative<f64>

type Output = NonNaNFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite> for StrictlyNegativeFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite> for StrictlyPositive<f64>

type Output = PositiveFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl Atan2<StrictlyPositiveFinite> for StrictlyPositiveFinite<f64>

type Output = PositiveFinite

The resulting type after applying Atan2::atan2().

fn atan2(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Computes the four quadrant arctangent of self (y) and other (x) in radians.

impl<T: Clone> Clone for StrictlyPositiveFinite<T>

fn clone(&self) -> StrictlyPositiveFinite<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copysign<Negative<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyNegativeFinite<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: Negative<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<Negative> for StrictlyPositiveFinite<f64>

type Output = StrictlyNegativeFinite

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: Negative<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<NegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyNegativeFinite<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: NegativeFinite<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<NegativeFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyNegativeFinite

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: NegativeFinite<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<NonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = NonZeroNonNaNFinite<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: NonNaN<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<NonNaN> for StrictlyPositiveFinite<f64>

type Output = NonZeroNonNaNFinite

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: NonNaN<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<NonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonZeroNonNaNFinite<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: NonNaNFinite<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<NonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = NonZeroNonNaNFinite

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: NonNaNFinite<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = NonZeroNonNaNFinite<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: NonZeroNonNaN<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<NonZeroNonNaN> for StrictlyPositiveFinite<f64>

type Output = NonZeroNonNaNFinite

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: NonZeroNonNaN<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<NonZeroNonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonZeroNonNaNFinite<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: NonZeroNonNaNFinite<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<NonZeroNonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = NonZeroNonNaNFinite

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: NonZeroNonNaNFinite<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<Positive<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: Positive<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<Positive> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: Positive<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<PositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: PositiveFinite<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<PositiveFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: PositiveFinite<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyNegative<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyNegativeFinite<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyNegative<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyNegative> for StrictlyPositiveFinite<f64>

type Output = StrictlyNegativeFinite

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyNegative<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyNegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyNegativeFinite<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyNegativeFinite<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyNegativeFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyNegativeFinite

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyNegativeFinite<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositive<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositive> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositive<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite<f32>> for Negative<f32>

type Output = Positive<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite<f32>> for NegativeFinite<f32>

type Output = PositiveFinite<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite<f32>> for NonNaN<f32>

type Output = Positive<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite<f32>> for NonNaNFinite<f32>

type Output = PositiveFinite<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite<f32>> for NonZeroNonNaNFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite<f32>> for Positive<f32>

type Output = Positive<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite<f32>> for PositiveFinite<f32>

type Output = PositiveFinite<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite<f32>> for StrictlyNegative<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite<f32>> for StrictlyNegativeFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite> for Negative<f64>

type Output = Positive

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite> for NegativeFinite<f64>

type Output = PositiveFinite

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite> for NonNaN<f64>

type Output = Positive

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite> for NonNaNFinite<f64>

type Output = PositiveFinite

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite> for NonZeroNonNaN<f64>

type Output = StrictlyPositive

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite> for NonZeroNonNaNFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite> for Positive<f64>

type Output = Positive

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite> for PositiveFinite<f64>

type Output = PositiveFinite

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite> for StrictlyNegative<f64>

type Output = StrictlyPositive

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite> for StrictlyNegativeFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite> for StrictlyPositive<f64>

type Output = StrictlyPositive

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl Copysign<StrictlyPositiveFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Copysign::copysign().

fn copysign(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns a number composed of the magnitude of self and the sign of sign. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl<T: Debug> Debug for StrictlyPositiveFinite<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StrictlyPositiveFinite<f64>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de> Deserialize<'de> for StrictlyPositiveFinite<f32>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for StrictlyPositiveFinite<f64>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for StrictlyPositiveFinite<f32>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Div<Negative<f32>> for StrictlyPositiveFinite<f32>

type Output = Negative<f32>

The resulting type after applying the / operator.

fn div(self, rhs: Negative<f32>) -> Self::Output

Performs the / operation.

impl Div<Negative> for StrictlyPositiveFinite<f64>

type Output = Negative

The resulting type after applying the / operator.

fn div(self, rhs: Negative<f64>) -> Self::Output

Performs the / operation.

impl Div<NegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = Negative<f32>

The resulting type after applying the / operator.

fn div(self, rhs: NegativeFinite<f32>) -> Self::Output

Performs the / operation.

impl Div<NegativeFinite> for StrictlyPositiveFinite<f64>

type Output = Negative

The resulting type after applying the / operator.

fn div(self, rhs: NegativeFinite<f64>) -> Self::Output

Performs the / operation.

impl Div<NonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the / operator.

fn div(self, rhs: NonNaN<f32>) -> Self::Output

Performs the / operation.

impl Div<NonNaN> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the / operator.

fn div(self, rhs: NonNaN<f64>) -> Self::Output

Performs the / operation.

impl Div<NonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the / operator.

fn div(self, rhs: NonNaNFinite<f32>) -> Self::Output

Performs the / operation.

impl Div<NonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the / operator.

fn div(self, rhs: NonNaNFinite<f64>) -> Self::Output

Performs the / operation.

impl Div<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroNonNaN<f32>) -> Self::Output

Performs the / operation.

impl Div<NonZeroNonNaN> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroNonNaN<f64>) -> Self::Output

Performs the / operation.

impl Div<NonZeroNonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroNonNaNFinite<f32>) -> Self::Output

Performs the / operation.

impl Div<NonZeroNonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroNonNaNFinite<f64>) -> Self::Output

Performs the / operation.

impl Div<Positive<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying the / operator.

fn div(self, rhs: Positive<f32>) -> Self::Output

Performs the / operation.

impl Div<Positive> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying the / operator.

fn div(self, rhs: Positive<f64>) -> Self::Output

Performs the / operation.

impl Div<PositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying the / operator.

fn div(self, rhs: PositiveFinite<f32>) -> Self::Output

Performs the / operation.

impl Div<PositiveFinite> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying the / operator.

fn div(self, rhs: PositiveFinite<f64>) -> Self::Output

Performs the / operation.

impl Div<StrictlyNegative<f32>> for StrictlyPositiveFinite<f32>

type Output = Negative<f32>

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyNegative<f32>) -> Self::Output

Performs the / operation.

impl Div<StrictlyNegative> for StrictlyPositiveFinite<f64>

type Output = Negative

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyNegative<f64>) -> Self::Output

Performs the / operation.

impl Div<StrictlyNegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = Negative<f32>

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyNegativeFinite<f32>) -> Self::Output

Performs the / operation.

impl Div<StrictlyNegativeFinite> for StrictlyPositiveFinite<f64>

type Output = Negative

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyNegativeFinite<f64>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositive<f32>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositive> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositive<f64>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite<f32>> for Negative<f32>

type Output = Negative<f32>

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite<f32>> for NegativeFinite<f32>

type Output = Negative<f32>

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite<f32>> for NonNaN<f32>

type Output = NonNaN<f32>

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite<f32>> for NonNaNFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>

type Output = NonNaN<f32>

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite<f32>> for NonZeroNonNaNFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite<f32>> for Positive<f32>

type Output = Positive<f32>

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite<f32>> for PositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite<f32>> for StrictlyNegative<f32>

type Output = Negative<f32>

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite<f32>> for StrictlyNegativeFinite<f32>

type Output = Negative<f32>

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>

type Output = Positive<f32>

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite> for Negative<f64>

type Output = Negative

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite> for NegativeFinite<f64>

type Output = Negative

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite> for NonNaN<f64>

type Output = NonNaN

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite> for NonNaNFinite<f64>

type Output = NonNaN

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite> for NonZeroNonNaN<f64>

type Output = NonNaN

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite> for NonZeroNonNaNFinite<f64>

type Output = NonNaN

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite> for Positive<f64>

type Output = Positive

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite> for PositiveFinite<f64>

type Output = Positive

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite> for StrictlyNegative<f64>

type Output = Negative

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite> for StrictlyNegativeFinite<f64>

type Output = Negative

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the / operation.

impl Div<StrictlyPositiveFinite> for StrictlyPositive<f64>

type Output = Positive

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the / operation.

impl Div for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the / operation.

impl Div for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the / operation.

impl DivAssign<StrictlyPositiveFinite<f32>> for Negative<f32>

fn div_assign(&mut self, rhs: StrictlyPositiveFinite<f32>)

Performs the /= operation.

impl DivAssign<StrictlyPositiveFinite<f32>> for NonNaN<f32>

fn div_assign(&mut self, rhs: StrictlyPositiveFinite<f32>)

Performs the /= operation.

impl DivAssign<StrictlyPositiveFinite<f32>> for Positive<f32>

fn div_assign(&mut self, rhs: StrictlyPositiveFinite<f32>)

Performs the /= operation.

impl DivAssign<StrictlyPositiveFinite> for Negative<f64>

fn div_assign(&mut self, rhs: StrictlyPositiveFinite<f64>)

Performs the /= operation.

impl DivAssign<StrictlyPositiveFinite> for NonNaN<f64>

fn div_assign(&mut self, rhs: StrictlyPositiveFinite<f64>)

Performs the /= operation.

impl DivAssign<StrictlyPositiveFinite> for Positive<f64>

fn div_assign(&mut self, rhs: StrictlyPositiveFinite<f64>)

Performs the /= operation.

impl DivEuclid<Negative<f32>> for StrictlyPositiveFinite<f32>

type Output = Negative<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: Negative<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<Negative> for StrictlyPositiveFinite<f64>

type Output = Negative

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: Negative<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<NegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = Negative<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: NegativeFinite<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<NegativeFinite> for StrictlyPositiveFinite<f64>

type Output = Negative

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: NegativeFinite<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<NonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: NonNaN<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<NonNaN> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: NonNaN<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<NonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: NonNaNFinite<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<NonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: NonNaNFinite<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: NonZeroNonNaN<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<NonZeroNonNaN> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: NonZeroNonNaN<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<NonZeroNonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: NonZeroNonNaNFinite<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<NonZeroNonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: NonZeroNonNaNFinite<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<Positive<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: Positive<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<Positive> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: Positive<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<PositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: PositiveFinite<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<PositiveFinite> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: PositiveFinite<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyNegative<f32>> for StrictlyPositiveFinite<f32>

type Output = Negative<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyNegative<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyNegative> for StrictlyPositiveFinite<f64>

type Output = Negative

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyNegative<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyNegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = Negative<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyNegativeFinite<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyNegativeFinite> for StrictlyPositiveFinite<f64>

type Output = Negative

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyNegativeFinite<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositive<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositive> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositive<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite<f32>> for Negative<f32>

type Output = Negative<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite<f32>> for NegativeFinite<f32>

type Output = Negative<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite<f32>> for NonNaN<f32>

type Output = NonNaN<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite<f32>> for NonNaNFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>

type Output = NonNaN<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite<f32>> for NonZeroNonNaNFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite<f32>> for Positive<f32>

type Output = Positive<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite<f32>> for PositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite<f32>> for StrictlyNegative<f32>

type Output = Negative<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite<f32>> for StrictlyNegativeFinite<f32>

type Output = Negative<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>

type Output = Positive<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite> for Negative<f64>

type Output = Negative

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite> for NegativeFinite<f64>

type Output = Negative

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite> for NonNaN<f64>

type Output = NonNaN

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite> for NonNaNFinite<f64>

type Output = NonNaN

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite> for NonZeroNonNaN<f64>

type Output = NonNaN

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite> for NonZeroNonNaNFinite<f64>

type Output = NonNaN

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite> for Positive<f64>

type Output = Positive

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite> for PositiveFinite<f64>

type Output = Positive

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite> for StrictlyNegative<f64>

type Output = Negative

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite> for StrictlyNegativeFinite<f64>

type Output = Negative

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite> for StrictlyPositive<f64>

type Output = Positive

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl DivEuclid<StrictlyPositiveFinite> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying DivEuclid::div_euclid().

fn div_euclid(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Calculates Euclidean division, the matching method for rem_euclid. Equal to self if the sign of self and sign are the same, otherwise equal to -self.

impl From<NonZero<u16>> for StrictlyPositiveFinite<f64>

fn from(value: NonZeroU16) -> Self

Converts to this type from the input type.

impl From<NonZero<u16>> for StrictlyPositiveFinite<f32>

fn from(value: NonZeroU16) -> Self

Converts to this type from the input type.

impl From<NonZero<u32>> for StrictlyPositiveFinite<f64>

fn from(value: NonZeroU32) -> Self

Converts to this type from the input type.

impl From<NonZero<u32>> for StrictlyPositiveFinite<f32>

fn from(value: NonZeroU32) -> Self

Converts to this type from the input type.

impl From<NonZero<u64>> for StrictlyPositiveFinite<f64>

fn from(value: NonZeroU64) -> Self

Converts to this type from the input type.

impl From<NonZero<u64>> for StrictlyPositiveFinite<f32>

fn from(value: NonZeroU64) -> Self

Converts to this type from the input type.

impl From<NonZero<u8>> for StrictlyPositiveFinite<f64>

fn from(value: NonZeroU8) -> Self

Converts to this type from the input type.

impl From<NonZero<u8>> for StrictlyPositiveFinite<f32>

fn from(value: NonZeroU8) -> Self

Converts to this type from the input type.

impl From<StrictlyPositiveFinite<f32>> for NonNaN<f32>

fn from(value: StrictlyPositiveFinite<f32>) -> Self

Converts to this type from the input type.

impl From<StrictlyPositiveFinite<f32>> for NonNaNFinite<f32>

fn from(value: StrictlyPositiveFinite<f32>) -> Self

Converts to this type from the input type.

impl From<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>

fn from(value: StrictlyPositiveFinite<f32>) -> Self

Converts to this type from the input type.

impl From<StrictlyPositiveFinite<f32>> for NonZeroNonNaNFinite<f32>

fn from(value: StrictlyPositiveFinite<f32>) -> Self

Converts to this type from the input type.

impl From<StrictlyPositiveFinite<f32>> for Positive<f32>

fn from(value: StrictlyPositiveFinite<f32>) -> Self

Converts to this type from the input type.

impl From<StrictlyPositiveFinite<f32>> for PositiveFinite<f32>

fn from(value: StrictlyPositiveFinite<f32>) -> Self

Converts to this type from the input type.

impl From<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>

fn from(value: StrictlyPositiveFinite<f32>) -> Self

Converts to this type from the input type.

impl From<StrictlyPositiveFinite<f32>> for f32

fn from(value: StrictlyPositiveFinite<Self>) -> Self

Converts to this type from the input type.

impl From<StrictlyPositiveFinite> for NonNaN<f64>

fn from(value: StrictlyPositiveFinite<f64>) -> Self

Converts to this type from the input type.

impl From<StrictlyPositiveFinite> for NonNaNFinite<f64>

fn from(value: StrictlyPositiveFinite<f64>) -> Self

Converts to this type from the input type.

impl From<StrictlyPositiveFinite> for NonZeroNonNaN<f64>

fn from(value: StrictlyPositiveFinite<f64>) -> Self

Converts to this type from the input type.

impl From<StrictlyPositiveFinite> for NonZeroNonNaNFinite<f64>

fn from(value: StrictlyPositiveFinite<f64>) -> Self

Converts to this type from the input type.

impl From<StrictlyPositiveFinite> for Positive<f64>

fn from(value: StrictlyPositiveFinite<f64>) -> Self

Converts to this type from the input type.

impl From<StrictlyPositiveFinite> for PositiveFinite<f64>

fn from(value: StrictlyPositiveFinite<f64>) -> Self

Converts to this type from the input type.

impl From<StrictlyPositiveFinite> for StrictlyPositive<f64>

fn from(value: StrictlyPositiveFinite<f64>) -> Self

Converts to this type from the input type.

impl From<StrictlyPositiveFinite> for f64

fn from(value: StrictlyPositiveFinite<Self>) -> Self

Converts to this type from the input type.

impl FromStr for StrictlyPositiveFinite<f64>

type Err = FromStrError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl FromStr for StrictlyPositiveFinite<f32>

type Err = FromStrError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for StrictlyPositiveFinite<f64>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Hash for StrictlyPositiveFinite<f32>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Hypot<Negative<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: Negative<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<Negative> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: Negative<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<NegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: NegativeFinite<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<NegativeFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: NegativeFinite<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<NonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: NonNaN<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<NonNaN> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: NonNaN<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<NonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: NonNaNFinite<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<NonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: NonNaNFinite<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: NonZeroNonNaN<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<NonZeroNonNaN> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: NonZeroNonNaN<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<NonZeroNonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: NonZeroNonNaNFinite<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<NonZeroNonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: NonZeroNonNaNFinite<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<Positive<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: Positive<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<Positive> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: Positive<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<PositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: PositiveFinite<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<PositiveFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: PositiveFinite<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyNegative<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyNegative<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyNegative> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyNegative<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyNegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyNegativeFinite<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyNegativeFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyNegativeFinite<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositive<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositive> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositive<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite<f32>> for Negative<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite<f32>> for NegativeFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite<f32>> for NonNaN<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite<f32>> for NonNaNFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite<f32>> for NonZeroNonNaNFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite<f32>> for Positive<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite<f32>> for PositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite<f32>> for StrictlyNegative<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite<f32>> for StrictlyNegativeFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite> for Negative<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite> for NegativeFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite> for NonNaN<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite> for NonNaNFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite> for NonZeroNonNaN<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite> for NonZeroNonNaNFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite> for Positive<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite> for PositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite> for StrictlyNegative<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite> for StrictlyNegativeFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite> for StrictlyPositive<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Hypot<StrictlyPositiveFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Hypot::hypot().

fn hypot(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

impl Max<Negative<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Max::max().

fn max(self, rhs: Negative<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<Negative> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Max::max().

fn max(self, rhs: Negative<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<NegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Max::max().

fn max(self, rhs: NegativeFinite<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<NegativeFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Max::max().

fn max(self, rhs: NegativeFinite<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<NonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Max::max().

fn max(self, rhs: NonNaN<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<NonNaN> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Max::max().

fn max(self, rhs: NonNaN<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<NonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Max::max().

fn max(self, rhs: NonNaNFinite<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<NonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Max::max().

fn max(self, rhs: NonNaNFinite<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Max::max().

fn max(self, rhs: NonZeroNonNaN<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<NonZeroNonNaN> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Max::max().

fn max(self, rhs: NonZeroNonNaN<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<NonZeroNonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Max::max().

fn max(self, rhs: NonZeroNonNaNFinite<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<NonZeroNonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Max::max().

fn max(self, rhs: NonZeroNonNaNFinite<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<Positive<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Max::max().

fn max(self, rhs: Positive<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<Positive> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Max::max().

fn max(self, rhs: Positive<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<PositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Max::max().

fn max(self, rhs: PositiveFinite<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<PositiveFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Max::max().

fn max(self, rhs: PositiveFinite<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyNegative<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyNegative<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyNegative> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyNegative<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyNegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyNegativeFinite<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyNegativeFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyNegativeFinite<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositive<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositive> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositive<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite<f32>> for Negative<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite<f32>> for NegativeFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite<f32>> for NonNaN<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite<f32>> for NonNaNFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite<f32>> for NonZeroNonNaNFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite<f32>> for Positive<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite<f32>> for PositiveFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite<f32>> for StrictlyNegative<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite<f32>> for StrictlyNegativeFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite> for Negative<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite> for NegativeFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite> for NonNaN<f64>

type Output = StrictlyPositive

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite> for NonNaNFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite> for NonZeroNonNaN<f64>

type Output = StrictlyPositive

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite> for NonZeroNonNaNFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite> for Positive<f64>

type Output = StrictlyPositive

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite> for PositiveFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite> for StrictlyNegative<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite> for StrictlyNegativeFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite> for StrictlyPositive<f64>

type Output = StrictlyPositive

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Max<StrictlyPositiveFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Max::max().

fn max(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the maximum of the two numbers.

impl Min<Negative<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying Min::min().

fn min(self, rhs: Negative<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<Negative> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying Min::min().

fn min(self, rhs: Negative<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<NegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Min::min().

fn min(self, rhs: NegativeFinite<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<NegativeFinite> for StrictlyPositiveFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Min::min().

fn min(self, rhs: NegativeFinite<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<NonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying Min::min().

fn min(self, rhs: NonNaN<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<NonNaN> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying Min::min().

fn min(self, rhs: NonNaN<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<NonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Min::min().

fn min(self, rhs: NonNaNFinite<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<NonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Min::min().

fn min(self, rhs: NonNaNFinite<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = NonZeroNonNaN<f32>

The resulting type after applying Min::min().

fn min(self, rhs: NonZeroNonNaN<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<NonZeroNonNaN> for StrictlyPositiveFinite<f64>

type Output = NonZeroNonNaN

The resulting type after applying Min::min().

fn min(self, rhs: NonZeroNonNaN<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<NonZeroNonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonZeroNonNaNFinite<f32>

The resulting type after applying Min::min().

fn min(self, rhs: NonZeroNonNaNFinite<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<NonZeroNonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = NonZeroNonNaNFinite

The resulting type after applying Min::min().

fn min(self, rhs: NonZeroNonNaNFinite<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<Positive<f32>> for StrictlyPositiveFinite<f32>

type Output = PositiveFinite<f32>

The resulting type after applying Min::min().

fn min(self, rhs: Positive<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<Positive> for StrictlyPositiveFinite<f64>

type Output = PositiveFinite

The resulting type after applying Min::min().

fn min(self, rhs: Positive<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<PositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = PositiveFinite<f32>

The resulting type after applying Min::min().

fn min(self, rhs: PositiveFinite<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<PositiveFinite> for StrictlyPositiveFinite<f64>

type Output = PositiveFinite

The resulting type after applying Min::min().

fn min(self, rhs: PositiveFinite<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyNegative<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyNegative<f32>

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyNegative<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyNegative> for StrictlyPositiveFinite<f64>

type Output = StrictlyNegative

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyNegative<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyNegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyNegativeFinite<f32>

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyNegativeFinite<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyNegativeFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyNegativeFinite

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyNegativeFinite<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositive<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositive> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositive<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite<f32>> for Negative<f32>

type Output = NonNaN<f32>

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite<f32>> for NegativeFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite<f32>> for NonNaN<f32>

type Output = NonNaN<f32>

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite<f32>> for NonNaNFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>

type Output = NonZeroNonNaN<f32>

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite<f32>> for NonZeroNonNaNFinite<f32>

type Output = NonZeroNonNaNFinite<f32>

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite<f32>> for Positive<f32>

type Output = PositiveFinite<f32>

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite<f32>> for PositiveFinite<f32>

type Output = PositiveFinite<f32>

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite<f32>> for StrictlyNegative<f32>

type Output = StrictlyNegative<f32>

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite<f32>> for StrictlyNegativeFinite<f32>

type Output = StrictlyNegativeFinite<f32>

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositiveFinite<f32>

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite> for Negative<f64>

type Output = NonNaN

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite> for NegativeFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite> for NonNaN<f64>

type Output = NonNaN

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite> for NonNaNFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite> for NonZeroNonNaN<f64>

type Output = NonZeroNonNaN

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite> for NonZeroNonNaNFinite<f64>

type Output = NonZeroNonNaNFinite

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite> for Positive<f64>

type Output = PositiveFinite

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite> for PositiveFinite<f64>

type Output = PositiveFinite

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite> for StrictlyNegative<f64>

type Output = StrictlyNegative

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite> for StrictlyNegativeFinite<f64>

type Output = StrictlyNegativeFinite

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite> for StrictlyPositive<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Min<StrictlyPositiveFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositiveFinite

The resulting type after applying Min::min().

fn min(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Returns the minimum of the two numbers.

impl Mul<Negative<f32>> for StrictlyPositiveFinite<f32>

type Output = Negative<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: Negative<f32>) -> Self::Output

Performs the * operation.

impl Mul<Negative> for StrictlyPositiveFinite<f64>

type Output = Negative

The resulting type after applying the * operator.

fn mul(self, rhs: Negative<f64>) -> Self::Output

Performs the * operation.

impl Mul<NegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = Negative<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: NegativeFinite<f32>) -> Self::Output

Performs the * operation.

impl Mul<NegativeFinite> for StrictlyPositiveFinite<f64>

type Output = Negative

The resulting type after applying the * operator.

fn mul(self, rhs: NegativeFinite<f64>) -> Self::Output

Performs the * operation.

impl Mul<NonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: NonNaN<f32>) -> Self::Output

Performs the * operation.

impl Mul<NonNaN> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the * operator.

fn mul(self, rhs: NonNaN<f64>) -> Self::Output

Performs the * operation.

impl Mul<NonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: NonNaNFinite<f32>) -> Self::Output

Performs the * operation.

impl Mul<NonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the * operator.

fn mul(self, rhs: NonNaNFinite<f64>) -> Self::Output

Performs the * operation.

impl Mul<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroNonNaN<f32>) -> Self::Output

Performs the * operation.

impl Mul<NonZeroNonNaN> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroNonNaN<f64>) -> Self::Output

Performs the * operation.

impl Mul<NonZeroNonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroNonNaNFinite<f32>) -> Self::Output

Performs the * operation.

impl Mul<NonZeroNonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroNonNaNFinite<f64>) -> Self::Output

Performs the * operation.

impl Mul<Positive<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: Positive<f32>) -> Self::Output

Performs the * operation.

impl Mul<Positive> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying the * operator.

fn mul(self, rhs: Positive<f64>) -> Self::Output

Performs the * operation.

impl Mul<PositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: PositiveFinite<f32>) -> Self::Output

Performs the * operation.

impl Mul<PositiveFinite> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying the * operator.

fn mul(self, rhs: PositiveFinite<f64>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyNegative<f32>> for StrictlyPositiveFinite<f32>

type Output = Negative<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyNegative<f32>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyNegative> for StrictlyPositiveFinite<f64>

type Output = Negative

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyNegative<f64>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyNegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = Negative<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyNegativeFinite<f32>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyNegativeFinite> for StrictlyPositiveFinite<f64>

type Output = Negative

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyNegativeFinite<f64>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositive<f32>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositive> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositive<f64>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite<f32>> for Negative<f32>

type Output = Negative<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite<f32>> for NegativeFinite<f32>

type Output = Negative<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite<f32>> for NonNaN<f32>

type Output = NonNaN<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite<f32>> for NonNaNFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>

type Output = NonNaN<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite<f32>> for NonZeroNonNaNFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite<f32>> for Positive<f32>

type Output = Positive<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite<f32>> for PositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite<f32>> for StrictlyNegative<f32>

type Output = Negative<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite<f32>> for StrictlyNegativeFinite<f32>

type Output = Negative<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>

type Output = Positive<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite> for Negative<f64>

type Output = Negative

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite> for NegativeFinite<f64>

type Output = Negative

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite> for NonNaN<f64>

type Output = NonNaN

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite> for NonNaNFinite<f64>

type Output = NonNaN

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite> for NonZeroNonNaN<f64>

type Output = NonNaN

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite> for NonZeroNonNaNFinite<f64>

type Output = NonNaN

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite> for Positive<f64>

type Output = Positive

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite> for PositiveFinite<f64>

type Output = Positive

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite> for StrictlyNegative<f64>

type Output = Negative

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite> for StrictlyNegativeFinite<f64>

type Output = Negative

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the * operation.

impl Mul<StrictlyPositiveFinite> for StrictlyPositive<f64>

type Output = Positive

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the * operation.

impl Mul for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the * operation.

impl Mul for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the * operation.

impl MulAssign<StrictlyPositiveFinite<f32>> for Negative<f32>

fn mul_assign(&mut self, rhs: StrictlyPositiveFinite<f32>)

Performs the *= operation.

impl MulAssign<StrictlyPositiveFinite<f32>> for NonNaN<f32>

fn mul_assign(&mut self, rhs: StrictlyPositiveFinite<f32>)

Performs the *= operation.

impl MulAssign<StrictlyPositiveFinite<f32>> for Positive<f32>

fn mul_assign(&mut self, rhs: StrictlyPositiveFinite<f32>)

Performs the *= operation.

impl MulAssign<StrictlyPositiveFinite> for Negative<f64>

fn mul_assign(&mut self, rhs: StrictlyPositiveFinite<f64>)

Performs the *= operation.

impl MulAssign<StrictlyPositiveFinite> for NonNaN<f64>

fn mul_assign(&mut self, rhs: StrictlyPositiveFinite<f64>)

Performs the *= operation.

impl MulAssign<StrictlyPositiveFinite> for Positive<f64>

fn mul_assign(&mut self, rhs: StrictlyPositiveFinite<f64>)

Performs the *= operation.

impl Neg for StrictlyPositiveFinite<f64>

type Output = StrictlyNegativeFinite

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for StrictlyPositiveFinite<f32>

type Output = StrictlyNegativeFinite<f32>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Ord for StrictlyPositiveFinite<f64>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl Ord for StrictlyPositiveFinite<f32>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq<Negative<f32>> for StrictlyPositiveFinite<f32>

fn eq(&self, other: &Negative<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Negative> for StrictlyPositiveFinite<f64>

fn eq(&self, other: &Negative<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<NegativeFinite<f32>> for StrictlyPositiveFinite<f32>

fn eq(&self, other: &NegativeFinite<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<NegativeFinite> for StrictlyPositiveFinite<f64>

fn eq(&self, other: &NegativeFinite<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<NonNaN<f32>> for StrictlyPositiveFinite<f32>

fn eq(&self, other: &NonNaN<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<NonNaN> for StrictlyPositiveFinite<f64>

fn eq(&self, other: &NonNaN<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<NonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

fn eq(&self, other: &NonNaNFinite<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<NonNaNFinite> for StrictlyPositiveFinite<f64>

fn eq(&self, other: &NonNaNFinite<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>

fn eq(&self, other: &NonZeroNonNaN<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<NonZeroNonNaN> for StrictlyPositiveFinite<f64>

fn eq(&self, other: &NonZeroNonNaN<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<NonZeroNonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

fn eq(&self, other: &NonZeroNonNaNFinite<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<NonZeroNonNaNFinite> for StrictlyPositiveFinite<f64>

fn eq(&self, other: &NonZeroNonNaNFinite<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Positive<f32>> for StrictlyPositiveFinite<f32>

fn eq(&self, other: &Positive<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Positive> for StrictlyPositiveFinite<f64>

fn eq(&self, other: &Positive<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<PositiveFinite<f32>> for StrictlyPositiveFinite<f32>

fn eq(&self, other: &PositiveFinite<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<PositiveFinite> for StrictlyPositiveFinite<f64>

fn eq(&self, other: &PositiveFinite<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyNegative<f32>> for StrictlyPositiveFinite<f32>

fn eq(&self, other: &StrictlyNegative<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyNegative> for StrictlyPositiveFinite<f64>

fn eq(&self, other: &StrictlyNegative<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyNegativeFinite<f32>> for StrictlyPositiveFinite<f32>

fn eq(&self, other: &StrictlyNegativeFinite<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyNegativeFinite> for StrictlyPositiveFinite<f64>

fn eq(&self, other: &StrictlyNegativeFinite<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>

fn eq(&self, other: &StrictlyPositive<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositive> for StrictlyPositiveFinite<f64>

fn eq(&self, other: &StrictlyPositive<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite<f32>> for Negative<f32>

fn eq(&self, other: &StrictlyPositiveFinite<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite<f32>> for NegativeFinite<f32>

fn eq(&self, other: &StrictlyPositiveFinite<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite<f32>> for NonNaN<f32>

fn eq(&self, other: &StrictlyPositiveFinite<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite<f32>> for NonNaNFinite<f32>

fn eq(&self, other: &StrictlyPositiveFinite<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>

fn eq(&self, other: &StrictlyPositiveFinite<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite<f32>> for NonZeroNonNaNFinite<f32>

fn eq(&self, other: &StrictlyPositiveFinite<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite<f32>> for Positive<f32>

fn eq(&self, other: &StrictlyPositiveFinite<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite<f32>> for PositiveFinite<f32>

fn eq(&self, other: &StrictlyPositiveFinite<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite<f32>> for StrictlyNegative<f32>

fn eq(&self, other: &StrictlyPositiveFinite<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite<f32>> for StrictlyNegativeFinite<f32>

fn eq(&self, other: &StrictlyPositiveFinite<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>

fn eq(&self, other: &StrictlyPositiveFinite<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite<f32>> for f32

fn eq(&self, other: &StrictlyPositiveFinite<f32>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite> for Negative<f64>

fn eq(&self, other: &StrictlyPositiveFinite<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite> for NegativeFinite<f64>

fn eq(&self, other: &StrictlyPositiveFinite<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite> for NonNaN<f64>

fn eq(&self, other: &StrictlyPositiveFinite<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite> for NonNaNFinite<f64>

fn eq(&self, other: &StrictlyPositiveFinite<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite> for NonZeroNonNaN<f64>

fn eq(&self, other: &StrictlyPositiveFinite<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite> for NonZeroNonNaNFinite<f64>

fn eq(&self, other: &StrictlyPositiveFinite<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite> for Positive<f64>

fn eq(&self, other: &StrictlyPositiveFinite<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite> for PositiveFinite<f64>

fn eq(&self, other: &StrictlyPositiveFinite<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite> for StrictlyNegative<f64>

fn eq(&self, other: &StrictlyPositiveFinite<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite> for StrictlyNegativeFinite<f64>

fn eq(&self, other: &StrictlyPositiveFinite<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite> for StrictlyPositive<f64>

fn eq(&self, other: &StrictlyPositiveFinite<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite> for f64

fn eq(&self, other: &StrictlyPositiveFinite<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<f32> for StrictlyPositiveFinite<f32>

fn eq(&self, other: &f32) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<f64> for StrictlyPositiveFinite<f64>

fn eq(&self, other: &f64) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for StrictlyPositiveFinite<f64>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for StrictlyPositiveFinite<f32>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<Negative<f32>> for StrictlyPositiveFinite<f32>

fn partial_cmp(&self, other: &Negative<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Negative> for StrictlyPositiveFinite<f64>

fn partial_cmp(&self, other: &Negative<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<NegativeFinite<f32>> for StrictlyPositiveFinite<f32>

fn partial_cmp(&self, other: &NegativeFinite<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<NegativeFinite> for StrictlyPositiveFinite<f64>

fn partial_cmp(&self, other: &NegativeFinite<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<NonNaN<f32>> for StrictlyPositiveFinite<f32>

fn partial_cmp(&self, other: &NonNaN<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<NonNaN> for StrictlyPositiveFinite<f64>

fn partial_cmp(&self, other: &NonNaN<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<NonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

fn partial_cmp(&self, other: &NonNaNFinite<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<NonNaNFinite> for StrictlyPositiveFinite<f64>

fn partial_cmp(&self, other: &NonNaNFinite<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>

fn partial_cmp(&self, other: &NonZeroNonNaN<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<NonZeroNonNaN> for StrictlyPositiveFinite<f64>

fn partial_cmp(&self, other: &NonZeroNonNaN<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<NonZeroNonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

fn partial_cmp(&self, other: &NonZeroNonNaNFinite<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<NonZeroNonNaNFinite> for StrictlyPositiveFinite<f64>

fn partial_cmp(&self, other: &NonZeroNonNaNFinite<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Positive<f32>> for StrictlyPositiveFinite<f32>

fn partial_cmp(&self, other: &Positive<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Positive> for StrictlyPositiveFinite<f64>

fn partial_cmp(&self, other: &Positive<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<PositiveFinite<f32>> for StrictlyPositiveFinite<f32>

fn partial_cmp(&self, other: &PositiveFinite<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<PositiveFinite> for StrictlyPositiveFinite<f64>

fn partial_cmp(&self, other: &PositiveFinite<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyNegative<f32>> for StrictlyPositiveFinite<f32>

fn partial_cmp(&self, other: &StrictlyNegative<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyNegative> for StrictlyPositiveFinite<f64>

fn partial_cmp(&self, other: &StrictlyNegative<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyNegativeFinite<f32>> for StrictlyPositiveFinite<f32>

fn partial_cmp(&self, other: &StrictlyNegativeFinite<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyNegativeFinite> for StrictlyPositiveFinite<f64>

fn partial_cmp(&self, other: &StrictlyNegativeFinite<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>

fn partial_cmp(&self, other: &StrictlyPositive<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositive> for StrictlyPositiveFinite<f64>

fn partial_cmp(&self, other: &StrictlyPositive<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite<f32>> for Negative<f32>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite<f32>> for NegativeFinite<f32>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite<f32>> for NonNaN<f32>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite<f32>> for NonNaNFinite<f32>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite<f32>> for NonZeroNonNaNFinite<f32>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite<f32>> for Positive<f32>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite<f32>> for PositiveFinite<f32>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite<f32>> for StrictlyNegative<f32>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite<f32>> for StrictlyNegativeFinite<f32>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite<f32>> for f32

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f32>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite> for Negative<f64>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite> for NegativeFinite<f64>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite> for NonNaN<f64>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite> for NonNaNFinite<f64>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite> for NonZeroNonNaN<f64>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite> for NonZeroNonNaNFinite<f64>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite> for Positive<f64>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite> for PositiveFinite<f64>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite> for StrictlyNegative<f64>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite> for StrictlyNegativeFinite<f64>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite> for StrictlyPositive<f64>

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositiveFinite> for f64

fn partial_cmp(&self, other: &StrictlyPositiveFinite<f64>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<f32> for StrictlyPositiveFinite<f32>

fn partial_cmp(&self, other: &f32) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<f64> for StrictlyPositiveFinite<f64>

fn partial_cmp(&self, other: &f64) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd for StrictlyPositiveFinite<f64>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd for StrictlyPositiveFinite<f32>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Powf<Negative<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying Powf::powf().

fn powf(self, rhs: Negative<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<Negative> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying Powf::powf().

fn powf(self, rhs: Negative<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<NegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying Powf::powf().

fn powf(self, rhs: NegativeFinite<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<NegativeFinite> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying Powf::powf().

fn powf(self, rhs: NegativeFinite<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<NonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying Powf::powf().

fn powf(self, rhs: NonNaN<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<NonNaN> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying Powf::powf().

fn powf(self, rhs: NonNaN<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<NonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying Powf::powf().

fn powf(self, rhs: NonNaNFinite<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<NonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying Powf::powf().

fn powf(self, rhs: NonNaNFinite<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying Powf::powf().

fn powf(self, rhs: NonZeroNonNaN<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<NonZeroNonNaN> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying Powf::powf().

fn powf(self, rhs: NonZeroNonNaN<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<NonZeroNonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying Powf::powf().

fn powf(self, rhs: NonZeroNonNaNFinite<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<NonZeroNonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying Powf::powf().

fn powf(self, rhs: NonZeroNonNaNFinite<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<Positive<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying Powf::powf().

fn powf(self, rhs: Positive<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<Positive> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying Powf::powf().

fn powf(self, rhs: Positive<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<PositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying Powf::powf().

fn powf(self, rhs: PositiveFinite<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<PositiveFinite> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying Powf::powf().

fn powf(self, rhs: PositiveFinite<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyNegative<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyNegative<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyNegative> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyNegative<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyNegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyNegativeFinite<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyNegativeFinite> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyNegativeFinite<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositive<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositive> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositive<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite<f32>> for Negative<f32>

type Output = f32

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite<f32>> for NegativeFinite<f32>

type Output = f32

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite<f32>> for NonNaN<f32>

type Output = f32

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite<f32>> for NonNaNFinite<f32>

type Output = f32

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>

type Output = f32

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite<f32>> for NonZeroNonNaNFinite<f32>

type Output = f32

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite<f32>> for Positive<f32>

type Output = Positive<f32>

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite<f32>> for PositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite<f32>> for StrictlyNegative<f32>

type Output = f32

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite<f32>> for StrictlyNegativeFinite<f32>

type Output = f32

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>

type Output = Positive<f32>

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = Positive<f32>

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite> for Negative<f64>

type Output = f64

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite> for NegativeFinite<f64>

type Output = f64

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite> for NonNaN<f64>

type Output = f64

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite> for NonNaNFinite<f64>

type Output = f64

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite> for NonZeroNonNaN<f64>

type Output = f64

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite> for NonZeroNonNaNFinite<f64>

type Output = f64

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite> for Positive<f64>

type Output = Positive

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite> for PositiveFinite<f64>

type Output = Positive

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite> for StrictlyNegative<f64>

type Output = f64

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite> for StrictlyNegativeFinite<f64>

type Output = f64

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite> for StrictlyPositive<f64>

type Output = Positive

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

See f64::powf() for more details.

impl Powf<StrictlyPositiveFinite> for StrictlyPositiveFinite<f64>

type Output = Positive

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

See f64::powf() for more details.

impl Rem<Negative<f32>> for StrictlyPositiveFinite<f32>

type Output = f32

The resulting type after applying the % operator.

fn rem(self, rhs: Negative<f32>) -> Self::Output

Performs the % operation.

impl Rem<Negative> for StrictlyPositiveFinite<f64>

type Output = f64

The resulting type after applying the % operator.

fn rem(self, rhs: Negative<f64>) -> Self::Output

Performs the % operation.

impl Rem<NegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = f32

The resulting type after applying the % operator.

fn rem(self, rhs: NegativeFinite<f32>) -> Self::Output

Performs the % operation.

impl Rem<NegativeFinite> for StrictlyPositiveFinite<f64>

type Output = f64

The resulting type after applying the % operator.

fn rem(self, rhs: NegativeFinite<f64>) -> Self::Output

Performs the % operation.

impl Rem<NonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = f32

The resulting type after applying the % operator.

fn rem(self, rhs: NonNaN<f32>) -> Self::Output

Performs the % operation.

impl Rem<NonNaN> for StrictlyPositiveFinite<f64>

type Output = f64

The resulting type after applying the % operator.

fn rem(self, rhs: NonNaN<f64>) -> Self::Output

Performs the % operation.

impl Rem<NonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = f32

The resulting type after applying the % operator.

fn rem(self, rhs: NonNaNFinite<f32>) -> Self::Output

Performs the % operation.

impl Rem<NonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = f64

The resulting type after applying the % operator.

fn rem(self, rhs: NonNaNFinite<f64>) -> Self::Output

Performs the % operation.

impl Rem<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = PositiveFinite<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: NonZeroNonNaN<f32>) -> Self::Output

Performs the % operation.

impl Rem<NonZeroNonNaN> for StrictlyPositiveFinite<f64>

type Output = PositiveFinite

The resulting type after applying the % operator.

fn rem(self, rhs: NonZeroNonNaN<f64>) -> Self::Output

Performs the % operation.

impl Rem<NonZeroNonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = PositiveFinite<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: NonZeroNonNaNFinite<f32>) -> Self::Output

Performs the % operation.

impl Rem<NonZeroNonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = PositiveFinite

The resulting type after applying the % operator.

fn rem(self, rhs: NonZeroNonNaNFinite<f64>) -> Self::Output

Performs the % operation.

impl Rem<Positive<f32>> for StrictlyPositiveFinite<f32>

type Output = f32

The resulting type after applying the % operator.

fn rem(self, rhs: Positive<f32>) -> Self::Output

Performs the % operation.

impl Rem<Positive> for StrictlyPositiveFinite<f64>

type Output = f64

The resulting type after applying the % operator.

fn rem(self, rhs: Positive<f64>) -> Self::Output

Performs the % operation.

impl Rem<PositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = f32

The resulting type after applying the % operator.

fn rem(self, rhs: PositiveFinite<f32>) -> Self::Output

Performs the % operation.

impl Rem<PositiveFinite> for StrictlyPositiveFinite<f64>

type Output = f64

The resulting type after applying the % operator.

fn rem(self, rhs: PositiveFinite<f64>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyNegative<f32>> for StrictlyPositiveFinite<f32>

type Output = PositiveFinite<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyNegative<f32>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyNegative> for StrictlyPositiveFinite<f64>

type Output = PositiveFinite

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyNegative<f64>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyNegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = PositiveFinite<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyNegativeFinite<f32>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyNegativeFinite> for StrictlyPositiveFinite<f64>

type Output = PositiveFinite

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyNegativeFinite<f64>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>

type Output = PositiveFinite<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositive<f32>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositive> for StrictlyPositiveFinite<f64>

type Output = PositiveFinite

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositive<f64>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite<f32>> for Negative<f32>

type Output = f32

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite<f32>> for NegativeFinite<f32>

type Output = NegativeFinite<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite<f32>> for NonNaN<f32>

type Output = f32

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite<f32>> for NonNaNFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>

type Output = f32

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite<f32>> for NonZeroNonNaNFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite<f32>> for Positive<f32>

type Output = f32

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite<f32>> for PositiveFinite<f32>

type Output = PositiveFinite<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite<f32>> for StrictlyNegative<f32>

type Output = f32

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite<f32>> for StrictlyNegativeFinite<f32>

type Output = NegativeFinite<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>

type Output = f32

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite> for Negative<f64>

type Output = f64

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite> for NegativeFinite<f64>

type Output = NegativeFinite

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite> for NonNaN<f64>

type Output = f64

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite> for NonNaNFinite<f64>

type Output = NonNaNFinite

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite> for NonZeroNonNaN<f64>

type Output = f64

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite> for NonZeroNonNaNFinite<f64>

type Output = NonNaNFinite

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite> for Positive<f64>

type Output = f64

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite> for PositiveFinite<f64>

type Output = PositiveFinite

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite> for StrictlyNegative<f64>

type Output = f64

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite> for StrictlyNegativeFinite<f64>

type Output = NegativeFinite

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the % operation.

impl Rem<StrictlyPositiveFinite> for StrictlyPositive<f64>

type Output = f64

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the % operation.

impl Rem for StrictlyPositiveFinite<f64>

type Output = PositiveFinite

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the % operation.

impl Rem for StrictlyPositiveFinite<f32>

type Output = PositiveFinite<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the % operation.

impl RemAssign<StrictlyPositiveFinite<f32>> for NegativeFinite<f32>

fn rem_assign(&mut self, rhs: StrictlyPositiveFinite<f32>)

Performs the %= operation.

impl RemAssign<StrictlyPositiveFinite<f32>> for NonNaNFinite<f32>

fn rem_assign(&mut self, rhs: StrictlyPositiveFinite<f32>)

Performs the %= operation.

impl RemAssign<StrictlyPositiveFinite<f32>> for PositiveFinite<f32>

fn rem_assign(&mut self, rhs: StrictlyPositiveFinite<f32>)

Performs the %= operation.

impl RemAssign<StrictlyPositiveFinite> for NegativeFinite<f64>

fn rem_assign(&mut self, rhs: StrictlyPositiveFinite<f64>)

Performs the %= operation.

impl RemAssign<StrictlyPositiveFinite> for NonNaNFinite<f64>

fn rem_assign(&mut self, rhs: StrictlyPositiveFinite<f64>)

Performs the %= operation.

impl RemAssign<StrictlyPositiveFinite> for PositiveFinite<f64>

fn rem_assign(&mut self, rhs: StrictlyPositiveFinite<f64>)

Performs the %= operation.

impl<T> Serialize for StrictlyPositiveFinite<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub<Negative<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: Negative<f32>) -> Self::Output

Performs the - operation.

impl Sub<Negative> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying the - operator.

fn sub(self, rhs: Negative<f64>) -> Self::Output

Performs the - operation.

impl Sub<NegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: NegativeFinite<f32>) -> Self::Output

Performs the - operation.

impl Sub<NegativeFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying the - operator.

fn sub(self, rhs: NegativeFinite<f64>) -> Self::Output

Performs the - operation.

impl Sub<NonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: NonNaN<f32>) -> Self::Output

Performs the - operation.

impl Sub<NonNaN> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the - operator.

fn sub(self, rhs: NonNaN<f64>) -> Self::Output

Performs the - operation.

impl Sub<NonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: NonNaNFinite<f32>) -> Self::Output

Performs the - operation.

impl Sub<NonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the - operator.

fn sub(self, rhs: NonNaNFinite<f64>) -> Self::Output

Performs the - operation.

impl Sub<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroNonNaN<f32>) -> Self::Output

Performs the - operation.

impl Sub<NonZeroNonNaN> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroNonNaN<f64>) -> Self::Output

Performs the - operation.

impl Sub<NonZeroNonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroNonNaNFinite<f32>) -> Self::Output

Performs the - operation.

impl Sub<NonZeroNonNaNFinite> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroNonNaNFinite<f64>) -> Self::Output

Performs the - operation.

impl Sub<Positive<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: Positive<f32>) -> Self::Output

Performs the - operation.

impl Sub<Positive> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the - operator.

fn sub(self, rhs: Positive<f64>) -> Self::Output

Performs the - operation.

impl Sub<PositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: PositiveFinite<f32>) -> Self::Output

Performs the - operation.

impl Sub<PositiveFinite> for StrictlyPositiveFinite<f64>

type Output = NonNaNFinite

The resulting type after applying the - operator.

fn sub(self, rhs: PositiveFinite<f64>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyNegative<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyNegative<f32>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyNegative> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyNegative<f64>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyNegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Output = StrictlyPositive<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyNegativeFinite<f32>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyNegativeFinite> for StrictlyPositiveFinite<f64>

type Output = StrictlyPositive

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyNegativeFinite<f64>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositive<f32>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositive> for StrictlyPositiveFinite<f64>

type Output = NonNaN

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositive<f64>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite<f32>> for Negative<f32>

type Output = StrictlyNegative<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite<f32>> for NegativeFinite<f32>

type Output = StrictlyNegative<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite<f32>> for NonNaN<f32>

type Output = NonNaN<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite<f32>> for NonNaNFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite<f32>> for NonZeroNonNaN<f32>

type Output = NonNaN<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite<f32>> for NonZeroNonNaNFinite<f32>

type Output = NonNaN<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite<f32>> for Positive<f32>

type Output = NonNaN<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite<f32>> for PositiveFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite<f32>> for StrictlyNegative<f32>

type Output = StrictlyNegative<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite<f32>> for StrictlyNegativeFinite<f32>

type Output = StrictlyNegative<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite<f32>> for StrictlyPositive<f32>

type Output = NonNaN<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite> for Negative<f64>

type Output = StrictlyNegative

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite> for NegativeFinite<f64>

type Output = StrictlyNegative

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite> for NonNaN<f64>

type Output = NonNaN

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite> for NonNaNFinite<f64>

type Output = NonNaN

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite> for NonZeroNonNaN<f64>

type Output = NonNaN

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite> for NonZeroNonNaNFinite<f64>

type Output = NonNaN

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite> for Positive<f64>

type Output = NonNaN

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite> for PositiveFinite<f64>

type Output = NonNaNFinite

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite> for StrictlyNegative<f64>

type Output = StrictlyNegative

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite> for StrictlyNegativeFinite<f64>

type Output = StrictlyNegative

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the - operation.

impl Sub<StrictlyPositiveFinite> for StrictlyPositive<f64>

type Output = NonNaN

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the - operation.

impl Sub for StrictlyPositiveFinite<f64>

type Output = NonNaNFinite

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f64>) -> Self::Output

Performs the - operation.

impl Sub for StrictlyPositiveFinite<f32>

type Output = NonNaNFinite<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositiveFinite<f32>) -> Self::Output

Performs the - operation.

impl SubAssign<StrictlyPositiveFinite<f32>> for Negative<f32>

fn sub_assign(&mut self, rhs: StrictlyPositiveFinite<f32>)

Performs the -= operation.

impl SubAssign<StrictlyPositiveFinite<f32>> for NonNaN<f32>

fn sub_assign(&mut self, rhs: StrictlyPositiveFinite<f32>)

Performs the -= operation.

impl SubAssign<StrictlyPositiveFinite<f32>> for StrictlyNegative<f32>

fn sub_assign(&mut self, rhs: StrictlyPositiveFinite<f32>)

Performs the -= operation.

impl SubAssign<StrictlyPositiveFinite> for Negative<f64>

fn sub_assign(&mut self, rhs: StrictlyPositiveFinite<f64>)

Performs the -= operation.

impl SubAssign<StrictlyPositiveFinite> for NonNaN<f64>

fn sub_assign(&mut self, rhs: StrictlyPositiveFinite<f64>)

Performs the -= operation.

impl SubAssign<StrictlyPositiveFinite> for StrictlyNegative<f64>

fn sub_assign(&mut self, rhs: StrictlyPositiveFinite<f64>)

Performs the -= operation.

impl TryFrom<Negative<f32>> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: Negative<f32>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Negative> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: Negative<f64>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NegativeFinite<f32>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NegativeFinite> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NegativeFinite<f64>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonNaN<f32>> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonNaN<f32>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonNaN> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonNaN<f64>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonNaNFinite<f32>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonNaNFinite> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonNaNFinite<f64>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonZero<i16>> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonZeroI16) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonZero<i16>> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonZeroI16) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonZero<i32>> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonZeroI32) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonZero<i32>> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonZeroI32) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonZero<i64>> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonZeroI64) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonZero<i64>> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonZeroI64) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonZero<i8>> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonZeroI8) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonZero<i8>> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonZeroI8) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonZeroNonNaN<f32>> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonZeroNonNaN<f32>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonZeroNonNaN> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonZeroNonNaN<f64>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonZeroNonNaNFinite<f32>> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonZeroNonNaNFinite<f32>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonZeroNonNaNFinite> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonZeroNonNaNFinite<f64>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Positive<f32>> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: Positive<f32>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Positive> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: Positive<f64>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<PositiveFinite<f32>> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: PositiveFinite<f32>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<PositiveFinite> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: PositiveFinite<f64>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<StrictlyNegative<f32>> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: StrictlyNegative<f32>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<StrictlyNegative> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: StrictlyNegative<f64>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<StrictlyNegativeFinite<f32>> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: StrictlyNegativeFinite<f32>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<StrictlyNegativeFinite> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: StrictlyNegativeFinite<f64>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<StrictlyPositive<f32>> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: StrictlyPositive<f32>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<StrictlyPositive> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: StrictlyPositive<f64>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<StrictlyPositiveFinite<f32>> for Negative<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: StrictlyPositiveFinite<f32>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<StrictlyPositiveFinite<f32>> for NegativeFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: StrictlyPositiveFinite<f32>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<StrictlyPositiveFinite<f32>> for StrictlyNegative<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: StrictlyPositiveFinite<f32>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<StrictlyPositiveFinite<f32>> for StrictlyNegativeFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: StrictlyPositiveFinite<f32>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<StrictlyPositiveFinite> for Negative<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: StrictlyPositiveFinite<f64>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<StrictlyPositiveFinite> for NegativeFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: StrictlyPositiveFinite<f64>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<StrictlyPositiveFinite> for StrictlyNegative<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: StrictlyPositiveFinite<f64>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<StrictlyPositiveFinite> for StrictlyNegativeFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: StrictlyPositiveFinite<f64>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<f32> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: f32) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<f64> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: f64) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<i16> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: i16) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<i16> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: i16) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<i32> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: i32) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<i32> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: i32) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<i64> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: i64) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<i64> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: i64) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<i8> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: i8) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<i8> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: i8) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u16> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: u16) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u16> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: u16) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u32> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: u32) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u32> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: u32) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u64> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: u64) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u64> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: u64) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u8> for StrictlyPositiveFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: u8) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u8> for StrictlyPositiveFinite<f32>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: u8) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: Copy> Copy for StrictlyPositiveFinite<T>

impl Eq for StrictlyPositiveFinite<f64>

impl Eq for StrictlyPositiveFinite<f32>