From 1ddee8070d3cb83609b1f71c29e3deda3d30fd51 Mon Sep 17 00:00:00 2001 From: Eli Friedman Date: Sun, 16 Aug 2015 00:42:53 -0700 Subject: Remove dependencies on libm functions from libcore. There wasn't any particular reason the functions needed to be there anyway, so just get rid of them, and adjust libstd to compensate. With this change, libcore depends on exactly two floating-point functions: fmod and fmodf. They are implicitly referenced because they are used to implement "%". --- src/libcore/num/f32.rs | 140 ----------------------------- src/libcore/num/f64.rs | 92 ------------------- src/libcore/num/flt2dec/decoder.rs | 5 -- src/libcore/num/flt2dec/mod.rs | 1 - src/libcore/num/flt2dec/strategy/dragon.rs | 1 - src/libcore/num/flt2dec/strategy/grisu.rs | 2 - src/libcore/num/mod.rs | 38 -------- 7 files changed, 279 deletions(-) (limited to 'src/libcore/num') diff --git a/src/libcore/num/f32.rs b/src/libcore/num/f32.rs index d0e6d4fa49c..883f9abf917 100644 --- a/src/libcore/num/f32.rs +++ b/src/libcore/num/f32.rs @@ -222,63 +222,6 @@ impl Float for f32 { (mantissa as u64, exponent, sign) } - /// Rounds towards minus infinity. - #[inline] - fn floor(self) -> f32 { - return floorf(self); - - // On MSVC LLVM will lower many math intrinsics to a call to the - // corresponding function. On MSVC, however, many of these functions - // aren't actually available as symbols to call, but rather they are all - // `static inline` functions in header files. This means that from a C - // perspective it's "compatible", but not so much from an ABI - // perspective (which we're worried about). - // - // The inline header functions always just cast to a f64 and do their - // operation, so we do that here as well, but only for MSVC targets. - // - // Note that there are many MSVC-specific float operations which - // redirect to this comment, so `floorf` is just one case of a missing - // function on MSVC, but there are many others elsewhere. - #[cfg(target_env = "msvc")] - fn floorf(f: f32) -> f32 { (f as f64).floor() as f32 } - #[cfg(not(target_env = "msvc"))] - fn floorf(f: f32) -> f32 { unsafe { intrinsics::floorf32(f) } } - } - - /// Rounds towards plus infinity. - #[inline] - fn ceil(self) -> f32 { - return ceilf(self); - - // see notes above in `floor` - #[cfg(target_env = "msvc")] - fn ceilf(f: f32) -> f32 { (f as f64).ceil() as f32 } - #[cfg(not(target_env = "msvc"))] - fn ceilf(f: f32) -> f32 { unsafe { intrinsics::ceilf32(f) } } - } - - /// Rounds to nearest integer. Rounds half-way cases away from zero. - #[inline] - fn round(self) -> f32 { - unsafe { intrinsics::roundf32(self) } - } - - /// Returns the integer part of the number (rounds towards zero). - #[inline] - fn trunc(self) -> f32 { - unsafe { intrinsics::truncf32(self) } - } - - /// The fractional part of the number, satisfying: - /// - /// ``` - /// let x = 1.65f32; - /// assert!(x == x.trunc() + x.fract()) - /// ``` - #[inline] - fn fract(self) -> f32 { self - self.trunc() } - /// Computes the absolute value of `self`. Returns `Float::nan()` if the /// number is `Float::nan()`. #[inline] @@ -314,14 +257,6 @@ impl Float for f32 { self < 0.0 || (1.0 / self) == Float::neg_infinity() } - /// Fused multiply-add. Computes `(self * a) + b` with only one rounding - /// error. This produces a more accurate result with better performance than - /// a separate multiplication operation followed by an add. - #[inline] - fn mul_add(self, a: f32, b: f32) -> f32 { - unsafe { intrinsics::fmaf32(self, a, b) } - } - /// Returns the reciprocal (multiplicative inverse) of the number. #[inline] fn recip(self) -> f32 { 1.0 / self } @@ -331,81 +266,6 @@ impl Float for f32 { unsafe { intrinsics::powif32(self, n) } } - #[inline] - fn powf(self, n: f32) -> f32 { - return powf(self, n); - - // see notes above in `floor` - #[cfg(target_env = "msvc")] - fn powf(f: f32, n: f32) -> f32 { (f as f64).powf(n as f64) as f32 } - #[cfg(not(target_env = "msvc"))] - fn powf(f: f32, n: f32) -> f32 { unsafe { intrinsics::powf32(f, n) } } - } - - #[inline] - fn sqrt(self) -> f32 { - if self < 0.0 { - NAN - } else { - unsafe { intrinsics::sqrtf32(self) } - } - } - - #[inline] - fn rsqrt(self) -> f32 { self.sqrt().recip() } - - /// Returns the exponential of the number. - #[inline] - fn exp(self) -> f32 { - return expf(self); - - // see notes above in `floor` - #[cfg(target_env = "msvc")] - fn expf(f: f32) -> f32 { (f as f64).exp() as f32 } - #[cfg(not(target_env = "msvc"))] - fn expf(f: f32) -> f32 { unsafe { intrinsics::expf32(f) } } - } - - /// Returns 2 raised to the power of the number. - #[inline] - fn exp2(self) -> f32 { - unsafe { intrinsics::exp2f32(self) } - } - - /// Returns the natural logarithm of the number. - #[inline] - fn ln(self) -> f32 { - return logf(self); - - // see notes above in `floor` - #[cfg(target_env = "msvc")] - fn logf(f: f32) -> f32 { (f as f64).ln() as f32 } - #[cfg(not(target_env = "msvc"))] - fn logf(f: f32) -> f32 { unsafe { intrinsics::logf32(f) } } - } - - /// Returns the logarithm of the number with respect to an arbitrary base. - #[inline] - fn log(self, base: f32) -> f32 { self.ln() / base.ln() } - - /// Returns the base 2 logarithm of the number. - #[inline] - fn log2(self) -> f32 { - unsafe { intrinsics::log2f32(self) } - } - - /// Returns the base 10 logarithm of the number. - #[inline] - fn log10(self) -> f32 { - return log10f(self); - - // see notes above in `floor` - #[cfg(target_env = "msvc")] - fn log10f(f: f32) -> f32 { (f as f64).log10() as f32 } - #[cfg(not(target_env = "msvc"))] - fn log10f(f: f32) -> f32 { unsafe { intrinsics::log10f32(f) } } - } - /// Converts to degrees, assuming the number is in radians. #[inline] fn to_degrees(self) -> f32 { self * (180.0f32 / consts::PI) } diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs index bf7da04f995..248137f5229 100644 --- a/src/libcore/num/f64.rs +++ b/src/libcore/num/f64.rs @@ -222,39 +222,6 @@ impl Float for f64 { (mantissa, exponent, sign) } - /// Rounds towards minus infinity. - #[inline] - fn floor(self) -> f64 { - unsafe { intrinsics::floorf64(self) } - } - - /// Rounds towards plus infinity. - #[inline] - fn ceil(self) -> f64 { - unsafe { intrinsics::ceilf64(self) } - } - - /// Rounds to nearest integer. Rounds half-way cases away from zero. - #[inline] - fn round(self) -> f64 { - unsafe { intrinsics::roundf64(self) } - } - - /// Returns the integer part of the number (rounds towards zero). - #[inline] - fn trunc(self) -> f64 { - unsafe { intrinsics::truncf64(self) } - } - - /// The fractional part of the number, satisfying: - /// - /// ``` - /// let x = 1.65f64; - /// assert!(x == x.trunc() + x.fract()) - /// ``` - #[inline] - fn fract(self) -> f64 { self - self.trunc() } - /// Computes the absolute value of `self`. Returns `Float::nan()` if the /// number is `Float::nan()`. #[inline] @@ -290,74 +257,15 @@ impl Float for f64 { self < 0.0 || (1.0 / self) == Float::neg_infinity() } - /// Fused multiply-add. Computes `(self * a) + b` with only one rounding - /// error. This produces a more accurate result with better performance than - /// a separate multiplication operation followed by an add. - #[inline] - fn mul_add(self, a: f64, b: f64) -> f64 { - unsafe { intrinsics::fmaf64(self, a, b) } - } - /// Returns the reciprocal (multiplicative inverse) of the number. #[inline] fn recip(self) -> f64 { 1.0 / self } - #[inline] - fn powf(self, n: f64) -> f64 { - unsafe { intrinsics::powf64(self, n) } - } - #[inline] fn powi(self, n: i32) -> f64 { unsafe { intrinsics::powif64(self, n) } } - #[inline] - fn sqrt(self) -> f64 { - if self < 0.0 { - NAN - } else { - unsafe { intrinsics::sqrtf64(self) } - } - } - - #[inline] - fn rsqrt(self) -> f64 { self.sqrt().recip() } - - /// Returns the exponential of the number. - #[inline] - fn exp(self) -> f64 { - unsafe { intrinsics::expf64(self) } - } - - /// 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. - #[inline] - fn ln(self) -> f64 { - unsafe { intrinsics::logf64(self) } - } - - /// 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. - #[inline] - fn log2(self) -> f64 { - unsafe { intrinsics::log2f64(self) } - } - - /// 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. #[inline] fn to_degrees(self) -> f64 { self * (180.0f64 / consts::PI) } diff --git a/src/libcore/num/flt2dec/decoder.rs b/src/libcore/num/flt2dec/decoder.rs index a292ffa2e9d..6265691bde9 100644 --- a/src/libcore/num/flt2dec/decoder.rs +++ b/src/libcore/num/flt2dec/decoder.rs @@ -53,20 +53,15 @@ pub enum FullDecoded { /// A floating point type which can be `decode`d. pub trait DecodableFloat: Float + Copy { - /// Returns `x * 2^exp`. Almost same to `std::{f32,f64}::ldexp`. - /// This is used for testing. - fn ldexpi(f: i64, exp: isize) -> Self; /// The minimum positive normalized value. fn min_pos_norm_value() -> Self; } impl DecodableFloat for f32 { - fn ldexpi(f: i64, exp: isize) -> Self { f as Self * (exp as Self).exp2() } fn min_pos_norm_value() -> Self { f32::MIN_POSITIVE } } impl DecodableFloat for f64 { - fn ldexpi(f: i64, exp: isize) -> Self { f as Self * (exp as Self).exp2() } fn min_pos_norm_value() -> Self { f64::MIN_POSITIVE } } diff --git a/src/libcore/num/flt2dec/mod.rs b/src/libcore/num/flt2dec/mod.rs index 40fa2a5563d..1277decf5e2 100644 --- a/src/libcore/num/flt2dec/mod.rs +++ b/src/libcore/num/flt2dec/mod.rs @@ -131,7 +131,6 @@ functions. use prelude::v1::*; use i16; -use num::Float; use slice::bytes; pub use self::decoder::{decode, DecodableFloat, FullDecoded, Decoded}; diff --git a/src/libcore/num/flt2dec/strategy/dragon.rs b/src/libcore/num/flt2dec/strategy/dragon.rs index cdc23c45fa0..ab610f28e9e 100644 --- a/src/libcore/num/flt2dec/strategy/dragon.rs +++ b/src/libcore/num/flt2dec/strategy/dragon.rs @@ -17,7 +17,6 @@ Almost direct (but slightly optimized) Rust translation of Figure 3 of [1]. use prelude::v1::*; -use num::Float; use cmp::Ordering; use num::flt2dec::{Decoded, MAX_SIG_DIGITS, round_up}; diff --git a/src/libcore/num/flt2dec/strategy/grisu.rs b/src/libcore/num/flt2dec/strategy/grisu.rs index 52eafcec184..b0822ca76c7 100644 --- a/src/libcore/num/flt2dec/strategy/grisu.rs +++ b/src/libcore/num/flt2dec/strategy/grisu.rs @@ -18,8 +18,6 @@ Rust adaptation of Grisu3 algorithm described in [1]. It uses about use prelude::v1::*; -use num::Float; - use num::flt2dec::{Decoded, MAX_SIG_DIGITS, round_up}; /// A custom 64-bit floating point type, representing `f * 2^e`. diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index 19ca83b6ea4..60675a61868 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -1296,18 +1296,6 @@ pub trait Float { /// Returns the mantissa, exponent and sign as integers, respectively. fn integer_decode(self) -> (u64, i16, i8); - /// Return the largest integer less than or equal to a number. - fn floor(self) -> Self; - /// Return the smallest integer greater than or equal to a number. - fn ceil(self) -> Self; - /// Return the nearest integer to a number. Round half-way cases away from - /// `0.0`. - fn round(self) -> Self; - /// Return the integer part of a number. - fn trunc(self) -> Self; - /// Return the fractional part of a number. - fn fract(self) -> Self; - /// Computes the absolute value of `self`. Returns `Float::nan()` if the /// number is `Float::nan()`. fn abs(self) -> Self; @@ -1324,10 +1312,6 @@ pub trait Float { /// `Float::neg_infinity()`. fn is_negative(self) -> bool; - /// Fused multiply-add. Computes `(self * a) + b` with only one rounding - /// error. This produces a more accurate result with better performance than - /// a separate multiplication operation followed by an add. - fn mul_add(self, a: Self, b: Self) -> Self; /// Take the reciprocal (inverse) of a number, `1/x`. fn recip(self) -> Self; @@ -1335,28 +1319,6 @@ pub trait Float { /// /// Using this function is generally faster than using `powf` fn powi(self, n: i32) -> Self; - /// Raise a number to a floating point power. - fn powf(self, n: Self) -> Self; - - /// Take the square root of a number. - /// - /// Returns NaN if `self` is a negative number. - fn sqrt(self) -> Self; - /// Take the reciprocal (inverse) square root of a number, `1/sqrt(x)`. - fn rsqrt(self) -> Self; - - /// Returns `e^(self)`, (the exponential function). - fn exp(self) -> Self; - /// Returns 2 raised to the power of the number, `2^(self)`. - fn exp2(self) -> Self; - /// Returns the natural logarithm of the number. - fn ln(self) -> Self; - /// Returns the logarithm of the number with respect to an arbitrary base. - fn log(self, base: Self) -> Self; - /// Returns the base 2 logarithm of the number. - fn log2(self) -> Self; - /// Returns the base 10 logarithm of the number. - fn log10(self) -> Self; /// Convert radians to degrees. fn to_degrees(self) -> Self; -- cgit 1.4.1-3-g733a5