From 42450ef02231f60f7ed41d78d04968b78f155404 Mon Sep 17 00:00:00 2001 From: Brendan Zabarauskas Date: Sat, 19 Apr 2014 01:27:51 +1000 Subject: [PATCH] Fix formatting in float implementations --- src/libstd/num/f32.rs | 135 +++++++++++++++++++++++++++++++----------- src/libstd/num/f64.rs | 135 +++++++++++++++++++++++++++++++----------- 2 files changed, 198 insertions(+), 72 deletions(-) diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index 2436ed1e95e..7525aa80a39 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -14,6 +14,7 @@ use prelude::*; +use cast; use default::Default; use from_str::FromStr; use libc::{c_int}; @@ -213,12 +214,16 @@ fn neg(&self) -> f32 { -*self } impl Signed for f32 { /// Computes the absolute value. Returns `NAN` if the number is `NAN`. #[inline] - fn abs(&self) -> f32 { unsafe{intrinsics::fabsf32(*self)} } + fn abs(&self) -> f32 { + unsafe { intrinsics::fabsf32(*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: &f32) -> f32 { unsafe{cmath::fdimf(*self, *other)} } + fn abs_sub(&self, other: &f32) -> f32 { + unsafe { cmath::fdimf(*self, *other) } + } /// # Returns /// @@ -227,7 +232,9 @@ fn abs_sub(&self, other: &f32) -> f32 { unsafe{cmath::fdimf(*self, *other)} } /// - `NAN` if the number is NaN #[inline] fn signum(&self) -> f32 { - if self.is_nan() { NAN } else { unsafe{intrinsics::copysignf32(1.0, *self)} } + if self.is_nan() { NAN } else { + unsafe { intrinsics::copysignf32(1.0, *self) } + } } /// Returns `true` if the number is positive, including `+0.0` and `INFINITY` @@ -250,7 +257,9 @@ fn max_value() -> f32 { 3.40282347e+38 } impl Primitive for f32 {} impl Float for f32 { - fn powi(self, n: i32) -> f32 { unsafe{intrinsics::powif32(self, n)} } + fn powi(self, n: i32) -> f32 { + unsafe { intrinsics::powif32(self, n) } + } #[inline] fn max(self, other: f32) -> f32 { @@ -302,7 +311,7 @@ fn classify(self) -> FPCategory { static EXP_MASK: u32 = 0x7f800000; static MAN_MASK: u32 = 0x007fffff; - let bits: u32 = unsafe {::cast::transmute(self)}; + let bits: u32 = unsafe { cast::transmute(self) }; match (bits & MAN_MASK, bits & EXP_MASK) { (0, 0) => FPZero, (_, 0) => FPSubnormal, @@ -335,7 +344,9 @@ fn max_10_exp(_: Option) -> int { 38 } /// Constructs a floating point number by multiplying `x` by 2 raised to the power of `exp` #[inline] - fn ldexp(x: f32, exp: int) -> f32 { unsafe{cmath::ldexpf(x, exp as c_int)} } + fn ldexp(x: f32, exp: int) -> f32 { + unsafe { cmath::ldexpf(x, exp as c_int) } + } /// Breaks the number into a normalized fraction and a base-2 exponent, satisfying: /// @@ -353,28 +364,34 @@ fn frexp(self) -> (f32, int) { /// Returns the exponential of the number, minus `1`, in a way that is accurate /// even if the number is close to zero #[inline] - fn exp_m1(self) -> f32 { unsafe{cmath::expm1f(self)} } + fn exp_m1(self) -> f32 { + unsafe { cmath::expm1f(self) } + } /// Returns the natural logarithm of the number plus `1` (`ln(1+n)`) more accurately /// than if the operations were performed separately #[inline] - fn ln_1p(self) -> f32 { unsafe{cmath::log1pf(self)} } + fn ln_1p(self) -> f32 { + unsafe { cmath::log1pf(self) } + } /// 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)} } + fn mul_add(self, a: f32, b: f32) -> f32 { + unsafe { intrinsics::fmaf32(self, a, b) } + } /// Returns the next representable floating-point value in the direction of `other` #[inline] - fn next_after(self, other: f32) -> f32 { unsafe{cmath::nextafterf(self, other)} } + fn next_after(self, other: f32) -> f32 { + unsafe { cmath::nextafterf(self, other) } + } /// Returns the mantissa, exponent and sign as integers. fn integer_decode(self) -> (u64, i16, i8) { - let bits: u32 = unsafe { - ::cast::transmute(self) - }; + let bits: u32 = unsafe { cast::transmute(self) }; let sign: i8 = if bits >> 31 == 0 { 1 } else { -1 }; let mut exponent: i16 = ((bits >> 23) & 0xff) as i16; let mantissa = if exponent == 0 { @@ -389,19 +406,27 @@ fn integer_decode(self) -> (u64, i16, i8) { /// Round half-way cases toward `NEG_INFINITY` #[inline] - fn floor(self) -> f32 { unsafe{intrinsics::floorf32(self)} } + fn floor(self) -> f32 { + unsafe { intrinsics::floorf32(self) } + } /// Round half-way cases toward `INFINITY` #[inline] - fn ceil(self) -> f32 { unsafe{intrinsics::ceilf32(self)} } + fn ceil(self) -> f32 { + unsafe { intrinsics::ceilf32(self) } + } /// Round half-way cases away from `0.0` #[inline] - fn round(self) -> f32 { unsafe{intrinsics::roundf32(self)} } + fn round(self) -> f32 { + unsafe { intrinsics::roundf32(self) } + } /// The integer part of the number (rounds towards `0.0`) #[inline] - fn trunc(self) -> f32 { unsafe{intrinsics::truncf32(self)} } + fn trunc(self) -> f32 { + unsafe { intrinsics::truncf32(self) } + } /// The fractional part of the number, satisfying: /// @@ -485,40 +510,62 @@ fn ln_10() -> f32 { 2.30258509299404568401799145468436421 } fn recip(self) -> f32 { 1.0 / self } #[inline] - fn powf(self, n: f32) -> f32 { unsafe{intrinsics::powf32(self, n)} } + fn powf(self, n: f32) -> f32 { + unsafe { intrinsics::powf32(self, n) } + } #[inline] - fn sqrt(self) -> f32 { unsafe{intrinsics::sqrtf32(self)} } + fn sqrt(self) -> f32 { + unsafe { intrinsics::sqrtf32(self) } + } #[inline] fn rsqrt(self) -> f32 { self.sqrt().recip() } #[inline] - fn cbrt(self) -> f32 { unsafe{cmath::cbrtf(self)} } + fn cbrt(self) -> f32 { + unsafe { cmath::cbrtf(self) } + } #[inline] - fn hypot(self, other: f32) -> f32 { unsafe{cmath::hypotf(self, other)} } + fn hypot(self, other: f32) -> f32 { + unsafe { cmath::hypotf(self, other) } + } #[inline] - fn sin(self) -> f32 { unsafe{intrinsics::sinf32(self)} } + fn sin(self) -> f32 { + unsafe { intrinsics::sinf32(self) } + } #[inline] - fn cos(self) -> f32 { unsafe{intrinsics::cosf32(self)} } + fn cos(self) -> f32 { + unsafe { intrinsics::cosf32(self) } + } #[inline] - fn tan(self) -> f32 { unsafe{cmath::tanf(self)} } + fn tan(self) -> f32 { + unsafe { cmath::tanf(self) } + } #[inline] - fn asin(self) -> f32 { unsafe{cmath::asinf(self)} } + fn asin(self) -> f32 { + unsafe { cmath::asinf(self) } + } #[inline] - fn acos(self) -> f32 { unsafe{cmath::acosf(self)} } + fn acos(self) -> f32 { + unsafe { cmath::acosf(self) } + } #[inline] - fn atan(self) -> f32 { unsafe{cmath::atanf(self)} } + fn atan(self) -> f32 { + unsafe { cmath::atanf(self) } + } #[inline] - fn atan2(self, other: f32) -> f32 { unsafe{cmath::atan2f(self, other)} } + fn atan2(self, other: f32) -> f32 { + unsafe { cmath::atan2f(self, other) } + } /// Simultaneously computes the sine and cosine of the number #[inline] @@ -528,15 +575,21 @@ fn sin_cos(self) -> (f32, f32) { /// Returns the exponential of the number #[inline] - fn exp(self) -> f32 { unsafe{intrinsics::expf32(self)} } + fn exp(self) -> f32 { + unsafe { intrinsics::expf32(self) } + } /// Returns 2 raised to the power of the number #[inline] - fn exp2(self) -> f32 { unsafe{intrinsics::exp2f32(self)} } + fn exp2(self) -> f32 { + unsafe { intrinsics::exp2f32(self) } + } /// Returns the natural logarithm of the number #[inline] - fn ln(self) -> f32 { unsafe{intrinsics::logf32(self)} } + fn ln(self) -> f32 { + unsafe { intrinsics::logf32(self) } + } /// Returns the logarithm of the number with respect to an arbitrary base #[inline] @@ -544,20 +597,30 @@ 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)} } + fn log2(self) -> f32 { + unsafe { intrinsics::log2f32(self) } + } /// Returns the base 10 logarithm of the number #[inline] - fn log10(self) -> f32 { unsafe{intrinsics::log10f32(self)} } + fn log10(self) -> f32 { + unsafe { intrinsics::log10f32(self) } + } #[inline] - fn sinh(self) -> f32 { unsafe{cmath::sinhf(self)} } + fn sinh(self) -> f32 { + unsafe { cmath::sinhf(self) } + } #[inline] - fn cosh(self) -> f32 { unsafe{cmath::coshf(self)} } + fn cosh(self) -> f32 { + unsafe { cmath::coshf(self) } + } #[inline] - fn tanh(self) -> f32 { unsafe{cmath::tanhf(self)} } + fn tanh(self) -> f32 { + unsafe { cmath::tanhf(self) } + } /// Inverse hyperbolic sine /// diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index 3fb5d793db0..7d0ad1029e7 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -14,6 +14,7 @@ use prelude::*; +use cast; use default::Default; use from_str::FromStr; use libc::{c_int}; @@ -221,12 +222,16 @@ 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)} } + 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 { unsafe{cmath::fdim(*self, *other)} } + fn abs_sub(&self, other: &f64) -> f64 { + unsafe { cmath::fdim(*self, *other) } + } /// # Returns /// @@ -235,7 +240,9 @@ fn abs_sub(&self, other: &f64) -> f64 { unsafe{cmath::fdim(*self, *other)} } /// - `NAN` if the number is NaN #[inline] fn signum(&self) -> f64 { - if self.is_nan() { NAN } else { unsafe{intrinsics::copysignf64(1.0, *self)} } + if self.is_nan() { NAN } else { + unsafe { intrinsics::copysignf64(1.0, *self) } + } } /// Returns `true` if the number is positive, including `+0.0` and `INFINITY` @@ -308,7 +315,7 @@ fn classify(self) -> FPCategory { static EXP_MASK: u64 = 0x7ff0000000000000; static MAN_MASK: u64 = 0x000fffffffffffff; - let bits: u64 = unsafe {::cast::transmute(self)}; + let bits: u64 = unsafe { cast::transmute(self) }; match (bits & MAN_MASK, bits & EXP_MASK) { (0, 0) => FPZero, (_, 0) => FPSubnormal, @@ -341,7 +348,9 @@ fn max_10_exp(_: Option) -> int { 308 } /// Constructs a floating point number by multiplying `x` by 2 raised to the power of `exp` #[inline] - fn ldexp(x: f64, exp: int) -> f64 { unsafe{cmath::ldexp(x, exp as c_int)} } + fn ldexp(x: f64, exp: int) -> f64 { + unsafe { cmath::ldexp(x, exp as c_int) } + } /// Breaks the number into a normalized fraction and a base-2 exponent, satisfying: /// @@ -359,28 +368,34 @@ fn frexp(self) -> (f64, int) { /// Returns the exponential of the number, minus `1`, in a way that is accurate /// even if the number is close to zero #[inline] - fn exp_m1(self) -> f64 { unsafe{cmath::expm1(self)} } + fn exp_m1(self) -> f64 { + unsafe { cmath::expm1(self) } + } /// Returns the natural logarithm of the number plus `1` (`ln(1+n)`) more accurately /// than if the operations were performed separately #[inline] - fn ln_1p(self) -> f64 { unsafe{cmath::log1p(self)} } + fn ln_1p(self) -> f64 { + unsafe { cmath::log1p(self) } + } /// 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)} } + fn mul_add(self, a: f64, b: f64) -> f64 { + unsafe { intrinsics::fmaf64(self, a, b) } + } /// Returns the next representable floating-point value in the direction of `other` #[inline] - fn next_after(self, other: f64) -> f64 { unsafe{cmath::nextafter(self, other)} } + fn next_after(self, other: f64) -> f64 { + unsafe { cmath::nextafter(self, other) } + } /// Returns the mantissa, exponent and sign as integers. fn integer_decode(self) -> (u64, i16, i8) { - let bits: u64 = unsafe { - ::cast::transmute(self) - }; + let bits: u64 = unsafe { cast::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 { @@ -395,19 +410,27 @@ fn integer_decode(self) -> (u64, i16, i8) { /// Round half-way cases toward `NEG_INFINITY` #[inline] - fn floor(self) -> f64 { unsafe{intrinsics::floorf64(self)} } + fn floor(self) -> f64 { + unsafe { intrinsics::floorf64(self) } + } /// Round half-way cases toward `INFINITY` #[inline] - fn ceil(self) -> f64 { unsafe{intrinsics::ceilf64(self)} } + fn ceil(self) -> f64 { + unsafe { intrinsics::ceilf64(self) } + } /// Round half-way cases away from `0.0` #[inline] - fn round(self) -> f64 { unsafe{intrinsics::roundf64(self)} } + fn round(self) -> f64 { + unsafe { intrinsics::roundf64(self) } + } /// The integer part of the number (rounds towards `0.0`) #[inline] - fn trunc(self) -> f64 { unsafe{intrinsics::truncf64(self)} } + fn trunc(self) -> f64 { + unsafe { intrinsics::truncf64(self) } + } /// The fractional part of the number, satisfying: /// @@ -491,43 +514,67 @@ fn ln_10() -> f64 { 2.30258509299404568401799145468436421 } fn recip(self) -> f64 { 1.0 / self } #[inline] - fn powf(self, n: f64) -> f64 { unsafe{intrinsics::powf64(self, n)} } + fn powf(self, n: f64) -> f64 { + unsafe { intrinsics::powf64(self, n) } + } #[inline] - fn powi(self, n: i32) -> f64 { unsafe{intrinsics::powif64(self, n)} } + fn powi(self, n: i32) -> f64 { + unsafe { intrinsics::powif64(self, n) } + } #[inline] - fn sqrt(self) -> f64 { unsafe{intrinsics::sqrtf64(self)} } + fn sqrt(self) -> f64 { + unsafe { intrinsics::sqrtf64(self) } + } #[inline] fn rsqrt(self) -> f64 { self.sqrt().recip() } #[inline] - fn cbrt(self) -> f64 { unsafe{cmath::cbrt(self)} } + fn cbrt(self) -> f64 { + unsafe { cmath::cbrt(self) } + } #[inline] - fn hypot(self, other: f64) -> f64 { unsafe{cmath::hypot(self, other)} } + fn hypot(self, other: f64) -> f64 { + unsafe { cmath::hypot(self, other) } + } #[inline] - fn sin(self) -> f64 { unsafe{intrinsics::sinf64(self)} } + fn sin(self) -> f64 { + unsafe { intrinsics::sinf64(self) } + } #[inline] - fn cos(self) -> f64 { unsafe{intrinsics::cosf64(self)} } + fn cos(self) -> f64 { + unsafe { intrinsics::cosf64(self) } + } #[inline] - fn tan(self) -> f64 { unsafe{cmath::tan(self)} } + fn tan(self) -> f64 { + unsafe { cmath::tan(self) } + } #[inline] - fn asin(self) -> f64 { unsafe{cmath::asin(self)} } + fn asin(self) -> f64 { + unsafe { cmath::asin(self) } + } #[inline] - fn acos(self) -> f64 { unsafe{cmath::acos(self)} } + fn acos(self) -> f64 { + unsafe { cmath::acos(self) } + } #[inline] - fn atan(self) -> f64 { unsafe{cmath::atan(self)} } + fn atan(self) -> f64 { + unsafe { cmath::atan(self) } + } #[inline] - fn atan2(self, other: f64) -> f64 { unsafe{cmath::atan2(self, other)} } + fn atan2(self, other: f64) -> f64 { + unsafe { cmath::atan2(self, other) } + } /// Simultaneously computes the sine and cosine of the number #[inline] @@ -537,15 +584,21 @@ fn sin_cos(self) -> (f64, f64) { /// Returns the exponential of the number #[inline] - fn exp(self) -> f64 { unsafe{intrinsics::expf64(self)} } + 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)} } + fn exp2(self) -> f64 { + unsafe { intrinsics::exp2f64(self) } + } /// Returns the natural logarithm of the number #[inline] - fn ln(self) -> f64 { unsafe{intrinsics::logf64(self)} } + fn ln(self) -> f64 { + unsafe { intrinsics::logf64(self) } + } /// Returns the logarithm of the number with respect to an arbitrary base #[inline] @@ -553,20 +606,30 @@ 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)} } + 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)} } + fn log10(self) -> f64 { + unsafe { intrinsics::log10f64(self) } + } #[inline] - fn sinh(self) -> f64 { unsafe{cmath::sinh(self)} } + fn sinh(self) -> f64 { + unsafe { cmath::sinh(self) } + } #[inline] - fn cosh(self) -> f64 { unsafe{cmath::cosh(self)} } + fn cosh(self) -> f64 { + unsafe { cmath::cosh(self) } + } #[inline] - fn tanh(self) -> f64 { unsafe{cmath::tanh(self)} } + fn tanh(self) -> f64 { + unsafe { cmath::tanh(self) } + } /// Inverse hyperbolic sine ///