reason = "stable interface is via `impl f{32,64}` in later crates",
issue = "32110")]
impl Float for f64 {
- #[inline]
- fn nan() -> f64 {
- NAN
- }
-
- #[inline]
- fn infinity() -> f64 {
- INFINITY
- }
-
- #[inline]
- fn neg_infinity() -> f64 {
- NEG_INFINITY
- }
-
- #[inline]
- fn zero() -> f64 {
- 0.0
- }
-
- #[inline]
- fn neg_zero() -> f64 {
- -0.0
- }
-
- #[inline]
- fn one() -> f64 {
- 1.0
- }
-
/// Returns `true` if the number is NaN.
#[inline]
fn is_nan(self) -> bool {
}
}
- /// Returns the mantissa, exponent and sign as integers.
- fn integer_decode(self) -> (u64, i16, i8) {
- let bits: u64 = unsafe { mem::transmute(self) };
- let sign: i8 = if bits >> 63 == 0 { 1 } else { -1 };
- let mut exponent: i16 = ((bits >> 52) & 0x7ff) as i16;
- let mantissa = if exponent == 0 {
- (bits & 0xfffffffffffff) << 1
- } else {
- (bits & 0xfffffffffffff) | 0x10000000000000
- };
- // Exponent bias + mantissa shift
- exponent -= 1023 + 52;
- (mantissa, exponent, sign)
- }
-
/// Computes the absolute value of `self`. Returns `Float::nan()` if the
/// number is `Float::nan()`.
#[inline]
let value: f64 = consts::PI;
self * (value / 180.0)
}
+
+ /// Returns the maximum of the two numbers.
+ #[inline]
+ fn max(self, other: f64) -> f64 {
+ // IEEE754 says: maxNum(x, y) is the canonicalized number y if x < y, x if y < x, the
+ // canonicalized number if one operand is a number and the other a quiet NaN. Otherwise it
+ // is either x or y, canonicalized (this means results might differ among implementations).
+ // When either x or y is a signalingNaN, then the result is according to 6.2.
+ //
+ // Since we do not support sNaN in Rust yet, we do not need to handle them.
+ // FIXME(nagisa): due to https://bugs.llvm.org/show_bug.cgi?id=33303 we canonicalize by
+ // multiplying by 1.0. Should switch to the `canonicalize` when it works.
+ (if self < other || self.is_nan() { other } else { self }) * 1.0
+ }
+
+ /// Returns the minimum of the two numbers.
+ #[inline]
+ fn min(self, other: f64) -> f64 {
+ // IEEE754 says: minNum(x, y) is the canonicalized number x if x < y, y if y < x, the
+ // canonicalized number if one operand is a number and the other a quiet NaN. Otherwise it
+ // is either x or y, canonicalized (this means results might differ among implementations).
+ // When either x or y is a signalingNaN, then the result is according to 6.2.
+ //
+ // Since we do not support sNaN in Rust yet, we do not need to handle them.
+ // FIXME(nagisa): due to https://bugs.llvm.org/show_bug.cgi?id=33303 we canonicalize by
+ // multiplying by 1.0. Should switch to the `canonicalize` when it works.
+ (if self < other || other.is_nan() { self } else { other }) * 1.0
+ }
}