Skip to content

Remove dependencies on libm functions from libcore. #27823

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Aug 18, 2015
Merged

Remove dependencies on libm functions from libcore. #27823

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
140 changes: 0 additions & 140 deletions src/libcore/num/f32.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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]
Expand Down Expand Up @@ -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 }
Expand All @@ -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) }
Expand Down
92 changes: 0 additions & 92 deletions src/libcore/num/f64.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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]
Expand Down Expand Up @@ -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) }
Expand Down
5 changes: 0 additions & 5 deletions src/libcore/num/flt2dec/decoder.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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 }
}

Expand Down
1 change: 0 additions & 1 deletion src/libcore/num/flt2dec/mod.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -131,7 +131,6 @@ functions.

use prelude::v1::*;
use i16;
use num::Float;
use slice::bytes;
pub use self::decoder::{decode, DecodableFloat, FullDecoded, Decoded};

Expand Down
1 change: 0 additions & 1 deletion src/libcore/num/flt2dec/strategy/dragon.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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};
Expand Down
2 changes: 0 additions & 2 deletions src/libcore/num/flt2dec/strategy/grisu.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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`.
Expand Down
38 changes: 0 additions & 38 deletions src/libcore/num/mod.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand All @@ -1324,39 +1312,13 @@ 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;

/// Raise a number to an integer power.
///
/// 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;
Expand Down
4 changes: 3 additions & 1 deletion src/libcore/ops.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -445,7 +445,9 @@ rem_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
impl Rem for f32 {
type Output = f32;

// see notes in `core::f32::Float::floor`
// The builtin f32 rem operator is broken when targeting
// MSVC; see comment in std::f32::floor.
// FIXME: See also #27859.
#[inline]
#[cfg(target_env = "msvc")]
fn rem(self, other: f32) -> f32 {
Expand Down
Loading