//! Operations and constants for 64-bits floats (`f64` type)
-use default::Default;
+#![doc(primitive = "f64")]
+// FIXME: MIN_VALUE and MAX_VALUE literals are parsed as -inf and inf #14353
+#![allow(type_overflow)]
+
use intrinsics;
use mem;
use num::{FPNormal, FPCategory, FPZero, FPSubnormal, FPInfinite, FPNaN};
-use num::{Zero, One, Bounded, Signed, Num, Primitive, Float};
+use num::Float;
use option::Option;
-#[cfg(not(test))] use cmp::{Eq, Ord};
-#[cfg(not(test))] use ops::{Add, Sub, Mul, Div, Rem, Neg};
-
// FIXME(#5527): These constants should be deprecated once associated
// constants are implemented in favour of referencing the respective
// members of `Bounded` and `Float`.
pub static LN_10: f64 = 2.30258509299404568401799145468436421_f64;
}
-#[cfg(not(test))]
-impl Ord for f64 {
- #[inline]
- fn lt(&self, other: &f64) -> bool { (*self) < (*other) }
- #[inline]
- fn le(&self, other: &f64) -> bool { (*self) <= (*other) }
- #[inline]
- fn ge(&self, other: &f64) -> bool { (*self) >= (*other) }
- #[inline]
- fn gt(&self, other: &f64) -> bool { (*self) > (*other) }
-}
-#[cfg(not(test))]
-impl Eq for f64 {
- #[inline]
- fn eq(&self, other: &f64) -> bool { (*self) == (*other) }
-}
-
-impl Default for f64 {
- #[inline]
- fn default() -> f64 { 0.0 }
-}
-
-impl Primitive for f64 {}
-
-impl Num for f64 {}
-
-impl Zero for f64 {
- #[inline]
- fn zero() -> f64 { 0.0 }
-
- /// Returns true if the number is equal to either `0.0` or `-0.0`
- #[inline]
- fn is_zero(&self) -> bool { *self == 0.0 || *self == -0.0 }
-}
-
-impl One for f64 {
- #[inline]
- fn one() -> f64 { 1.0 }
-}
-
-#[cfg(not(test))]
-impl Add<f64,f64> for f64 {
- #[inline]
- fn add(&self, other: &f64) -> f64 { *self + *other }
-}
-#[cfg(not(test))]
-impl Sub<f64,f64> for f64 {
- #[inline]
- fn sub(&self, other: &f64) -> f64 { *self - *other }
-}
-#[cfg(not(test))]
-impl Mul<f64,f64> for f64 {
- #[inline]
- fn mul(&self, other: &f64) -> f64 { *self * *other }
-}
-#[cfg(not(test))]
-impl Div<f64,f64> for f64 {
- #[inline]
- fn div(&self, other: &f64) -> f64 { *self / *other }
-}
-#[cfg(not(test))]
-impl Rem<f64,f64> for f64 {
- #[inline]
- fn rem(&self, other: &f64) -> f64 {
- extern { fn fmod(a: f64, b: f64) -> f64; }
- unsafe { fmod(*self, *other) }
- }
-}
-#[cfg(not(test))]
-impl Neg<f64> for f64 {
- #[inline]
- fn neg(&self) -> f64 { -*self }
-}
-
-impl Signed for f64 {
- /// Computes the absolute value. Returns `NAN` if the number is `NAN`.
- #[inline]
- fn abs(&self) -> f64 {
- unsafe { intrinsics::fabsf64(*self) }
- }
-
- /// The positive difference of two numbers. Returns `0.0` if the number is less than or
- /// equal to `other`, otherwise the difference between`self` and `other` is returned.
- #[inline]
- fn abs_sub(&self, other: &f64) -> f64 {
- extern { fn fdim(a: f64, b: f64) -> f64; }
- unsafe { fdim(*self, *other) }
- }
-
- /// # Returns
- ///
- /// - `1.0` if the number is positive, `+0.0` or `INFINITY`
- /// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
- /// - `NAN` if the number is NaN
- #[inline]
- fn signum(&self) -> f64 {
- if self != self { NAN } else {
- unsafe { intrinsics::copysignf64(1.0, *self) }
- }
- }
-
- /// Returns `true` if the number is positive, including `+0.0` and `INFINITY`
- #[inline]
- fn is_positive(&self) -> bool { *self > 0.0 || (1.0 / *self) == INFINITY }
-
- /// Returns `true` if the number is negative, including `-0.0` and `NEG_INFINITY`
- #[inline]
- fn is_negative(&self) -> bool { *self < 0.0 || (1.0 / *self) == NEG_INFINITY }
-}
-
-impl Bounded for f64 {
- // NOTE: this is the smallest non-infinite f32 value, *not* MIN_VALUE
- #[inline]
- fn min_value() -> f64 { -MAX_VALUE }
-
- #[inline]
- fn max_value() -> f64 { MAX_VALUE }
-}
-
impl Float for f64 {
#[inline]
fn nan() -> f64 { NAN }
#[inline]
fn neg_zero() -> f64 { -0.0 }
- /// Returns `true` if the number is NaN
+ /// Returns `true` if the number is NaN.
#[inline]
fn is_nan(self) -> bool { self != self }
- /// Returns `true` if the number is infinite
+ /// Returns `true` if the number is infinite.
#[inline]
fn is_infinite(self) -> bool {
self == Float::infinity() || self == Float::neg_infinity()
}
- /// Returns `true` if the number is neither infinite or NaN
+ /// Returns `true` if the number is neither infinite or NaN.
#[inline]
fn is_finite(self) -> bool {
!(self.is_nan() || self.is_infinite())
}
- /// Returns `true` if the number is neither zero, infinite, subnormal or NaN
+ /// Returns `true` if the number is neither zero, infinite, subnormal or NaN.
#[inline]
fn is_normal(self) -> bool {
self.classify() == FPNormal
(mantissa, exponent, sign)
}
- /// Round half-way cases toward `NEG_INFINITY`
+ /// Rounds towards minus infinity.
#[inline]
fn floor(self) -> f64 {
unsafe { intrinsics::floorf64(self) }
}
- /// Round half-way cases toward `INFINITY`
+ /// Rounds towards plus infinity.
#[inline]
fn ceil(self) -> f64 {
unsafe { intrinsics::ceilf64(self) }
}
- /// Round half-way cases away from `0.0`
+ /// Rounds to nearest integer. Rounds half-way cases away from zero.
#[inline]
fn round(self) -> f64 {
unsafe { intrinsics::roundf64(self) }
}
- /// The integer part of the number (rounds towards `0.0`)
+ /// Returns the integer part of the number (rounds towards zero).
#[inline]
fn trunc(self) -> f64 {
unsafe { intrinsics::truncf64(self) }
unsafe { intrinsics::fmaf64(self, a, b) }
}
- /// The reciprocal (multiplicative inverse) of the number
+ /// Returns the reciprocal (multiplicative inverse) of the number.
#[inline]
fn recip(self) -> f64 { 1.0 / self }
#[inline]
fn ln_10() -> f64 { consts::LN_10 }
- /// Returns the exponential of the number
+ /// Returns the exponential of the number.
#[inline]
fn exp(self) -> f64 {
unsafe { intrinsics::expf64(self) }
}
- /// Returns 2 raised to the power of the number
+ /// Returns 2 raised to the power of the number.
#[inline]
fn exp2(self) -> f64 {
unsafe { intrinsics::exp2f64(self) }
}
- /// Returns the natural logarithm of the number
+ /// Returns the natural logarithm of the number.
#[inline]
fn ln(self) -> f64 {
unsafe { intrinsics::logf64(self) }
}
- /// Returns the logarithm of the number with respect to an arbitrary base
+ /// Returns the logarithm of the number with respect to an arbitrary base.
#[inline]
fn log(self, base: f64) -> f64 { self.ln() / base.ln() }
- /// Returns the base 2 logarithm of the number
+ /// Returns the base 2 logarithm of the number.
#[inline]
fn log2(self) -> f64 {
unsafe { intrinsics::log2f64(self) }
}
- /// Returns the base 10 logarithm of the number
+ /// Returns the base 10 logarithm of the number.
#[inline]
fn log10(self) -> f64 {
unsafe { intrinsics::log10f64(self) }
}
-
- /// Converts to degrees, assuming the number is in radians
+ /// Converts to degrees, assuming the number is in radians.
#[inline]
fn to_degrees(self) -> f64 { self * (180.0f64 / Float::pi()) }
- /// Converts to radians, assuming the number is in degrees
+ /// Converts to radians, assuming the number is in degrees.
#[inline]
fn to_radians(self) -> f64 {
let value: f64 = Float::pi();
projects / rust.git / blobdiff