From 3797f2bfe63ca618702607b0dd3f714f8fab99f3 Mon Sep 17 00:00:00 2001 From: Ziad Hatahet Date: Mon, 28 Oct 2013 17:34:33 -0700 Subject: [PATCH] Capitalize statics in f32 and f64 mods Fixes #10077 --- doc/tutorial.md | 26 ++--- src/libstd/num/f32.rs | 132 ++++++++++++----------- src/libstd/num/f64.rs | 150 +++++++++++++-------------- src/libstd/num/num.rs | 6 +- src/test/bench/noise.rs | 2 +- src/test/compile-fail/issue-6804.rs | 10 +- src/test/run-pass/intrinsics-math.rs | 16 +-- src/test/run-pass/issue-3753.rs | 2 +- 8 files changed, 169 insertions(+), 175 deletions(-) diff --git a/doc/tutorial.md b/doc/tutorial.md index f9f110c122b28..3eab4ceffec19 100644 --- a/doc/tutorial.md +++ b/doc/tutorial.md @@ -491,7 +491,7 @@ types. use std::f64; use std::num::atan; fn angle(vector: (f64, f64)) -> f64 { - let pi = f64::consts::pi; + let pi = f64::consts::PI; match vector { (0.0, y) if y < 0.0 => 1.5 * pi, (0.0, y) => 0.5 * pi, @@ -689,7 +689,7 @@ use std::f64; # enum Shape { Circle(Point, f64), Rectangle(Point, Point) } fn area(sh: Shape) -> f64 { match sh { - Circle(_, size) => f64::consts::pi * size * size, + Circle(_, size) => f64::consts::PI * size * size, Rectangle(Point { x, y }, Point { x: x2, y: y2 }) => (x2 - x) * (y2 - y) } } @@ -725,7 +725,7 @@ enum Shape { } fn area(sh: Shape) -> f64 { match sh { - Circle { radius: radius, _ } => f64::consts::pi * square(radius), + Circle { radius: radius, _ } => f64::consts::PI * square(radius), Rectangle { top_left: top_left, bottom_right: bottom_right } => { (bottom_right.x - top_left.x) * (top_left.y - bottom_right.y) } @@ -1699,10 +1699,10 @@ impl Circle { To call such a method, just prefix it with the type name and a double colon: ~~~~ -use std::f64::consts::pi; +use std::f64::consts::PI; struct Circle { radius: f64 } impl Circle { - fn new(area: f64) -> Circle { Circle { radius: (area / pi).sqrt() } } + fn new(area: f64) -> Circle { Circle { radius: (area / PI).sqrt() } } } let c = Circle::new(42.5); ~~~~ @@ -1977,13 +1977,13 @@ name and a double colon. The compiler uses type inference to decide which implementation to use. ~~~~ -use std::f64::consts::pi; +use std::f64::consts::PI; trait Shape { fn new(area: f64) -> Self; } struct Circle { radius: f64 } struct Square { length: f64 } impl Shape for Circle { - fn new(area: f64) -> Circle { Circle { radius: (area / pi).sqrt() } } + fn new(area: f64) -> Circle { Circle { radius: (area / PI).sqrt() } } } impl Shape for Square { fn new(area: f64) -> Square { Square { length: (area).sqrt() } } @@ -2157,17 +2157,17 @@ trait Circle : Shape { fn radius(&self) -> f64; } Now, we can implement `Circle` on a type only if we also implement `Shape`. ~~~~ -use std::f64::consts::pi; +use std::f64::consts::PI; # trait Shape { fn area(&self) -> f64; } # trait Circle : Shape { fn radius(&self) -> f64; } # struct Point { x: f64, y: f64 } # fn square(x: f64) -> f64 { x * x } struct CircleStruct { center: Point, radius: f64 } impl Circle for CircleStruct { - fn radius(&self) -> f64 { (self.area() / pi).sqrt() } + fn radius(&self) -> f64 { (self.area() / PI).sqrt() } } impl Shape for CircleStruct { - fn area(&self) -> f64 { pi * square(self.radius) } + fn area(&self) -> f64 { PI * square(self.radius) } } ~~~~ @@ -2192,13 +2192,13 @@ fn radius_times_area(c: T) -> f64 { Likewise, supertrait methods may also be called on trait objects. ~~~ {.xfail-test} -use std::f64::consts::pi; +use std::f64::consts::PI; # trait Shape { fn area(&self) -> f64; } # trait Circle : Shape { fn radius(&self) -> f64; } # struct Point { x: f64, y: f64 } # struct CircleStruct { center: Point, radius: f64 } -# impl Circle for CircleStruct { fn radius(&self) -> f64 { (self.area() / pi).sqrt() } } -# impl Shape for CircleStruct { fn area(&self) -> f64 { pi * square(self.radius) } } +# impl Circle for CircleStruct { fn radius(&self) -> f64 { (self.area() / PI).sqrt() } } +# impl Shape for CircleStruct { fn area(&self) -> f64 { PI * square(self.radius) } } let concrete = @CircleStruct{center:Point{x:3f,y:4f},radius:5f}; let mycircle: @Circle = concrete as @Circle; diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index 3103731a52faf..d6de4f25f6eef 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -10,8 +10,6 @@ //! Operations and constants for `f32` #[allow(missing_doc)]; -#[allow(non_uppercase_statics)]; -#[allow(non_uppercase_pattern_statics)]; use default::Default; use libc::c_int; @@ -112,11 +110,11 @@ delegate!( // These are not defined inside consts:: for consistency with // the integer types -pub static NaN: f32 = 0.0_f32/0.0_f32; +pub static NAN: f32 = 0.0_f32/0.0_f32; -pub static infinity: f32 = 1.0_f32/0.0_f32; +pub static INFINITY: f32 = 1.0_f32/0.0_f32; -pub static neg_infinity: f32 = -1.0_f32/0.0_f32; +pub static NEG_INFINITY: f32 = -1.0_f32/0.0_f32; // FIXME (#1999): replace the predicates below with llvm intrinsics or // calls to the libmath macros in the rust runtime for performance. @@ -128,43 +126,43 @@ pub mod consts { // FIXME (requires Issue #1433 to fix): replace with mathematical // staticants from cmath. /// Archimedes' constant - pub static pi: f32 = 3.14159265358979323846264338327950288_f32; + pub static PI: f32 = 3.14159265358979323846264338327950288_f32; /// pi/2.0 - pub static frac_pi_2: f32 = 1.57079632679489661923132169163975144_f32; + pub static FRAC_PI_2: f32 = 1.57079632679489661923132169163975144_f32; /// pi/4.0 - pub static frac_pi_4: f32 = 0.785398163397448309615660845819875721_f32; + pub static FRAC_PI_4: f32 = 0.785398163397448309615660845819875721_f32; /// 1.0/pi - pub static frac_1_pi: f32 = 0.318309886183790671537767526745028724_f32; + pub static FRAC_1_PI: f32 = 0.318309886183790671537767526745028724_f32; /// 2.0/pi - pub static frac_2_pi: f32 = 0.636619772367581343075535053490057448_f32; + pub static FRAC_2_PI: f32 = 0.636619772367581343075535053490057448_f32; /// 2.0/sqrt(pi) - pub static frac_2_sqrtpi: f32 = 1.12837916709551257389615890312154517_f32; + pub static FRAC_2_SQRTPI: f32 = 1.12837916709551257389615890312154517_f32; /// sqrt(2.0) - pub static sqrt2: f32 = 1.41421356237309504880168872420969808_f32; + pub static SQRT2: f32 = 1.41421356237309504880168872420969808_f32; /// 1.0/sqrt(2.0) - pub static frac_1_sqrt2: f32 = 0.707106781186547524400844362104849039_f32; + pub static FRAC_1_SQRT2: f32 = 0.707106781186547524400844362104849039_f32; /// Euler's number - pub static e: f32 = 2.71828182845904523536028747135266250_f32; + pub static E: f32 = 2.71828182845904523536028747135266250_f32; /// log2(e) - pub static log2_e: f32 = 1.44269504088896340735992468100189214_f32; + pub static LOG2_E: f32 = 1.44269504088896340735992468100189214_f32; /// log10(e) - pub static log10_e: f32 = 0.434294481903251827651128918916605082_f32; + pub static LOG10_E: f32 = 0.434294481903251827651128918916605082_f32; /// ln(2.0) - pub static ln_2: f32 = 0.693147180559945309417232121458176568_f32; + pub static LN_2: f32 = 0.693147180559945309417232121458176568_f32; /// ln(10.0) - pub static ln_10: f32 = 2.30258509299404568401799145468436421_f32; + pub static LN_10: f32 = 2.30258509299404568401799145468436421_f32; } impl Num for f32 {} @@ -204,7 +202,7 @@ impl Ord for f32 { } impl Orderable for f32 { - /// Returns `NaN` if either of the numbers are `NaN`. + /// Returns `NAN` if either of the numbers are `NAN`. #[inline] fn min(&self, other: &f32) -> f32 { match () { @@ -215,7 +213,7 @@ impl Orderable for f32 { } } - /// Returns `NaN` if either of the numbers are `NaN`. + /// Returns `NAN` if either of the numbers are `NAN`. #[inline] fn max(&self, other: &f32) -> f32 { match () { @@ -227,7 +225,7 @@ impl Orderable for f32 { } /// Returns the number constrained within the range `mn <= self <= mx`. - /// If any of the numbers are `NaN` then `NaN` is returned. + /// If any of the numbers are `NAN` then `NAN` is returned. #[inline] fn clamp(&self, mn: &f32, mx: &f32) -> f32 { match () { @@ -295,7 +293,7 @@ impl Neg for f32 { } impl Signed for f32 { - /// Computes the absolute value. Returns `NaN` if the number is `NaN`. + /// Computes the absolute value. Returns `NAN` if the number is `NAN`. #[inline] fn abs(&self) -> f32 { abs(*self) } @@ -309,30 +307,30 @@ impl Signed for f32 { /// /// # 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 + /// - `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) -> f32 { - if self.is_nan() { NaN } else { copysign(1.0, *self) } + if self.is_nan() { NAN } else { copysign(1.0, *self) } } - /// Returns `true` if the number is positive, including `+0.0` and `infinity` + /// 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 } + 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` + /// 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 } + fn is_negative(&self) -> bool { *self < 0.0 || (1.0 / *self) == NEG_INFINITY } } impl Round for f32 { - /// Round half-way cases toward `neg_infinity` + /// Round half-way cases toward `NEG_INFINITY` #[inline] fn floor(&self) -> f32 { floor(*self) } - /// Round half-way cases toward `infinity` + /// Round half-way cases toward `INFINITY` #[inline] fn ceil(&self) -> f32 { ceil(*self) } @@ -449,13 +447,13 @@ impl Hyperbolic for f32 { /// # Returns /// /// - on success, the inverse hyperbolic sine of `self` will be returned - /// - `self` if `self` is `0.0`, `-0.0`, `infinity`, or `neg_infinity` - /// - `NaN` if `self` is `NaN` + /// - `self` if `self` is `0.0`, `-0.0`, `INFINITY`, or `NEG_INFINITY` + /// - `NAN` if `self` is `NAN` /// #[inline] fn asinh(&self) -> f32 { match *self { - neg_infinity => neg_infinity, + NEG_INFINITY => NEG_INFINITY, x => (x + ((x * x) + 1.0).sqrt()).ln(), } } @@ -466,8 +464,8 @@ impl Hyperbolic for f32 { /// # Returns /// /// - on success, the inverse hyperbolic cosine of `self` will be returned - /// - `infinity` if `self` is `infinity` - /// - `NaN` if `self` is `NaN` or `self < 1.0` (including `neg_infinity`) + /// - `INFINITY` if `self` is `INFINITY` + /// - `NAN` if `self` is `NAN` or `self < 1.0` (including `NEG_INFINITY`) /// #[inline] fn acosh(&self) -> f32 { @@ -484,10 +482,10 @@ impl Hyperbolic for f32 { /// /// - on success, the inverse hyperbolic tangent of `self` will be returned /// - `self` if `self` is `0.0` or `-0.0` - /// - `infinity` if `self` is `1.0` - /// - `neg_infinity` if `self` is `-1.0` - /// - `NaN` if the `self` is `NaN` or outside the domain of `-1.0 <= self <= 1.0` - /// (including `infinity` and `neg_infinity`) + /// - `INFINITY` if `self` is `1.0` + /// - `NEG_INFINITY` if `self` is `-1.0` + /// - `NAN` if the `self` is `NAN` or outside the domain of `-1.0 <= self <= 1.0` + /// (including `INFINITY` and `NEG_INFINITY`) /// #[inline] fn atanh(&self) -> f32 { @@ -821,7 +819,7 @@ impl num::ToStrRadix for f32 { let (r, special) = strconv::float_to_str_common( *self, rdx, true, strconv::SignNeg, strconv::DigAll); if special { fail!("number has a special value, \ - try to_str_radix_special() if those are expected") } + try to_str_radix_special() if those are expected") } r } } @@ -850,7 +848,7 @@ impl num::ToStrRadix for f32 { /// /// # Return value /// -/// `none` if the string did not represent a valid number. Otherwise, +/// `None` if the string did not represent a valid number. Otherwise, /// `Some(n)` where `n` is the floating-point number represented by `[num]`. /// #[inline] @@ -884,7 +882,7 @@ impl FromStr for f32 { /// /// # Return value /// - /// `none` if the string did not represent a valid number. Otherwise, + /// `None` if the string did not represent a valid number. Otherwise, /// `Some(n)` where `n` is the floating-point number represented by `num`. /// #[inline] @@ -911,7 +909,7 @@ impl num::FromStrRadix for f32 { /// /// # Return value /// - /// `none` if the string did not represent a valid number. Otherwise, + /// `None` if the string did not represent a valid number. Otherwise, /// `Some(n)` where `n` is the floating-point number represented by `num`. /// #[inline] @@ -1122,14 +1120,14 @@ mod tests { #[test] pub fn test_abs() { - assert_eq!(infinity.abs(), infinity); + assert_eq!(INFINITY.abs(), INFINITY); assert_eq!(1f32.abs(), 1f32); assert_eq!(0f32.abs(), 0f32); assert_eq!((-0f32).abs(), 0f32); assert_eq!((-1f32).abs(), 1f32); - assert_eq!(neg_infinity.abs(), infinity); - assert_eq!((1f32/neg_infinity).abs(), 0f32); - assert!(NaN.abs().is_nan()); + assert_eq!(NEG_INFINITY.abs(), INFINITY); + assert_eq!((1f32/NEG_INFINITY).abs(), 0f32); + assert!(NAN.abs().is_nan()); } #[test] @@ -1138,52 +1136,52 @@ mod tests { assert_eq!(1f32.abs_sub(&1f32), 0f32); assert_eq!(1f32.abs_sub(&0f32), 1f32); assert_eq!(1f32.abs_sub(&-1f32), 2f32); - assert_eq!(neg_infinity.abs_sub(&0f32), 0f32); - assert_eq!(infinity.abs_sub(&1f32), infinity); - assert_eq!(0f32.abs_sub(&neg_infinity), infinity); - assert_eq!(0f32.abs_sub(&infinity), 0f32); + assert_eq!(NEG_INFINITY.abs_sub(&0f32), 0f32); + assert_eq!(INFINITY.abs_sub(&1f32), INFINITY); + assert_eq!(0f32.abs_sub(&NEG_INFINITY), INFINITY); + assert_eq!(0f32.abs_sub(&INFINITY), 0f32); } #[test] #[ignore(cfg(windows))] // FIXME #8663 fn test_abs_sub_nowin() { - assert!(NaN.abs_sub(&-1f32).is_nan()); - assert!(1f32.abs_sub(&NaN).is_nan()); + assert!(NAN.abs_sub(&-1f32).is_nan()); + assert!(1f32.abs_sub(&NAN).is_nan()); } #[test] fn test_signum() { - assert_eq!(infinity.signum(), 1f32); + assert_eq!(INFINITY.signum(), 1f32); assert_eq!(1f32.signum(), 1f32); assert_eq!(0f32.signum(), 1f32); assert_eq!((-0f32).signum(), -1f32); assert_eq!((-1f32).signum(), -1f32); - assert_eq!(neg_infinity.signum(), -1f32); - assert_eq!((1f32/neg_infinity).signum(), -1f32); - assert!(NaN.signum().is_nan()); + assert_eq!(NEG_INFINITY.signum(), -1f32); + assert_eq!((1f32/NEG_INFINITY).signum(), -1f32); + assert!(NAN.signum().is_nan()); } #[test] fn test_is_positive() { - assert!(infinity.is_positive()); + assert!(INFINITY.is_positive()); assert!(1f32.is_positive()); assert!(0f32.is_positive()); assert!(!(-0f32).is_positive()); assert!(!(-1f32).is_positive()); - assert!(!neg_infinity.is_positive()); - assert!(!(1f32/neg_infinity).is_positive()); - assert!(!NaN.is_positive()); + assert!(!NEG_INFINITY.is_positive()); + assert!(!(1f32/NEG_INFINITY).is_positive()); + assert!(!NAN.is_positive()); } #[test] fn test_is_negative() { - assert!(!infinity.is_negative()); + assert!(!INFINITY.is_negative()); assert!(!1f32.is_negative()); assert!(!0f32.is_negative()); assert!((-0f32).is_negative()); assert!((-1f32).is_negative()); - assert!(neg_infinity.is_negative()); - assert!((1f32/neg_infinity).is_negative()); - assert!(!NaN.is_negative()); + assert!(NEG_INFINITY.is_negative()); + assert!((1f32/NEG_INFINITY).is_negative()); + assert!(!NAN.is_negative()); } #[test] diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index da8270703d72f..5feab20ba81d3 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -11,8 +11,6 @@ //! Operations and constants for `f64` #[allow(missing_doc)]; -#[allow(non_uppercase_statics)]; -#[allow(non_uppercase_pattern_statics)]; use default::Default; use libc::c_int; @@ -122,27 +120,27 @@ delegate!( // These are not defined inside consts:: for consistency with // the integer types -pub static radix: uint = 2u; +pub static RADIX: uint = 2u; -pub static mantissa_digits: uint = 53u; -pub static digits: uint = 15u; +pub static MANTISSA_DIGITS: uint = 53u; +pub static DIGITS: uint = 15u; -pub static epsilon: f64 = 2.2204460492503131e-16_f64; +pub static EPSILON: f64 = 2.2204460492503131e-16_f64; -pub static min_value: f64 = 2.2250738585072014e-308_f64; -pub static max_value: f64 = 1.7976931348623157e+308_f64; +pub static MIN_VALUE: f64 = 2.2250738585072014e-308_f64; +pub static MAX_VALUE: f64 = 1.7976931348623157e+308_f64; -pub static min_exp: int = -1021; -pub static max_exp: int = 1024; +pub static MIN_EXP: int = -1021; +pub static MAX_EXP: int = 1024; -pub static min_10_exp: int = -307; -pub static max_10_exp: int = 308; +pub static MIN_10_EXP: int = -307; +pub static MAX_10_EXP: int = 308; -pub static NaN: f64 = 0.0_f64/0.0_f64; +pub static NAN: f64 = 0.0_f64/0.0_f64; -pub static infinity: f64 = 1.0_f64/0.0_f64; +pub static INFINITY: f64 = 1.0_f64/0.0_f64; -pub static neg_infinity: f64 = -1.0_f64/0.0_f64; +pub static NEG_INFINITY: f64 = -1.0_f64/0.0_f64; // FIXME (#1999): add is_normal, is_subnormal, and fpclassify @@ -151,43 +149,43 @@ pub mod consts { // FIXME (requires Issue #1433 to fix): replace with mathematical // constants from cmath. /// Archimedes' constant - pub static pi: f64 = 3.14159265358979323846264338327950288_f64; + pub static PI: f64 = 3.14159265358979323846264338327950288_f64; /// pi/2.0 - pub static frac_pi_2: f64 = 1.57079632679489661923132169163975144_f64; + pub static FRAC_PI_2: f64 = 1.57079632679489661923132169163975144_f64; /// pi/4.0 - pub static frac_pi_4: f64 = 0.785398163397448309615660845819875721_f64; + pub static FRAC_PI_4: f64 = 0.785398163397448309615660845819875721_f64; /// 1.0/pi - pub static frac_1_pi: f64 = 0.318309886183790671537767526745028724_f64; + pub static FRAC_1_PI: f64 = 0.318309886183790671537767526745028724_f64; /// 2.0/pi - pub static frac_2_pi: f64 = 0.636619772367581343075535053490057448_f64; + pub static FRAC_2_PI: f64 = 0.636619772367581343075535053490057448_f64; /// 2.0/sqrt(pi) - pub static frac_2_sqrtpi: f64 = 1.12837916709551257389615890312154517_f64; + pub static FRAC_2_SQRTPI: f64 = 1.12837916709551257389615890312154517_f64; /// sqrt(2.0) - pub static sqrt2: f64 = 1.41421356237309504880168872420969808_f64; + pub static SQRT2: f64 = 1.41421356237309504880168872420969808_f64; /// 1.0/sqrt(2.0) - pub static frac_1_sqrt2: f64 = 0.707106781186547524400844362104849039_f64; + pub static FRAC_1_SQRT2: f64 = 0.707106781186547524400844362104849039_f64; /// Euler's number - pub static e: f64 = 2.71828182845904523536028747135266250_f64; + pub static E: f64 = 2.71828182845904523536028747135266250_f64; /// log2(e) - pub static log2_e: f64 = 1.44269504088896340735992468100189214_f64; + pub static LOG2_E: f64 = 1.44269504088896340735992468100189214_f64; /// log10(e) - pub static log10_e: f64 = 0.434294481903251827651128918916605082_f64; + pub static LOG10_E: f64 = 0.434294481903251827651128918916605082_f64; /// ln(2.0) - pub static ln_2: f64 = 0.693147180559945309417232121458176568_f64; + pub static LN_2: f64 = 0.693147180559945309417232121458176568_f64; /// ln(10.0) - pub static ln_10: f64 = 2.30258509299404568401799145468436421_f64; + pub static LN_10: f64 = 2.30258509299404568401799145468436421_f64; } impl Num for f64 {} @@ -227,7 +225,7 @@ impl Ord for f64 { } impl Orderable for f64 { - /// Returns `NaN` if either of the numbers are `NaN`. + /// Returns `NAN` if either of the numbers are `NAN`. #[inline] fn min(&self, other: &f64) -> f64 { match () { @@ -238,7 +236,7 @@ impl Orderable for f64 { } } - /// Returns `NaN` if either of the numbers are `NaN`. + /// Returns `NAN` if either of the numbers are `NAN`. #[inline] fn max(&self, other: &f64) -> f64 { match () { @@ -250,7 +248,7 @@ impl Orderable for f64 { } /// Returns the number constrained within the range `mn <= self <= mx`. - /// If any of the numbers are `NaN` then `NaN` is returned. + /// If any of the numbers are `NAN` then `NAN` is returned. #[inline] fn clamp(&self, mn: &f64, mx: &f64) -> f64 { match () { @@ -313,7 +311,7 @@ impl Neg for f64 { } impl Signed for f64 { - /// Computes the absolute value. Returns `NaN` if the number is `NaN`. + /// Computes the absolute value. Returns `NAN` if the number is `NAN`. #[inline] fn abs(&self) -> f64 { abs(*self) } @@ -327,30 +325,30 @@ impl Signed for f64 { /// /// # 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 + /// - `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.is_nan() { NaN } else { copysign(1.0, *self) } + if self.is_nan() { NAN } else { copysign(1.0, *self) } } - /// Returns `true` if the number is positive, including `+0.0` and `infinity` + /// 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 } + 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` + /// 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 } + fn is_negative(&self) -> bool { *self < 0.0 || (1.0 / *self) == NEG_INFINITY } } impl Round for f64 { - /// Round half-way cases toward `neg_infinity` + /// Round half-way cases toward `NEG_INFINITY` #[inline] fn floor(&self) -> f64 { floor(*self) } - /// Round half-way cases toward `infinity` + /// Round half-way cases toward `INFINITY` #[inline] fn ceil(&self) -> f64 { ceil(*self) } @@ -467,13 +465,13 @@ impl Hyperbolic for f64 { /// # Returns /// /// - on success, the inverse hyperbolic sine of `self` will be returned - /// - `self` if `self` is `0.0`, `-0.0`, `infinity`, or `neg_infinity` - /// - `NaN` if `self` is `NaN` + /// - `self` if `self` is `0.0`, `-0.0`, `INFINITY`, or `NEG_INFINITY` + /// - `NAN` if `self` is `NAN` /// #[inline] fn asinh(&self) -> f64 { match *self { - neg_infinity => neg_infinity, + NEG_INFINITY => NEG_INFINITY, x => (x + ((x * x) + 1.0).sqrt()).ln(), } } @@ -484,8 +482,8 @@ impl Hyperbolic for f64 { /// # Returns /// /// - on success, the inverse hyperbolic cosine of `self` will be returned - /// - `infinity` if `self` is `infinity` - /// - `NaN` if `self` is `NaN` or `self < 1.0` (including `neg_infinity`) + /// - `INFINITY` if `self` is `INFINITY` + /// - `NAN` if `self` is `NAN` or `self < 1.0` (including `NEG_INFINITY`) /// #[inline] fn acosh(&self) -> f64 { @@ -502,10 +500,10 @@ impl Hyperbolic for f64 { /// /// - on success, the inverse hyperbolic tangent of `self` will be returned /// - `self` if `self` is `0.0` or `-0.0` - /// - `infinity` if `self` is `1.0` - /// - `neg_infinity` if `self` is `-1.0` - /// - `NaN` if the `self` is `NaN` or outside the domain of `-1.0 <= self <= 1.0` - /// (including `infinity` and `neg_infinity`) + /// - `INFINITY` if `self` is `1.0` + /// - `NEG_INFINITY` if `self` is `-1.0` + /// - `NAN` if the `self` is `NAN` or outside the domain of `-1.0 <= self <= 1.0` + /// (including `INFINITY` and `NEG_INFINITY`) /// #[inline] fn atanh(&self) -> f64 { @@ -861,7 +859,7 @@ impl num::ToStrRadix for f64 { /// /// # Failure /// - /// Fails if called on a special value like `inf`, `-inf` or `NaN` due to + /// Fails if called on a special value like `inf`, `-inf` or `NAN` due to /// possible misinterpretation of the result at higher bases. If those values /// are expected, use `to_str_radix_special()` instead. #[inline] @@ -898,7 +896,7 @@ impl num::ToStrRadix for f64 { /// /// # Return value /// -/// `none` if the string did not represent a valid number. Otherwise, +/// `None` if the string did not represent a valid number. Otherwise, /// `Some(n)` where `n` is the floating-point number represented by `[num]`. /// #[inline] @@ -959,7 +957,7 @@ impl num::FromStrRadix for f64 { /// /// # Return value /// - /// `none` if the string did not represent a valid number. Otherwise, + /// `None` if the string did not represent a valid number. Otherwise, /// `Some(n)` where `n` is the floating-point number represented by `num`. /// #[inline] @@ -1173,14 +1171,14 @@ mod tests { #[test] pub fn test_abs() { - assert_eq!(infinity.abs(), infinity); + assert_eq!(INFINITY.abs(), INFINITY); assert_eq!(1f64.abs(), 1f64); assert_eq!(0f64.abs(), 0f64); assert_eq!((-0f64).abs(), 0f64); assert_eq!((-1f64).abs(), 1f64); - assert_eq!(neg_infinity.abs(), infinity); - assert_eq!((1f64/neg_infinity).abs(), 0f64); - assert!(NaN.abs().is_nan()); + assert_eq!(NEG_INFINITY.abs(), INFINITY); + assert_eq!((1f64/NEG_INFINITY).abs(), 0f64); + assert!(NAN.abs().is_nan()); } #[test] @@ -1189,52 +1187,52 @@ mod tests { assert_eq!(1f64.abs_sub(&1f64), 0f64); assert_eq!(1f64.abs_sub(&0f64), 1f64); assert_eq!(1f64.abs_sub(&-1f64), 2f64); - assert_eq!(neg_infinity.abs_sub(&0f64), 0f64); - assert_eq!(infinity.abs_sub(&1f64), infinity); - assert_eq!(0f64.abs_sub(&neg_infinity), infinity); - assert_eq!(0f64.abs_sub(&infinity), 0f64); + assert_eq!(NEG_INFINITY.abs_sub(&0f64), 0f64); + assert_eq!(INFINITY.abs_sub(&1f64), INFINITY); + assert_eq!(0f64.abs_sub(&NEG_INFINITY), INFINITY); + assert_eq!(0f64.abs_sub(&INFINITY), 0f64); } #[test] #[ignore(cfg(windows))] // FIXME #8663 fn test_abs_sub_nowin() { - assert!(NaN.abs_sub(&-1f64).is_nan()); - assert!(1f64.abs_sub(&NaN).is_nan()); + assert!(NAN.abs_sub(&-1f64).is_nan()); + assert!(1f64.abs_sub(&NAN).is_nan()); } #[test] fn test_signum() { - assert_eq!(infinity.signum(), 1f64); + assert_eq!(INFINITY.signum(), 1f64); assert_eq!(1f64.signum(), 1f64); assert_eq!(0f64.signum(), 1f64); assert_eq!((-0f64).signum(), -1f64); assert_eq!((-1f64).signum(), -1f64); - assert_eq!(neg_infinity.signum(), -1f64); - assert_eq!((1f64/neg_infinity).signum(), -1f64); - assert!(NaN.signum().is_nan()); + assert_eq!(NEG_INFINITY.signum(), -1f64); + assert_eq!((1f64/NEG_INFINITY).signum(), -1f64); + assert!(NAN.signum().is_nan()); } #[test] fn test_is_positive() { - assert!(infinity.is_positive()); + assert!(INFINITY.is_positive()); assert!(1f64.is_positive()); assert!(0f64.is_positive()); assert!(!(-0f64).is_positive()); assert!(!(-1f64).is_positive()); - assert!(!neg_infinity.is_positive()); - assert!(!(1f64/neg_infinity).is_positive()); - assert!(!NaN.is_positive()); + assert!(!NEG_INFINITY.is_positive()); + assert!(!(1f64/NEG_INFINITY).is_positive()); + assert!(!NAN.is_positive()); } #[test] fn test_is_negative() { - assert!(!infinity.is_negative()); + assert!(!INFINITY.is_negative()); assert!(!1f64.is_negative()); assert!(!0f64.is_negative()); assert!((-0f64).is_negative()); assert!((-1f64).is_negative()); - assert!(neg_infinity.is_negative()); - assert!((1f64/neg_infinity).is_negative()); - assert!(!NaN.is_negative()); + assert!(NEG_INFINITY.is_negative()); + assert!((1f64/NEG_INFINITY).is_negative()); + assert!(!NAN.is_negative()); } #[test] diff --git a/src/libstd/num/num.rs b/src/libstd/num/num.rs index d49759515b3b9..3097a8e138ef0 100644 --- a/src/libstd/num/num.rs +++ b/src/libstd/num/num.rs @@ -86,9 +86,9 @@ pub trait Signed: Num /// Returns the sign of the number. /// /// For float, f32, f64: -/// - `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` +/// - `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` /// /// For int: /// - `0` if the number is zero diff --git a/src/test/bench/noise.rs b/src/test/bench/noise.rs index a424c880c385f..65f0f7a84aedf 100644 --- a/src/test/bench/noise.rs +++ b/src/test/bench/noise.rs @@ -16,7 +16,7 @@ fn lerp(a: f32, b: f32, v: f32) -> f32 { a * (1.0 - v) + b * v } fn smooth(v: f32) -> f32 { v * v * (3.0 - 2.0 * v) } fn random_gradient(r: &mut R) -> Vec2 { - let v = 2.0 * f64::consts::pi * r.gen(); + let v = 2.0 * f64::consts::PI * r.gen(); Vec2 { x: v.cos() as f32, y: v.sin() as f32, diff --git a/src/test/compile-fail/issue-6804.rs b/src/test/compile-fail/issue-6804.rs index 4aa45c78fc889..c2e0c40d8ca2f 100644 --- a/src/test/compile-fail/issue-6804.rs +++ b/src/test/compile-fail/issue-6804.rs @@ -1,18 +1,16 @@ -#[allow(non_uppercase_pattern_statics)]; - // Matching against NaN should result in a warning -use std::f64::NaN; +use std::f64::NAN; fn main() { - let x = NaN; + let x = NAN; match x { - NaN => {}, + NAN => {}, _ => {}, }; //~^^^ WARNING unmatchable NaN in pattern, use the is_nan method in a guard instead match [x, 1.0] { - [NaN, _] => {}, + [NAN, _] => {}, _ => {}, }; //~^^^ WARNING unmatchable NaN in pattern, use the is_nan method in a guard instead diff --git a/src/test/run-pass/intrinsics-math.rs b/src/test/run-pass/intrinsics-math.rs index 085ce6569083a..2a6143979feb1 100644 --- a/src/test/run-pass/intrinsics-math.rs +++ b/src/test/run-pass/intrinsics-math.rs @@ -61,31 +61,31 @@ pub fn main() { assert!((powif64(23.2f64, 2i32).approx_eq(&538.24f64))); assert!((sinf32(0f32).approx_eq(&0f32))); - assert!((sinf64(f64::consts::pi / 2f64).approx_eq(&1f64))); + assert!((sinf64(f64::consts::PI / 2f64).approx_eq(&1f64))); assert!((cosf32(0f32).approx_eq(&1f32))); - assert!((cosf64(f64::consts::pi * 2f64).approx_eq(&1f64))); + assert!((cosf64(f64::consts::PI * 2f64).approx_eq(&1f64))); assert!((powf32(25f32, -2f32).approx_eq(&0.0016f32))); assert!((powf64(400f64, 0.5f64).approx_eq(&20f64))); - assert!((fabsf32(expf32(1f32) - f32::consts::e).approx_eq(&0f32))); - assert!((expf64(1f64).approx_eq(&f64::consts::e))); + assert!((fabsf32(expf32(1f32) - f32::consts::E).approx_eq(&0f32))); + assert!((expf64(1f64).approx_eq(&f64::consts::E))); assert!((exp2f32(10f32).approx_eq(&1024f32))); assert!((exp2f64(50f64).approx_eq(&1125899906842624f64))); - assert!((fabsf32(logf32(f32::consts::e) - 1f32).approx_eq(&0f32))); + assert!((fabsf32(logf32(f32::consts::E) - 1f32).approx_eq(&0f32))); assert!((logf64(1f64).approx_eq(&0f64))); assert!((log10f32(10f32).approx_eq(&1f32))); - assert!((log10f64(f64::consts::e).approx_eq(&f64::consts::log10_e))); + assert!((log10f64(f64::consts::E).approx_eq(&f64::consts::LOG10_E))); assert!((log2f32(8f32).approx_eq(&3f32))); - assert!((log2f64(f64::consts::e).approx_eq(&f64::consts::log2_e))); + assert!((log2f64(f64::consts::E).approx_eq(&f64::consts::LOG2_E))); assert!((fmaf32(1.0f32, 2.0f32, 5.0f32).approx_eq(&7.0f32))); - assert!((fmaf64(0.0f64, -2.0f64, f64::consts::e).approx_eq(&f64::consts::e))); + assert!((fmaf64(0.0f64, -2.0f64, f64::consts::E).approx_eq(&f64::consts::E))); assert!((fabsf32(-1.0f32).approx_eq(&1.0f32))); assert!((fabsf64(34.2f64).approx_eq(&34.2f64))); diff --git a/src/test/run-pass/issue-3753.rs b/src/test/run-pass/issue-3753.rs index 49759f3b85b98..fe2d729bc9e44 100644 --- a/src/test/run-pass/issue-3753.rs +++ b/src/test/run-pass/issue-3753.rs @@ -27,7 +27,7 @@ pub enum Shape { impl Shape { pub fn area(&self, sh: Shape) -> f64 { match sh { - Circle(_, size) => f64::consts::pi * size * size, + Circle(_, size) => f64::consts::PI * size * size, Rectangle(Point {x, y}, Point {x: x2, y: y2}) => (x2 - x) * (y2 - y) } }