From d9874c0885118d1b4f55ca928dc5ba6d0adf88c6 Mon Sep 17 00:00:00 2001 From: Chris Morgan Date: Thu, 19 Sep 2013 15:37:34 +1000 Subject: [PATCH] Rename the NaN and is_NaN methods to lowercase. This is for consistency in naming conventions. - ``std::num::Float::NaN()`` is changed to ``nan()``; - ``std::num::Float.is_NaN()`` is changed to ``is_nan()``; and - ``std::num::strconv::NumStrConv::NaN()`` is changed to ``nan()``. Fixes #9319. --- src/librustc/middle/check_match.rs | 4 +- src/libstd/num/f32.rs | 72 ++++++++++++------------- src/libstd/num/f64.rs | 84 ++++++++++++++--------------- src/libstd/num/float.rs | 62 ++++++++++----------- src/libstd/num/num.rs | 4 +- src/libstd/num/strconv.rs | 8 +-- src/test/compile-fail/issue-6804.rs | 4 +- src/test/run-pass/float-nan.rs | 38 ++++++------- 8 files changed, 138 insertions(+), 138 deletions(-) diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 2a38492a6e5..8fc98ac10c7 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -126,7 +126,7 @@ pub fn check_arms(cx: &MatchCheckCtxt, arms: &[Arm]) { Some(&DefStatic(did, false)) => { let const_expr = lookup_const_by_id(cx.tcx, did).unwrap(); match eval_const_expr(cx.tcx, const_expr) { - const_float(f) if f.is_NaN() => true, + const_float(f) if f.is_nan() => true, _ => false } } @@ -136,7 +136,7 @@ pub fn check_arms(cx: &MatchCheckCtxt, arms: &[Arm]) { do walk_pat(*pat) |p| { if pat_matches_nan(p) { cx.tcx.sess.span_warn(p.span, "unmatchable NaN in pattern, \ - use the is_NaN method in a guard instead"); + use the is_nan method in a guard instead"); } true }; diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index 2787e028645..a2a0a1ab13b 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -207,8 +207,8 @@ impl Orderable for f32 { #[inline] fn min(&self, other: &f32) -> f32 { match () { - _ if self.is_NaN() => *self, - _ if other.is_NaN() => *other, + _ if self.is_nan() => *self, + _ if other.is_nan() => *other, _ if *self < *other => *self, _ => *other, } @@ -218,8 +218,8 @@ impl Orderable for f32 { #[inline] fn max(&self, other: &f32) -> f32 { match () { - _ if self.is_NaN() => *self, - _ if other.is_NaN() => *other, + _ if self.is_nan() => *self, + _ if other.is_nan() => *other, _ if *self > *other => *self, _ => *other, } @@ -230,7 +230,7 @@ impl Orderable for f32 { #[inline] fn clamp(&self, mn: &f32, mx: &f32) -> f32 { match () { - _ if self.is_NaN() => *self, + _ if self.is_nan() => *self, _ if !(*self <= *mx) => *mx, _ if !(*self >= *mn) => *mn, _ => *self, @@ -314,7 +314,7 @@ impl Signed for f32 { /// #[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` @@ -471,7 +471,7 @@ impl Hyperbolic for f32 { #[inline] fn acosh(&self) -> f32 { match *self { - x if x < 1.0 => Float::NaN(), + x if x < 1.0 => Float::nan(), x => (x + ((x * x) - 1.0).sqrt()).ln(), } } @@ -593,7 +593,7 @@ impl Primitive for f32 { impl Float for f32 { #[inline] - fn NaN() -> f32 { 0.0 / 0.0 } + fn nan() -> f32 { 0.0 / 0.0 } #[inline] fn infinity() -> f32 { 1.0 / 0.0 } @@ -606,7 +606,7 @@ impl Float for f32 { /// Returns `true` if the number is NaN #[inline] - fn is_NaN(&self) -> bool { *self != *self } + fn is_nan(&self) -> bool { *self != *self } /// Returns `true` if the number is infinite #[inline] @@ -617,7 +617,7 @@ impl Float for f32 { /// Returns `true` if the number is neither infinite or NaN #[inline] fn is_finite(&self) -> bool { - !(self.is_NaN() || self.is_infinite()) + !(self.is_nan() || self.is_infinite()) } /// Returns `true` if the number is neither zero, infinite, subnormal or NaN @@ -949,10 +949,10 @@ mod tests { assert_eq!(8f32.clamp(&2f32, &4f32), 4f32); assert_eq!(3f32.clamp(&2f32, &4f32), 3f32); - let nan: f32 = Float::NaN(); - assert!(3f32.clamp(&nan, &4f32).is_NaN()); - assert!(3f32.clamp(&2f32, &nan).is_NaN()); - assert!(nan.clamp(&2f32, &4f32).is_NaN()); + let nan: f32 = Float::nan(); + assert!(3f32.clamp(&nan, &4f32).is_nan()); + assert!(3f32.clamp(&2f32, &nan).is_nan()); + assert!(nan.clamp(&2f32, &4f32).is_nan()); } #[test] @@ -1032,10 +1032,10 @@ mod tests { let inf: f32 = Float::infinity(); let neg_inf: f32 = Float::neg_infinity(); - let nan: f32 = Float::NaN(); + let nan: f32 = Float::nan(); assert_eq!(inf.asinh(), inf); assert_eq!(neg_inf.asinh(), neg_inf); - assert!(nan.asinh().is_NaN()); + assert!(nan.asinh().is_nan()); assert_approx_eq!(2.0f32.asinh(), 1.443635475178810342493276740273105f32); assert_approx_eq!((-2.0f32).asinh(), -1.443635475178810342493276740273105f32); } @@ -1043,14 +1043,14 @@ mod tests { #[test] fn test_acosh() { assert_eq!(1.0f32.acosh(), 0.0f32); - assert!(0.999f32.acosh().is_NaN()); + assert!(0.999f32.acosh().is_nan()); let inf: f32 = Float::infinity(); let neg_inf: f32 = Float::neg_infinity(); - let nan: f32 = Float::NaN(); + let nan: f32 = Float::nan(); assert_eq!(inf.acosh(), inf); - assert!(neg_inf.acosh().is_NaN()); - assert!(nan.acosh().is_NaN()); + assert!(neg_inf.acosh().is_nan()); + assert!(nan.acosh().is_nan()); assert_approx_eq!(2.0f32.acosh(), 1.31695789692481670862504634730796844f32); assert_approx_eq!(3.0f32.acosh(), 1.76274717403908605046521864995958461f32); } @@ -1065,15 +1065,15 @@ mod tests { assert_eq!(1.0f32.atanh(), inf32); assert_eq!((-1.0f32).atanh(), neg_inf32); - assert!(2f64.atanh().atanh().is_NaN()); - assert!((-2f64).atanh().atanh().is_NaN()); + assert!(2f64.atanh().atanh().is_nan()); + assert!((-2f64).atanh().atanh().is_nan()); let inf64: f32 = Float::infinity(); let neg_inf64: f32 = Float::neg_infinity(); - let nan32: f32 = Float::NaN(); - assert!(inf64.atanh().is_NaN()); - assert!(neg_inf64.atanh().is_NaN()); - assert!(nan32.atanh().is_NaN()); + let nan32: f32 = Float::nan(); + assert!(inf64.atanh().is_nan()); + assert!(neg_inf64.atanh().is_nan()); + assert!(nan32.atanh().is_nan()); assert_approx_eq!(0.5f32.atanh(), 0.54930614433405484569762261846126285f32); assert_approx_eq!((-0.5f32).atanh(), -0.54930614433405484569762261846126285f32); @@ -1125,7 +1125,7 @@ mod tests { assert_eq!((-1f32).abs(), 1f32); assert_eq!(neg_infinity.abs(), infinity); assert_eq!((1f32/neg_infinity).abs(), 0f32); - assert!(NaN.abs().is_NaN()); + assert!(NaN.abs().is_nan()); } #[test] @@ -1142,8 +1142,8 @@ mod tests { #[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] @@ -1155,7 +1155,7 @@ mod tests { assert_eq!((-1f32).signum(), -1f32); assert_eq!(neg_infinity.signum(), -1f32); assert_eq!((1f32/neg_infinity).signum(), -1f32); - assert!(NaN.signum().is_NaN()); + assert!(NaN.signum().is_nan()); } #[test] @@ -1200,7 +1200,7 @@ mod tests { #[test] fn test_is_normal() { - let nan: f32 = Float::NaN(); + let nan: f32 = Float::nan(); let inf: f32 = Float::infinity(); let neg_inf: f32 = Float::neg_infinity(); let zero: f32 = Zero::zero(); @@ -1217,7 +1217,7 @@ mod tests { #[test] fn test_classify() { - let nan: f32 = Float::NaN(); + let nan: f32 = Float::nan(); let inf: f32 = Float::infinity(); let neg_inf: f32 = Float::neg_infinity(); let zero: f32 = Zero::zero(); @@ -1246,10 +1246,10 @@ mod tests { let inf: f32 = Float::infinity(); let neg_inf: f32 = Float::neg_infinity(); - let nan: f32 = Float::NaN(); + let nan: f32 = Float::nan(); assert_eq!(Float::ldexp(inf, -123), inf); assert_eq!(Float::ldexp(neg_inf, -123), neg_inf); - assert!(Float::ldexp(nan, -123).is_NaN()); + assert!(Float::ldexp(nan, -123).is_nan()); } #[test] @@ -1273,9 +1273,9 @@ mod tests { fn test_frexp_nowin() { let inf: f32 = Float::infinity(); let neg_inf: f32 = Float::neg_infinity(); - let nan: f32 = Float::NaN(); + let nan: f32 = Float::nan(); assert_eq!(match inf.frexp() { (x, _) => x }, inf) assert_eq!(match neg_inf.frexp() { (x, _) => x }, neg_inf) - assert!(match nan.frexp() { (x, _) => x.is_NaN() }) + assert!(match nan.frexp() { (x, _) => x.is_nan() }) } } diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index afc22ec212b..826102cd434 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -230,8 +230,8 @@ impl Orderable for f64 { #[inline] fn min(&self, other: &f64) -> f64 { match () { - _ if self.is_NaN() => *self, - _ if other.is_NaN() => *other, + _ if self.is_nan() => *self, + _ if other.is_nan() => *other, _ if *self < *other => *self, _ => *other, } @@ -241,8 +241,8 @@ impl Orderable for f64 { #[inline] fn max(&self, other: &f64) -> f64 { match () { - _ if self.is_NaN() => *self, - _ if other.is_NaN() => *other, + _ if self.is_nan() => *self, + _ if other.is_nan() => *other, _ if *self > *other => *self, _ => *other, } @@ -253,7 +253,7 @@ impl Orderable for f64 { #[inline] fn clamp(&self, mn: &f64, mx: &f64) -> f64 { match () { - _ if self.is_NaN() => *self, + _ if self.is_nan() => *self, _ if !(*self <= *mx) => *mx, _ if !(*self >= *mn) => *mn, _ => *self, @@ -331,7 +331,7 @@ impl Signed for f64 { /// #[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` @@ -488,7 +488,7 @@ impl Hyperbolic for f64 { #[inline] fn acosh(&self) -> f64 { match *self { - x if x < 1.0 => Float::NaN(), + x if x < 1.0 => Float::nan(), x => (x + ((x * x) - 1.0).sqrt()).ln(), } } @@ -640,7 +640,7 @@ impl Primitive for f64 { impl Float for f64 { #[inline] - fn NaN() -> f64 { 0.0 / 0.0 } + fn nan() -> f64 { 0.0 / 0.0 } #[inline] fn infinity() -> f64 { 1.0 / 0.0 } @@ -653,7 +653,7 @@ impl Float for f64 { /// Returns `true` if the number is NaN #[inline] - fn is_NaN(&self) -> bool { *self != *self } + fn is_nan(&self) -> bool { *self != *self } /// Returns `true` if the number is infinite #[inline] @@ -664,7 +664,7 @@ impl Float for f64 { /// Returns `true` if the number is neither infinite or NaN #[inline] fn is_finite(&self) -> bool { - !(self.is_NaN() || self.is_infinite()) + !(self.is_nan() || self.is_infinite()) } /// Returns `true` if the number is neither zero, infinite, subnormal or NaN @@ -983,9 +983,9 @@ mod tests { assert_eq!(1f64.min(&2f64), 1f64); assert_eq!(2f64.min(&1f64), 1f64); - let nan: f64 = Float::NaN(); - assert!(1f64.min(&nan).is_NaN()); - assert!(nan.min(&1f64).is_NaN()); + let nan: f64 = Float::nan(); + assert!(1f64.min(&nan).is_nan()); + assert!(nan.min(&1f64).is_nan()); } #[test] @@ -993,9 +993,9 @@ mod tests { assert_eq!(1f64.max(&2f64), 2f64); assert_eq!(2f64.max(&1f64), 2f64); - let nan: f64 = Float::NaN(); - assert!(1f64.max(&nan).is_NaN()); - assert!(nan.max(&1f64).is_NaN()); + let nan: f64 = Float::nan(); + assert!(1f64.max(&nan).is_nan()); + assert!(nan.max(&1f64).is_nan()); } #[test] @@ -1004,10 +1004,10 @@ mod tests { assert_eq!(8f64.clamp(&2f64, &4f64), 4f64); assert_eq!(3f64.clamp(&2f64, &4f64), 3f64); - let nan: f64 = Float::NaN(); - assert!(3f64.clamp(&nan, &4f64).is_NaN()); - assert!(3f64.clamp(&2f64, &nan).is_NaN()); - assert!(nan.clamp(&2f64, &4f64).is_NaN()); + let nan: f64 = Float::nan(); + assert!(3f64.clamp(&nan, &4f64).is_nan()); + assert!(3f64.clamp(&2f64, &nan).is_nan()); + assert!(nan.clamp(&2f64, &4f64).is_nan()); } #[test] @@ -1087,10 +1087,10 @@ mod tests { let inf: f64 = Float::infinity(); let neg_inf: f64 = Float::neg_infinity(); - let nan: f64 = Float::NaN(); + let nan: f64 = Float::nan(); assert_eq!(inf.asinh(), inf); assert_eq!(neg_inf.asinh(), neg_inf); - assert!(nan.asinh().is_NaN()); + assert!(nan.asinh().is_nan()); assert_approx_eq!(2.0f64.asinh(), 1.443635475178810342493276740273105f64); assert_approx_eq!((-2.0f64).asinh(), -1.443635475178810342493276740273105f64); } @@ -1098,14 +1098,14 @@ mod tests { #[test] fn test_acosh() { assert_eq!(1.0f64.acosh(), 0.0f64); - assert!(0.999f64.acosh().is_NaN()); + assert!(0.999f64.acosh().is_nan()); let inf: f64 = Float::infinity(); let neg_inf: f64 = Float::neg_infinity(); - let nan: f64 = Float::NaN(); + let nan: f64 = Float::nan(); assert_eq!(inf.acosh(), inf); - assert!(neg_inf.acosh().is_NaN()); - assert!(nan.acosh().is_NaN()); + assert!(neg_inf.acosh().is_nan()); + assert!(nan.acosh().is_nan()); assert_approx_eq!(2.0f64.acosh(), 1.31695789692481670862504634730796844f64); assert_approx_eq!(3.0f64.acosh(), 1.76274717403908605046521864995958461f64); } @@ -1117,14 +1117,14 @@ mod tests { let inf: f64 = Float::infinity(); let neg_inf: f64 = Float::neg_infinity(); - let nan: f64 = Float::NaN(); + let nan: f64 = Float::nan(); assert_eq!(1.0f64.atanh(), inf); assert_eq!((-1.0f64).atanh(), neg_inf); - assert!(2f64.atanh().atanh().is_NaN()); - assert!((-2f64).atanh().atanh().is_NaN()); - assert!(inf.atanh().is_NaN()); - assert!(neg_inf.atanh().is_NaN()); - assert!(nan.atanh().is_NaN()); + assert!(2f64.atanh().atanh().is_nan()); + assert!((-2f64).atanh().atanh().is_nan()); + assert!(inf.atanh().is_nan()); + assert!(neg_inf.atanh().is_nan()); + assert!(nan.atanh().is_nan()); assert_approx_eq!(0.5f64.atanh(), 0.54930614433405484569762261846126285f64); assert_approx_eq!((-0.5f64).atanh(), -0.54930614433405484569762261846126285f64); } @@ -1175,7 +1175,7 @@ mod tests { assert_eq!((-1f64).abs(), 1f64); assert_eq!(neg_infinity.abs(), infinity); assert_eq!((1f64/neg_infinity).abs(), 0f64); - assert!(NaN.abs().is_NaN()); + assert!(NaN.abs().is_nan()); } #[test] @@ -1192,8 +1192,8 @@ mod tests { #[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] @@ -1205,7 +1205,7 @@ mod tests { assert_eq!((-1f64).signum(), -1f64); assert_eq!(neg_infinity.signum(), -1f64); assert_eq!((1f64/neg_infinity).signum(), -1f64); - assert!(NaN.signum().is_NaN()); + assert!(NaN.signum().is_nan()); } #[test] @@ -1250,7 +1250,7 @@ mod tests { #[test] fn test_is_normal() { - let nan: f64 = Float::NaN(); + let nan: f64 = Float::nan(); let inf: f64 = Float::infinity(); let neg_inf: f64 = Float::neg_infinity(); let zero: f64 = Zero::zero(); @@ -1267,7 +1267,7 @@ mod tests { #[test] fn test_classify() { - let nan: f64 = Float::NaN(); + let nan: f64 = Float::nan(); let inf: f64 = Float::infinity(); let neg_inf: f64 = Float::neg_infinity(); let zero: f64 = Zero::zero(); @@ -1295,10 +1295,10 @@ mod tests { let inf: f64 = Float::infinity(); let neg_inf: f64 = Float::neg_infinity(); - let nan: f64 = Float::NaN(); + let nan: f64 = Float::nan(); assert_eq!(Float::ldexp(inf, -123), inf); assert_eq!(Float::ldexp(neg_inf, -123), neg_inf); - assert!(Float::ldexp(nan, -123).is_NaN()); + assert!(Float::ldexp(nan, -123).is_nan()); } #[test] @@ -1322,9 +1322,9 @@ mod tests { fn test_frexp_nowin() { let inf: f64 = Float::infinity(); let neg_inf: f64 = Float::neg_infinity(); - let nan: f64 = Float::NaN(); + let nan: f64 = Float::nan(); assert_eq!(match inf.frexp() { (x, _) => x }, inf) assert_eq!(match neg_inf.frexp() { (x, _) => x }, neg_inf) - assert!(match nan.frexp() { (x, _) => x.is_NaN() }) + assert!(match nan.frexp() { (x, _) => x.is_nan() }) } } diff --git a/src/libstd/num/float.rs b/src/libstd/num/float.rs index b86422edc03..dc46d4fec32 100644 --- a/src/libstd/num/float.rs +++ b/src/libstd/num/float.rs @@ -807,8 +807,8 @@ impl Primitive for float { impl Float for float { #[inline] - fn NaN() -> float { - let value: f64 = Float::NaN(); + fn nan() -> float { + let value: f64 = Float::nan(); value as float } @@ -832,7 +832,7 @@ impl Float for float { /// Returns `true` if the number is NaN #[inline] - fn is_NaN(&self) -> bool { (*self as f64).is_NaN() } + fn is_nan(&self) -> bool { (*self as f64).is_nan() } /// Returns `true` if the number is infinite #[inline] @@ -973,10 +973,10 @@ mod tests { assert_eq!(1f.clamp(&2f, &4f), 2f); assert_eq!(8f.clamp(&2f, &4f), 4f); assert_eq!(3f.clamp(&2f, &4f), 3f); - let nan: float = Float::NaN(); - assert!(3f.clamp(&nan, &4f).is_NaN()); - assert!(3f.clamp(&2f, &nan).is_NaN()); - assert!(nan.clamp(&2f, &4f).is_NaN()); + let nan: float = Float::nan(); + assert!(3f.clamp(&nan, &4f).is_nan()); + assert!(3f.clamp(&2f, &nan).is_nan()); + assert!(nan.clamp(&2f, &4f).is_nan()); } #[test] @@ -1056,10 +1056,10 @@ mod tests { let inf: float = Float::infinity(); let neg_inf: float = Float::neg_infinity(); - let nan: float = Float::NaN(); + let nan: float = Float::nan(); assert_eq!(inf.asinh(), inf); assert_eq!(neg_inf.asinh(), neg_inf); - assert!(nan.asinh().is_NaN()); + assert!(nan.asinh().is_nan()); assert_approx_eq!(2.0f.asinh(), 1.443635475178810342493276740273105f); assert_approx_eq!((-2.0f).asinh(), -1.443635475178810342493276740273105f); } @@ -1067,14 +1067,14 @@ mod tests { #[test] fn test_acosh() { assert_eq!(1.0f.acosh(), 0.0f); - assert!(0.999f.acosh().is_NaN()); + assert!(0.999f.acosh().is_nan()); let inf: float = Float::infinity(); let neg_inf: float = Float::neg_infinity(); - let nan: float = Float::NaN(); + let nan: float = Float::nan(); assert_eq!(inf.acosh(), inf); - assert!(neg_inf.acosh().is_NaN()); - assert!(nan.acosh().is_NaN()); + assert!(neg_inf.acosh().is_nan()); + assert!(nan.acosh().is_nan()); assert_approx_eq!(2.0f.acosh(), 1.31695789692481670862504634730796844f); assert_approx_eq!(3.0f.acosh(), 1.76274717403908605046521864995958461f); } @@ -1088,14 +1088,14 @@ mod tests { let neg_inf: float = Float::neg_infinity(); let inf64: f64 = Float::infinity(); let neg_inf64: f64 = Float::neg_infinity(); - let nan: float = Float::NaN(); + let nan: float = Float::nan(); assert_eq!(1.0f.atanh(), inf); assert_eq!((-1.0f).atanh(), neg_inf); - assert!(2f64.atanh().atanh().is_NaN()); - assert!((-2f64).atanh().atanh().is_NaN()); - assert!(inf64.atanh().is_NaN()); - assert!(neg_inf64.atanh().is_NaN()); - assert!(nan.atanh().is_NaN()); + assert!(2f64.atanh().atanh().is_nan()); + assert!((-2f64).atanh().atanh().is_nan()); + assert!(inf64.atanh().is_nan()); + assert!(neg_inf64.atanh().is_nan()); + assert!(nan.atanh().is_nan()); assert_approx_eq!(0.5f.atanh(), 0.54930614433405484569762261846126285f); assert_approx_eq!((-0.5f).atanh(), -0.54930614433405484569762261846126285f); } @@ -1146,7 +1146,7 @@ mod tests { assert_eq!((-1f).abs(), 1f); assert_eq!(neg_infinity.abs(), infinity); assert_eq!((1f/neg_infinity).abs(), 0f); - assert!(NaN.abs().is_NaN()); + assert!(NaN.abs().is_nan()); } #[test] @@ -1163,8 +1163,8 @@ mod tests { #[test] #[ignore(cfg(windows))] // FIXME #8663 fn test_abs_sub_nowin() { - assert!(NaN.abs_sub(&-1f).is_NaN()); - assert!(1f.abs_sub(&NaN).is_NaN()); + assert!(NaN.abs_sub(&-1f).is_nan()); + assert!(1f.abs_sub(&NaN).is_nan()); } #[test] @@ -1176,7 +1176,7 @@ mod tests { assert_eq!((-1f).signum(), -1f); assert_eq!(neg_infinity.signum(), -1f); assert_eq!((1f/neg_infinity).signum(), -1f); - assert!(NaN.signum().is_NaN()); + assert!(NaN.signum().is_nan()); } #[test] @@ -1221,7 +1221,7 @@ mod tests { #[test] fn test_is_normal() { - let nan: float = Float::NaN(); + let nan: float = Float::nan(); let inf: float = Float::infinity(); let neg_inf: float = Float::neg_infinity(); let zero: float = Zero::zero(); @@ -1238,7 +1238,7 @@ mod tests { #[test] fn test_classify() { - let nan: float = Float::NaN(); + let nan: float = Float::nan(); let inf: float = Float::infinity(); let neg_inf: float = Float::neg_infinity(); let zero: float = Zero::zero(); @@ -1267,10 +1267,10 @@ mod tests { let inf: float = Float::infinity(); let neg_inf: float = Float::neg_infinity(); - let nan: float = Float::NaN(); + let nan: float = Float::nan(); assert_eq!(Float::ldexp(inf, -123), inf); assert_eq!(Float::ldexp(neg_inf, -123), neg_inf); - assert!(Float::ldexp(nan, -123).is_NaN()); + assert!(Float::ldexp(nan, -123).is_nan()); } #[test] @@ -1294,10 +1294,10 @@ mod tests { fn test_frexp_nowin() { let inf: float = Float::infinity(); let neg_inf: float = Float::neg_infinity(); - let nan: float = Float::NaN(); + let nan: float = Float::nan(); assert_eq!(match inf.frexp() { (x, _) => x }, inf); assert_eq!(match neg_inf.frexp() { (x, _) => x }, neg_inf); - assert!(match nan.frexp() { (x, _) => x.is_NaN() }) + assert!(match nan.frexp() { (x, _) => x.is_nan() }) } #[test] @@ -1328,7 +1328,7 @@ mod tests { assert_eq!(from_str::("-inf"), Some(neg_infinity)); // note: NaN != NaN, hence this slightly complex test match from_str::("NaN") { - Some(f) => assert!(f.is_NaN()), + Some(f) => assert!(f.is_nan()), None => fail!() } // note: -0 == 0, hence these slightly more complex tests @@ -1375,7 +1375,7 @@ mod tests { assert_eq!(from_str_hex("-inf"), Some(neg_infinity)); // note: NaN != NaN, hence this slightly complex test match from_str_hex("NaN") { - Some(f) => assert!(f.is_NaN()), + Some(f) => assert!(f.is_nan()), None => fail!() } // note: -0 == 0, hence these slightly more complex tests diff --git a/src/libstd/num/num.rs b/src/libstd/num/num.rs index f0efeb762cc..634c86104fb 100644 --- a/src/libstd/num/num.rs +++ b/src/libstd/num/num.rs @@ -320,12 +320,12 @@ pub trait Float: Real + Primitive + ApproxEq { // FIXME (#5527): These should be associated constants - fn NaN() -> Self; + fn nan() -> Self; fn infinity() -> Self; fn neg_infinity() -> Self; fn neg_zero() -> Self; - fn is_NaN(&self) -> bool; + fn is_nan(&self) -> bool; fn is_infinite(&self) -> bool; fn is_finite(&self) -> bool; fn is_normal(&self) -> bool; diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs index dcda27d8ea9..94156f6e81f 100644 --- a/src/libstd/num/strconv.rs +++ b/src/libstd/num/strconv.rs @@ -42,7 +42,7 @@ pub enum SignFormat { } pub trait NumStrConv { - fn NaN() -> Option; + fn nan() -> Option; fn inf() -> Option; fn neg_inf() -> Option; fn neg_zero() -> Option; @@ -54,7 +54,7 @@ pub trait NumStrConv { macro_rules! impl_NumStrConv_Floating (($t:ty) => ( impl NumStrConv for $t { #[inline] - fn NaN() -> Option<$t> { Some( 0.0 / 0.0) } + fn nan() -> Option<$t> { Some( 0.0 / 0.0) } #[inline] fn inf() -> Option<$t> { Some( 1.0 / 0.0) } #[inline] @@ -71,7 +71,7 @@ macro_rules! impl_NumStrConv_Floating (($t:ty) => ( macro_rules! impl_NumStrConv_Integer (($t:ty) => ( impl NumStrConv for $t { - #[inline] fn NaN() -> Option<$t> { None } + #[inline] fn nan() -> Option<$t> { None } #[inline] fn inf() -> Option<$t> { None } #[inline] fn neg_inf() -> Option<$t> { None } #[inline] fn neg_zero() -> Option<$t> { None } @@ -515,7 +515,7 @@ pub fn from_str_bytes_common+ return None; } } else if buf == NAN_BUF { - return NumStrConv::NaN(); + return NumStrConv::nan(); } } diff --git a/src/test/compile-fail/issue-6804.rs b/src/test/compile-fail/issue-6804.rs index 0a62e889d09..db72740f483 100644 --- a/src/test/compile-fail/issue-6804.rs +++ b/src/test/compile-fail/issue-6804.rs @@ -8,12 +8,12 @@ fn main() { NaN => {}, _ => {}, }; - //~^^^ WARNING unmatchable NaN in pattern, use the is_NaN method in a guard instead + //~^^^ WARNING unmatchable NaN in pattern, use the is_nan method in a guard instead match [x, 1.0] { [NaN, _] => {}, _ => {}, }; - //~^^^ WARNING unmatchable NaN in pattern, use the is_NaN method in a guard instead + //~^^^ WARNING unmatchable NaN in pattern, use the is_nan method in a guard instead } // At least one error is needed so that compilation fails diff --git a/src/test/run-pass/float-nan.rs b/src/test/run-pass/float-nan.rs index d59b8c77d00..b34cc7863b2 100644 --- a/src/test/run-pass/float-nan.rs +++ b/src/test/run-pass/float-nan.rs @@ -13,8 +13,8 @@ extern mod extra; use std::num::Float; pub fn main() { - let nan: float = Float::NaN(); - assert!((nan).is_NaN()); + let nan: float = Float::nan(); + assert!((nan).is_nan()); let inf: float = Float::infinity(); let neg_inf: float = Float::neg_infinity(); @@ -73,22 +73,22 @@ pub fn main() { assert!(!(-inf < nan)); assert!(!(-nan < nan)); - assert!((nan + inf).is_NaN()); - assert!((nan + -inf).is_NaN()); - assert!((nan + 0.).is_NaN()); - assert!((nan + 1.).is_NaN()); - assert!((nan * 1.).is_NaN()); - assert!((nan / 1.).is_NaN()); - assert!((nan / 0.).is_NaN()); - assert!((0f/0f).is_NaN()); - assert!((-inf + inf).is_NaN()); - assert!((inf - inf).is_NaN()); + assert!((nan + inf).is_nan()); + assert!((nan + -inf).is_nan()); + assert!((nan + 0.).is_nan()); + assert!((nan + 1.).is_nan()); + assert!((nan * 1.).is_nan()); + assert!((nan / 1.).is_nan()); + assert!((nan / 0.).is_nan()); + assert!((0f/0f).is_nan()); + assert!((-inf + inf).is_nan()); + assert!((inf - inf).is_nan()); - assert!(!(-1f).is_NaN()); - assert!(!(0f).is_NaN()); - assert!(!(0.1f).is_NaN()); - assert!(!(1f).is_NaN()); - assert!(!(inf).is_NaN()); - assert!(!(-inf).is_NaN()); - assert!(!(1./-inf).is_NaN()); + assert!(!(-1f).is_nan()); + assert!(!(0f).is_nan()); + assert!(!(0.1f).is_nan()); + assert!(!(1f).is_nan()); + assert!(!(inf).is_nan()); + assert!(!(-inf).is_nan()); + assert!(!(1./-inf).is_nan()); }