Type Alias NegativeFinite 

pub type NegativeFinite = NegativeFinite<f64>;

Equivalent to NegativeFinite<f64>

Aliased Type

pub struct NegativeFinite(/* private fields */);

Implementations

impl NegativeFinite

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 NegativeFinite<f64>

pub const 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 = NegativeFinite::new(-3.0).unwrap();

assert_eq!(x, -3.0);

Errors

Returns an error if the value is not valid

pub const 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 { NegativeFinite::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::NegativeFinite;

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

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

See f64::is_finite() for more details.

pub const fn is_subnormal(&self) -> bool

Returns true if the number is subnormal.

Examples

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

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

See f64::is_subnormal() for more details.

pub const fn is_normal(&self) -> bool

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

Examples

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

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

See f64::is_normal() for more details.

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

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

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

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

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

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

pub const fn is_positive_zero(&self) -> bool

Returns true if the number is positive zero.

Examples

use typed_floats::tf64::NegativeFinite;
let x: NegativeFinite = (-3.0).try_into().unwrap();
let y: NegativeFinite = (-0.0).try_into().unwrap();

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

impl NegativeFinite<f64>

pub const fn abs(self) -> PositiveFinite<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 NegativeFinite<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 NegativeFinite<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 NegativeFinite<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 NegativeFinite<f64>

pub fn asinh(self) -> Negative<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 NegativeFinite<f64>

pub fn atan(self) -> NegativeFinite<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 NegativeFinite<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 NegativeFinite<f64>

pub fn cbrt(self) -> NegativeFinite<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 NegativeFinite<f64>

pub fn ceil(self) -> NegativeFinite<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 NegativeFinite<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 NegativeFinite<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 NegativeFinite<f64>

pub fn exp2(self) -> PositiveFinite<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 NegativeFinite<f64>

pub fn exp(self) -> PositiveFinite<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 NegativeFinite<f64>

pub fn exp_m1(self) -> NegativeFinite<f64>

Returns e^(self) - 1 in a way that is accurate even if the number is close to zero.

Examples

assert_is_positive_zero!(tf64::ZERO.exp_m1());
assert_is_negative_zero!(tf64::NEG_ZERO.exp_m1());

assert_eq!(tf64::INFINITY.exp_m1(), f64::INFINITY);
assert_eq!(tf64::NEG_INFINITY.exp_m1(), -1.0);

See f64::exp_m1() for more details.

impl NegativeFinite<f64>

pub fn floor(self) -> NegativeFinite<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 NegativeFinite<f64>

pub fn fract(self) -> NonNaNFinite<f64>

Returns the fractional part of self. For negative numbers, the result is negative except when the fractional part is zero. For INFINITY 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 NegativeFinite<f64>

pub fn ln(self) -> f64

Returns the natural logarithm of the number.

Returns NaN if self is a negative number other than -0.0.

Examples

let a: NonNaN = 1.0.try_into().unwrap();
let b: NonNaN = (-1.0).try_into().unwrap();

assert_eq!(a.ln(), 0.0);
assert_is_nan!(b.ln());

assert_eq!(tf64::ZERO.ln(), f64::NEG_INFINITY);
assert_eq!(tf64::NEG_ZERO.ln(), f64::NEG_INFINITY);

assert_eq!(tf64::INFINITY.ln(), tf64::INFINITY);
assert_is_nan!(tf64::NEG_INFINITY.ln());

See f64::ln() for more details.

impl NegativeFinite<f64>

pub fn ln_1p(self) -> f64

Returns ln(1+n) (natural logarithm) more accurately than if the operations were performed separately.

Examples

let a: NonNaN = (-1.0).try_into().unwrap();

assert_eq!(a.ln_1p(), f64::NEG_INFINITY);

assert!(tf64::is_positive_zero(tf64::ZERO.ln_1p().get()));
assert!(tf64::is_negative_zero(tf64::NEG_ZERO.ln_1p()));

assert_eq!(tf64::INFINITY.ln_1p(), f64::INFINITY);
assert_is_nan!(tf64::NEG_INFINITY.ln_1p());

See f64::ln_1p() for more details.

impl NegativeFinite<f64>

pub fn log10(self) -> f64

Returns the base 10 logarithm of the number.

Returns NaN if self is a negative number other than -0.0.

Examples

let a: NonNaN = 100.0.try_into().unwrap();
let b: NonNaN = 1.0.try_into().unwrap();
let c: NonNaN = (-1.0).try_into().unwrap();

assert_eq!(a.log10(), 2.0);
assert_eq!(b.log10(), 0.0);
assert_is_nan!(c.log10());

assert_eq!(tf64::ZERO.log10(), f64::NEG_INFINITY);
assert_eq!(tf64::NEG_ZERO.log10(), f64::NEG_INFINITY);

assert_eq!(tf64::INFINITY.log10(), tf64::INFINITY);
assert_is_nan!(tf64::NEG_INFINITY.log10());

See f64::log10() for more details.

impl NegativeFinite<f64>

pub fn log2(self) -> f64

Returns the base 2 logarithm of the number.

Returns NaN if self is a negative number other than -0.0.

Examples

let a: NonNaN = 2.0.try_into().unwrap();
let b: NonNaN = 1.0.try_into().unwrap();
let c: NonNaN = (-1.0).try_into().unwrap();

assert_eq!(a.log2(), 1.0);
assert!(tf64::is_positive_zero(b.log2()));
assert_is_nan!(c.log2());

assert_eq!(tf64::ZERO.log2(), f64::NEG_INFINITY);
assert_eq!(tf64::NEG_ZERO.log2(), f64::NEG_INFINITY);

assert_eq!(tf64::INFINITY.log2(), tf64::INFINITY);
assert_is_nan!(tf64::NEG_INFINITY.log2());

See f64::log2() for more details.

impl NegativeFinite<f64>

pub fn next_down(self) -> StrictlyNegative<f64>

Returns the greatest number less than `self``.

See f64::next_down() for more details.

impl NegativeFinite<f64>

pub fn next_up(self) -> NonNaNFinite<f64>

Returns the least number greater than `self``.

See f64::next_up() for more details.

impl NegativeFinite<f64>

pub fn powi(self, n: i32) -> NonNaN<f64>

Raises a number to an integer power.

Using this function is generally faster than using powf. It might have a different sequence of rounding operations than powf, so the results are not guaranteed to agree.

Examples

let x: NonNaN = (-2.0).try_into().unwrap();

assert_eq!(x.powi(3), -8.0);
assert_eq!(x.powi(2), 4.0);
assert_eq!(x.powi(1), -2.0);
assert_eq!(x.powi(0), 1.0);
assert_eq!(x.powi(-1), -0.5);
assert_eq!(x.powi(-2), 0.25);
assert_eq!(x.powi(-3), -0.125);

See f64::powi() for more details.

impl NegativeFinite<f64>

pub const fn recip(self) -> StrictlyNegative<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();
let c: StrictlyPositiveFinite = (5e-324).try_into().unwrap();

assert_eq!(a.recip(), 1.0);
assert_eq!(b.recip(), -1.0);
assert_eq!(c.recip(), tf64::INFINITY);

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 NegativeFinite<f64>

pub fn round(self) -> NegativeFinite<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 NegativeFinite<f64>

pub const fn signum(self) -> StrictlyNegativeFinite<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 NegativeFinite<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 NegativeFinite<f64>

pub fn sinh(self) -> Negative<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 NegativeFinite<f64>

pub fn sqrt(self) -> f64

Returns the square root of a number.

Returns NaN if self is a negative number other than -0.0. Returns -0.0 if self is -0.0.

Examples

let a: NonNaN = 25.0.try_into().unwrap();
let b: NonNaN = (-1).try_into().unwrap();

assert_eq!(a.sqrt(), 5.0);
assert_is_nan!(b.sqrt());

assert!(tf64::is_positive_zero(tf64::ZERO.sqrt().into()));
assert!(tf64::is_negative_zero(tf64::NEG_ZERO.sqrt()));

assert_eq!(tf64::INFINITY.sqrt(), tf64::INFINITY);
assert_is_nan!(tf64::NEG_INFINITY.sqrt());

See f64::sqrt() for more details.

impl NegativeFinite<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 NegativeFinite<f64>

pub fn tanh(self) -> NegativeFinite<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 NegativeFinite<f64>

pub const fn to_degrees(self) -> Negative<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 NegativeFinite<f64>

pub const fn to_radians(self) -> NegativeFinite<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();
let e: StrictlyPositiveFinite = (5e-324).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!(e.to_radians(), 0.0);

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 NegativeFinite<f64>

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

Trait Implementations

impl Add<Negative> for NegativeFinite<f64>

type Output = Negative

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNaN> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<f64>

type Output = NonNaN

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<PositiveFinite> for NegativeFinite<f64>

type Output = NonNaNFinite

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<StrictlyNegative> for NegativeFinite<f64>

type Output = StrictlyNegative

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<StrictlyNegativeFinite> for NegativeFinite<f64>

type Output = StrictlyNegative

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<StrictlyPositive> for NegativeFinite<f64>

type Output = NonNaN

The resulting type after applying the + operator.

fn add(self, rhs: StrictlyPositive<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 for NegativeFinite<f64>

type Output = Negative

The resulting type after applying the + operator.

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

Performs the + operation.

impl Atan2<Negative> for NegativeFinite<f64>

type Output = NegativeFinite

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> for NegativeFinite<f64>

type Output = NegativeFinite

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> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<f64>

type Output = NonNaNFinite

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> for NegativeFinite<f64>

type Output = NonNaNFinite

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> for NegativeFinite<f64>

type Output = NegativeFinite

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> for NegativeFinite<f64>

type Output = NegativeFinite

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> for NegativeFinite<f64>

type Output = NonNaNFinite

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> 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<T: Clone> Clone for NegativeFinite<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copysign<Negative> for NegativeFinite<f64>

type Output = NegativeFinite

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> for NegativeFinite<f64>

type Output = NegativeFinite

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> for NegativeFinite<f64>

type Output = NonNaNFinite

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> for NegativeFinite<f64>

type Output = NonNaNFinite

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> for NegativeFinite<f64>

type Output = NonNaNFinite

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> for NegativeFinite<f64>

type Output = NonNaNFinite

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> for NegativeFinite<f64>

type Output = PositiveFinite

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> for NegativeFinite<f64>

type Output = PositiveFinite

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> for NegativeFinite<f64>

type Output = NegativeFinite

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> for NegativeFinite<f64>

type Output = NegativeFinite

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> for NegativeFinite<f64>

type Output = PositiveFinite

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> 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<T: Debug> Debug for NegativeFinite<T>

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

Formats the value using the given formatter.

impl Default for NegativeFinite<f64>

fn default() -> Self

Returns the “default value” for a type.

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

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for NegativeFinite<f64>

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

Formats the value using the given formatter.

impl Div<Negative> for NegativeFinite<f64>

type Output = f64

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNaN> for NegativeFinite<f64>

type Output = f64

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNaNFinite> for NegativeFinite<f64>

type Output = f64

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonZeroNonNaN> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<f64>

type Output = f64

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<PositiveFinite> for NegativeFinite<f64>

type Output = f64

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<StrictlyNegative> for NegativeFinite<f64>

type Output = Positive

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<StrictlyNegativeFinite> for NegativeFinite<f64>

type Output = Positive

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<StrictlyPositive> for NegativeFinite<f64>

type Output = Negative

The resulting type after applying the / operator.

fn div(self, rhs: StrictlyPositive<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 for NegativeFinite<f64>

type Output = f64

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivEuclid<Negative> for NegativeFinite<f64>

type Output = f64

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> for NegativeFinite<f64>

type Output = f64

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> for NegativeFinite<f64>

type Output = f64

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> for NegativeFinite<f64>

type Output = f64

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> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<f64>

type Output = f64

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> for NegativeFinite<f64>

type Output = f64

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> for NegativeFinite<f64>

type Output = Positive

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> for NegativeFinite<f64>

type Output = Positive

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> for NegativeFinite<f64>

type Output = Negative

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> 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 From<StrictlyNegativeFinite> for NegativeFinite<f64>

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

Converts to this type from the input type.

impl FromStr for NegativeFinite<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 Hash for NegativeFinite<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 Hypot<Negative> for NegativeFinite<f64>

type Output = Positive

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> for NegativeFinite<f64>

type Output = Positive

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> for NegativeFinite<f64>

type Output = Positive

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> for NegativeFinite<f64>

type Output = Positive

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> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<f64>

type Output = Positive

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> for NegativeFinite<f64>

type Output = Positive

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> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<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> 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 Max<Negative> for NegativeFinite<f64>

type Output = NegativeFinite

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> for NegativeFinite<f64>

type Output = NegativeFinite

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> for NegativeFinite<f64>

type Output = NonNaN

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> for NegativeFinite<f64>

type Output = NonNaNFinite

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> for NegativeFinite<f64>

type Output = NonNaN

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> for NegativeFinite<f64>

type Output = NonNaNFinite

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> for NegativeFinite<f64>

type Output = NonNaN

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> for NegativeFinite<f64>

type Output = NonNaNFinite

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> for NegativeFinite<f64>

type Output = NegativeFinite

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> for NegativeFinite<f64>

type Output = NegativeFinite

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> for NegativeFinite<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> 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 Midpoint<Negative> for NegativeFinite<f64>

type Output = Negative

The resulting type after applying Midpoint::midpoint().

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

See f64::midpoint() for more details.

impl Midpoint<NegativeFinite> for NegativeFinite<f64>

type Output = NegativeFinite

The resulting type after applying Midpoint::midpoint().

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

See f64::midpoint() for more details.

impl Midpoint<NonNaN> for NegativeFinite<f64>

type Output = NonNaN

The resulting type after applying Midpoint::midpoint().

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

See f64::midpoint() for more details.

impl Midpoint<NonNaNFinite> for NegativeFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Midpoint::midpoint().

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

See f64::midpoint() for more details.

impl Midpoint<NonZeroNonNaN> for NegativeFinite<f64>

type Output = NonNaN

The resulting type after applying Midpoint::midpoint().

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

See f64::midpoint() for more details.

impl Midpoint<NonZeroNonNaNFinite> for NegativeFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Midpoint::midpoint().

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

See f64::midpoint() for more details.

impl Midpoint<Positive> for NegativeFinite<f64>

type Output = NonNaN

The resulting type after applying Midpoint::midpoint().

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

See f64::midpoint() for more details.

impl Midpoint<PositiveFinite> for NegativeFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Midpoint::midpoint().

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

See f64::midpoint() for more details.

impl Midpoint<StrictlyNegative> for NegativeFinite<f64>

type Output = Negative

The resulting type after applying Midpoint::midpoint().

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

See f64::midpoint() for more details.

impl Midpoint<StrictlyNegativeFinite> for NegativeFinite<f64>

type Output = NegativeFinite

The resulting type after applying Midpoint::midpoint().

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

See f64::midpoint() for more details.

impl Midpoint<StrictlyPositive> for NegativeFinite<f64>

type Output = NonNaN

The resulting type after applying Midpoint::midpoint().

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

See f64::midpoint() for more details.

impl Midpoint<StrictlyPositiveFinite> for NegativeFinite<f64>

type Output = NonNaNFinite

The resulting type after applying Midpoint::midpoint().

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

See f64::midpoint() for more details.

impl Min<Negative> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<f64>

type Output = NonNaN

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> for NegativeFinite<f64>

type Output = NonNaNFinite

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> for NegativeFinite<f64>

type Output = NonNaNFinite

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> for NegativeFinite<f64>

type Output = NonNaNFinite

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> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<f64>

type Output = NonNaNFinite

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> 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 Mul<Negative> for NegativeFinite<f64>

type Output = f64

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNaN> for NegativeFinite<f64>

type Output = f64

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNaNFinite> for NegativeFinite<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> for NegativeFinite<f64>

type Output = f64

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonZeroNonNaNFinite> for NegativeFinite<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> for NegativeFinite<f64>

type Output = f64

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<PositiveFinite> for NegativeFinite<f64>

type Output = Negative

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<StrictlyNegative> for NegativeFinite<f64>

type Output = f64

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<StrictlyNegativeFinite> for NegativeFinite<f64>

type Output = Positive

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<StrictlyPositive> for NegativeFinite<f64>

type Output = f64

The resulting type after applying the * operator.

fn mul(self, rhs: StrictlyPositive<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 for NegativeFinite<f64>

type Output = Positive

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for NegativeFinite<f64>

type Output = PositiveFinite

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Ord for NegativeFinite<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,

Restrict a value to a certain interval.

impl PartialEq<Negative> for NegativeFinite<f64>

fn eq(&self, other: &Negative<f64>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<NonNaN> for NegativeFinite<f64>

fn eq(&self, other: &NonNaN<f64>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<NonNaNFinite> for NegativeFinite<f64>

fn eq(&self, other: &NonNaNFinite<f64>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<NonZeroNonNaN> for NegativeFinite<f64>

fn eq(&self, other: &NonZeroNonNaN<f64>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<NonZeroNonNaNFinite> for NegativeFinite<f64>

fn eq(&self, other: &NonZeroNonNaNFinite<f64>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Positive> for NegativeFinite<f64>

fn eq(&self, other: &Positive<f64>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<PositiveFinite> for NegativeFinite<f64>

fn eq(&self, other: &PositiveFinite<f64>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyNegative> for NegativeFinite<f64>

fn eq(&self, other: &StrictlyNegative<f64>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyNegativeFinite> for NegativeFinite<f64>

fn eq(&self, other: &StrictlyNegativeFinite<f64>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositive> for NegativeFinite<f64>

fn eq(&self, other: &StrictlyPositive<f64>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<StrictlyPositiveFinite> for NegativeFinite<f64>

fn eq(&self, other: &StrictlyPositiveFinite<f64>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<f64> for NegativeFinite<f64>

fn eq(&self, other: &f64) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for NegativeFinite<f64>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<Negative> for NegativeFinite<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

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<NonNaN> for NegativeFinite<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

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<NonNaNFinite> for NegativeFinite<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

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<NonZeroNonNaN> for NegativeFinite<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

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<NonZeroNonNaNFinite> for NegativeFinite<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

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Positive> for NegativeFinite<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

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<PositiveFinite> for NegativeFinite<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

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyNegative> for NegativeFinite<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

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyNegativeFinite> for NegativeFinite<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

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<StrictlyPositive> for NegativeFinite<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

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

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

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<f64> for NegativeFinite<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

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd for NegativeFinite<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

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Powf<Negative> for NegativeFinite<f64>

type Output = f64

The resulting type after applying Powf::powf().

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

See f64::powf() for more details.

impl Powf<NegativeFinite> for NegativeFinite<f64>

type Output = f64

The resulting type after applying Powf::powf().

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

See f64::powf() for more details.

impl Powf<NonNaN> for NegativeFinite<f64>

type Output = f64

The resulting type after applying Powf::powf().

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

See f64::powf() for more details.

impl Powf<NonNaNFinite> for NegativeFinite<f64>

type Output = f64

The resulting type after applying Powf::powf().

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

See f64::powf() for more details.

impl Powf<NonZeroNonNaN> for NegativeFinite<f64>

type Output = f64

The resulting type after applying Powf::powf().

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

See f64::powf() for more details.

impl Powf<NonZeroNonNaNFinite> for NegativeFinite<f64>

type Output = f64

The resulting type after applying Powf::powf().

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

See f64::powf() for more details.

impl Powf<Positive> for NegativeFinite<f64>

type Output = f64

The resulting type after applying Powf::powf().

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

See f64::powf() for more details.

impl Powf<PositiveFinite> for NegativeFinite<f64>

type Output = f64

The resulting type after applying Powf::powf().

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

See f64::powf() for more details.

impl Powf<StrictlyNegative> for NegativeFinite<f64>

type Output = f64

The resulting type after applying Powf::powf().

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

See f64::powf() for more details.

impl Powf<StrictlyNegativeFinite> for NegativeFinite<f64>

type Output = f64

The resulting type after applying Powf::powf().

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

See f64::powf() for more details.

impl Powf<StrictlyPositive> for NegativeFinite<f64>

type Output = f64

The resulting type after applying Powf::powf().

fn powf(self, rhs: StrictlyPositive<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 Rem<Negative> for NegativeFinite<f64>

type Output = f64

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<NonNaN> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<f64>

type Output = NegativeFinite

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<NonZeroNonNaNFinite> for NegativeFinite<f64>

type Output = NegativeFinite

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<Positive> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<f64>

type Output = NegativeFinite

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<StrictlyNegativeFinite> for NegativeFinite<f64>

type Output = NegativeFinite

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<StrictlyPositive> for NegativeFinite<f64>

type Output = NegativeFinite

The resulting type after applying the % operator.

fn rem(self, rhs: StrictlyPositive<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 for NegativeFinite<f64>

type Output = f64

The resulting type after applying the % operator.

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

Performs the % operation.

impl RemAssign<NonZeroNonNaN> for NegativeFinite<f64>

fn rem_assign(&mut self, rhs: NonZeroNonNaN<f64>)

Performs the %= operation.

impl RemAssign<NonZeroNonNaNFinite> for NegativeFinite<f64>

fn rem_assign(&mut self, rhs: NonZeroNonNaNFinite<f64>)

Performs the %= operation.

impl RemAssign<StrictlyNegative> for NegativeFinite<f64>

fn rem_assign(&mut self, rhs: StrictlyNegative<f64>)

Performs the %= operation.

impl RemAssign<StrictlyNegativeFinite> for NegativeFinite<f64>

fn rem_assign(&mut self, rhs: StrictlyNegativeFinite<f64>)

Performs the %= operation.

impl RemAssign<StrictlyPositive> for NegativeFinite<f64>

fn rem_assign(&mut self, rhs: StrictlyPositive<f64>)

Performs the %= operation.

impl RemAssign<StrictlyPositiveFinite> for NegativeFinite<f64>

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

Performs the %= operation.

impl<T> Serialize for NegativeFinite<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> for NegativeFinite<f64>

type Output = NonNaN

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNaN> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<f64>

type Output = Negative

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<PositiveFinite> for NegativeFinite<f64>

type Output = Negative

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<StrictlyNegative> for NegativeFinite<f64>

type Output = NonNaN

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<StrictlyNegativeFinite> for NegativeFinite<f64>

type Output = NonNaNFinite

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<StrictlyPositive> for NegativeFinite<f64>

type Output = StrictlyNegative

The resulting type after applying the - operator.

fn sub(self, rhs: StrictlyPositive<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 for NegativeFinite<f64>

type Output = NonNaNFinite

The resulting type after applying the - operator.

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

Performs the - operation.

impl TryFrom<Negative> for NegativeFinite<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<NonNaN> for NegativeFinite<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> for NegativeFinite<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 NegativeFinite<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<i32>> for NegativeFinite<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<i64>> for NegativeFinite<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<i8>> for NegativeFinite<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<u16>> for NegativeFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonZeroU16) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonZero<u32>> for NegativeFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonZeroU32) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonZero<u64>> for NegativeFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonZeroU64) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonZero<u8>> for NegativeFinite<f64>

type Error = InvalidNumber

The type returned in the event of a conversion error.

fn try_from(value: NonZeroU8) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NonZeroNonNaN> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<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> for NegativeFinite<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<StrictlyPositive> for NegativeFinite<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> 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<f64> for NegativeFinite<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 NegativeFinite<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<i32> for NegativeFinite<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<i64> for NegativeFinite<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<i8> for NegativeFinite<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<u16> for NegativeFinite<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<u32> for NegativeFinite<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<u64> for NegativeFinite<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<u8> for NegativeFinite<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<T: Copy> Copy for NegativeFinite<T>

impl Eq for NegativeFinite<f64>