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.
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
}
}
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
};
#[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,
}
#[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,
}
#[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,
///
#[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`
#[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(),
}
}
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 }
/// 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]
/// 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
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]
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);
}
#[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);
}
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);
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]
#[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]
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]
#[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();
#[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();
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]
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() })
}
}
#[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,
}
#[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,
}
#[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,
///
#[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`
#[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(),
}
}
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 }
/// 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]
/// 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
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]
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]
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]
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);
}
#[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);
}
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);
}
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]
#[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]
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]
#[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();
#[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();
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]
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() })
}
}
impl Float for float {
#[inline]
- fn NaN() -> float {
- let value: f64 = Float::NaN();
+ fn nan() -> float {
+ let value: f64 = Float::nan();
value as 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]
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]
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);
}
#[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);
}
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);
}
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]
#[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]
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]
#[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();
#[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();
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]
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]
assert_eq!(from_str::<float>("-inf"), Some(neg_infinity));
// note: NaN != NaN, hence this slightly complex test
match from_str::<float>("NaN") {
- Some(f) => assert!(f.is_NaN()),
+ Some(f) => assert!(f.is_nan()),
None => fail!()
}
// note: -0 == 0, hence these slightly more complex 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
+ Primitive
+ ApproxEq<Self> {
// 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;
}
pub trait NumStrConv {
- fn NaN() -> Option<Self>;
+ fn nan() -> Option<Self>;
fn inf() -> Option<Self>;
fn neg_inf() -> Option<Self>;
fn neg_zero() -> Option<Self>;
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]
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 }
return None;
}
} else if buf == NAN_BUF {
- return NumStrConv::NaN();
+ return NumStrConv::nan();
}
}
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
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();
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());
}