library/std/src/f64/tests.rs

   1 use crate::f64::consts;
   2 use crate::num::FpCategory as Fp;
   3 use crate::num::*;
   4
   5 #[test]
   6 fn test_num_f64() {
   7     test_num(10f64, 2f64);
   8 }
   9
  10 #[test]
  11 fn test_min_nan() {
  12     assert_eq!(f64::NAN.min(2.0), 2.0);
  13     assert_eq!(2.0f64.min(f64::NAN), 2.0);
  14 }
  15
  16 #[test]
  17 fn test_max_nan() {
  18     assert_eq!(f64::NAN.max(2.0), 2.0);
  19     assert_eq!(2.0f64.max(f64::NAN), 2.0);
  20 }
  21
  22 #[test]
  23 fn test_nan() {
  24     let nan: f64 = f64::NAN;
  25     assert!(nan.is_nan());
  26     assert!(!nan.is_infinite());
  27     assert!(!nan.is_finite());
  28     assert!(!nan.is_normal());
  29     assert!(nan.is_sign_positive());
  30     assert!(!nan.is_sign_negative());
  31     assert_eq!(Fp::Nan, nan.classify());
  32 }
  33
  34 #[test]
  35 fn test_infinity() {
  36     let inf: f64 = f64::INFINITY;
  37     assert!(inf.is_infinite());
  38     assert!(!inf.is_finite());
  39     assert!(inf.is_sign_positive());
  40     assert!(!inf.is_sign_negative());
  41     assert!(!inf.is_nan());
  42     assert!(!inf.is_normal());
  43     assert_eq!(Fp::Infinite, inf.classify());
  44 }
  45
  46 #[test]
  47 fn test_neg_infinity() {
  48     let neg_inf: f64 = f64::NEG_INFINITY;
  49     assert!(neg_inf.is_infinite());
  50     assert!(!neg_inf.is_finite());
  51     assert!(!neg_inf.is_sign_positive());
  52     assert!(neg_inf.is_sign_negative());
  53     assert!(!neg_inf.is_nan());
  54     assert!(!neg_inf.is_normal());
  55     assert_eq!(Fp::Infinite, neg_inf.classify());
  56 }
  57
  58 #[test]
  59 fn test_zero() {
  60     let zero: f64 = 0.0f64;
  61     assert_eq!(0.0, zero);
  62     assert!(!zero.is_infinite());
  63     assert!(zero.is_finite());
  64     assert!(zero.is_sign_positive());
  65     assert!(!zero.is_sign_negative());
  66     assert!(!zero.is_nan());
  67     assert!(!zero.is_normal());
  68     assert_eq!(Fp::Zero, zero.classify());
  69 }
  70
  71 #[test]
  72 fn test_neg_zero() {
  73     let neg_zero: f64 = -0.0;
  74     assert_eq!(0.0, neg_zero);
  75     assert!(!neg_zero.is_infinite());
  76     assert!(neg_zero.is_finite());
  77     assert!(!neg_zero.is_sign_positive());
  78     assert!(neg_zero.is_sign_negative());
  79     assert!(!neg_zero.is_nan());
  80     assert!(!neg_zero.is_normal());
  81     assert_eq!(Fp::Zero, neg_zero.classify());
  82 }
  83
  84 #[cfg_attr(all(target_arch = "wasm32", target_os = "emscripten"), ignore)] // issue 42630
  85 #[test]
  86 fn test_one() {
  87     let one: f64 = 1.0f64;
  88     assert_eq!(1.0, one);
  89     assert!(!one.is_infinite());
  90     assert!(one.is_finite());
  91     assert!(one.is_sign_positive());
  92     assert!(!one.is_sign_negative());
  93     assert!(!one.is_nan());
  94     assert!(one.is_normal());
  95     assert_eq!(Fp::Normal, one.classify());
  96 }
  97
  98 #[test]
  99 fn test_is_nan() {
 100     let nan: f64 = f64::NAN;
 101     let inf: f64 = f64::INFINITY;
 102     let neg_inf: f64 = f64::NEG_INFINITY;
 103     assert!(nan.is_nan());
 104     assert!(!0.0f64.is_nan());
 105     assert!(!5.3f64.is_nan());
 106     assert!(!(-10.732f64).is_nan());
 107     assert!(!inf.is_nan());
 108     assert!(!neg_inf.is_nan());
 109 }
 110
 111 #[test]
 112 fn test_is_infinite() {
 113     let nan: f64 = f64::NAN;
 114     let inf: f64 = f64::INFINITY;
 115     let neg_inf: f64 = f64::NEG_INFINITY;
 116     assert!(!nan.is_infinite());
 117     assert!(inf.is_infinite());
 118     assert!(neg_inf.is_infinite());
 119     assert!(!0.0f64.is_infinite());
 120     assert!(!42.8f64.is_infinite());
 121     assert!(!(-109.2f64).is_infinite());
 122 }
 123
 124 #[test]
 125 fn test_is_finite() {
 126     let nan: f64 = f64::NAN;
 127     let inf: f64 = f64::INFINITY;
 128     let neg_inf: f64 = f64::NEG_INFINITY;
 129     assert!(!nan.is_finite());
 130     assert!(!inf.is_finite());
 131     assert!(!neg_inf.is_finite());
 132     assert!(0.0f64.is_finite());
 133     assert!(42.8f64.is_finite());
 134     assert!((-109.2f64).is_finite());
 135 }
 136
 137 #[cfg_attr(all(target_arch = "wasm32", target_os = "emscripten"), ignore)] // issue 42630
 138 #[test]
 139 fn test_is_normal() {
 140     let nan: f64 = f64::NAN;
 141     let inf: f64 = f64::INFINITY;
 142     let neg_inf: f64 = f64::NEG_INFINITY;
 143     let zero: f64 = 0.0f64;
 144     let neg_zero: f64 = -0.0;
 145     assert!(!nan.is_normal());
 146     assert!(!inf.is_normal());
 147     assert!(!neg_inf.is_normal());
 148     assert!(!zero.is_normal());
 149     assert!(!neg_zero.is_normal());
 150     assert!(1f64.is_normal());
 151     assert!(1e-307f64.is_normal());
 152     assert!(!1e-308f64.is_normal());
 153 }
 154
 155 #[cfg_attr(all(target_arch = "wasm32", target_os = "emscripten"), ignore)] // issue 42630
 156 #[test]
 157 fn test_classify() {
 158     let nan: f64 = f64::NAN;
 159     let inf: f64 = f64::INFINITY;
 160     let neg_inf: f64 = f64::NEG_INFINITY;
 161     let zero: f64 = 0.0f64;
 162     let neg_zero: f64 = -0.0;
 163     assert_eq!(nan.classify(), Fp::Nan);
 164     assert_eq!(inf.classify(), Fp::Infinite);
 165     assert_eq!(neg_inf.classify(), Fp::Infinite);
 166     assert_eq!(zero.classify(), Fp::Zero);
 167     assert_eq!(neg_zero.classify(), Fp::Zero);
 168     assert_eq!(1e-307f64.classify(), Fp::Normal);
 169     assert_eq!(1e-308f64.classify(), Fp::Subnormal);
 170 }
 171
 172 #[test]
 173 fn test_floor() {
 174     assert_approx_eq!(1.0f64.floor(), 1.0f64);
 175     assert_approx_eq!(1.3f64.floor(), 1.0f64);
 176     assert_approx_eq!(1.5f64.floor(), 1.0f64);
 177     assert_approx_eq!(1.7f64.floor(), 1.0f64);
 178     assert_approx_eq!(0.0f64.floor(), 0.0f64);
 179     assert_approx_eq!((-0.0f64).floor(), -0.0f64);
 180     assert_approx_eq!((-1.0f64).floor(), -1.0f64);
 181     assert_approx_eq!((-1.3f64).floor(), -2.0f64);
 182     assert_approx_eq!((-1.5f64).floor(), -2.0f64);
 183     assert_approx_eq!((-1.7f64).floor(), -2.0f64);
 184 }
 185
 186 #[test]
 187 fn test_ceil() {
 188     assert_approx_eq!(1.0f64.ceil(), 1.0f64);
 189     assert_approx_eq!(1.3f64.ceil(), 2.0f64);
 190     assert_approx_eq!(1.5f64.ceil(), 2.0f64);
 191     assert_approx_eq!(1.7f64.ceil(), 2.0f64);
 192     assert_approx_eq!(0.0f64.ceil(), 0.0f64);
 193     assert_approx_eq!((-0.0f64).ceil(), -0.0f64);
 194     assert_approx_eq!((-1.0f64).ceil(), -1.0f64);
 195     assert_approx_eq!((-1.3f64).ceil(), -1.0f64);
 196     assert_approx_eq!((-1.5f64).ceil(), -1.0f64);
 197     assert_approx_eq!((-1.7f64).ceil(), -1.0f64);
 198 }
 199
 200 #[test]
 201 fn test_round() {
 202     assert_approx_eq!(1.0f64.round(), 1.0f64);
 203     assert_approx_eq!(1.3f64.round(), 1.0f64);
 204     assert_approx_eq!(1.5f64.round(), 2.0f64);
 205     assert_approx_eq!(1.7f64.round(), 2.0f64);
 206     assert_approx_eq!(0.0f64.round(), 0.0f64);
 207     assert_approx_eq!((-0.0f64).round(), -0.0f64);
 208     assert_approx_eq!((-1.0f64).round(), -1.0f64);
 209     assert_approx_eq!((-1.3f64).round(), -1.0f64);
 210     assert_approx_eq!((-1.5f64).round(), -2.0f64);
 211     assert_approx_eq!((-1.7f64).round(), -2.0f64);
 212 }
 213
 214 #[test]
 215 fn test_trunc() {
 216     assert_approx_eq!(1.0f64.trunc(), 1.0f64);
 217     assert_approx_eq!(1.3f64.trunc(), 1.0f64);
 218     assert_approx_eq!(1.5f64.trunc(), 1.0f64);
 219     assert_approx_eq!(1.7f64.trunc(), 1.0f64);
 220     assert_approx_eq!(0.0f64.trunc(), 0.0f64);
 221     assert_approx_eq!((-0.0f64).trunc(), -0.0f64);
 222     assert_approx_eq!((-1.0f64).trunc(), -1.0f64);
 223     assert_approx_eq!((-1.3f64).trunc(), -1.0f64);
 224     assert_approx_eq!((-1.5f64).trunc(), -1.0f64);
 225     assert_approx_eq!((-1.7f64).trunc(), -1.0f64);
 226 }
 227
 228 #[test]
 229 fn test_fract() {
 230     assert_approx_eq!(1.0f64.fract(), 0.0f64);
 231     assert_approx_eq!(1.3f64.fract(), 0.3f64);
 232     assert_approx_eq!(1.5f64.fract(), 0.5f64);
 233     assert_approx_eq!(1.7f64.fract(), 0.7f64);
 234     assert_approx_eq!(0.0f64.fract(), 0.0f64);
 235     assert_approx_eq!((-0.0f64).fract(), -0.0f64);
 236     assert_approx_eq!((-1.0f64).fract(), -0.0f64);
 237     assert_approx_eq!((-1.3f64).fract(), -0.3f64);
 238     assert_approx_eq!((-1.5f64).fract(), -0.5f64);
 239     assert_approx_eq!((-1.7f64).fract(), -0.7f64);
 240 }
 241
 242 #[test]
 243 fn test_abs() {
 244     assert_eq!(f64::INFINITY.abs(), f64::INFINITY);
 245     assert_eq!(1f64.abs(), 1f64);
 246     assert_eq!(0f64.abs(), 0f64);
 247     assert_eq!((-0f64).abs(), 0f64);
 248     assert_eq!((-1f64).abs(), 1f64);
 249     assert_eq!(f64::NEG_INFINITY.abs(), f64::INFINITY);
 250     assert_eq!((1f64 / f64::NEG_INFINITY).abs(), 0f64);
 251     assert!(f64::NAN.abs().is_nan());
 252 }
 253
 254 #[test]
 255 fn test_signum() {
 256     assert_eq!(f64::INFINITY.signum(), 1f64);
 257     assert_eq!(1f64.signum(), 1f64);
 258     assert_eq!(0f64.signum(), 1f64);
 259     assert_eq!((-0f64).signum(), -1f64);
 260     assert_eq!((-1f64).signum(), -1f64);
 261     assert_eq!(f64::NEG_INFINITY.signum(), -1f64);
 262     assert_eq!((1f64 / f64::NEG_INFINITY).signum(), -1f64);
 263     assert!(f64::NAN.signum().is_nan());
 264 }
 265
 266 #[test]
 267 fn test_is_sign_positive() {
 268     assert!(f64::INFINITY.is_sign_positive());
 269     assert!(1f64.is_sign_positive());
 270     assert!(0f64.is_sign_positive());
 271     assert!(!(-0f64).is_sign_positive());
 272     assert!(!(-1f64).is_sign_positive());
 273     assert!(!f64::NEG_INFINITY.is_sign_positive());
 274     assert!(!(1f64 / f64::NEG_INFINITY).is_sign_positive());
 275     assert!(f64::NAN.is_sign_positive());
 276     assert!(!(-f64::NAN).is_sign_positive());
 277 }
 278
 279 #[test]
 280 fn test_is_sign_negative() {
 281     assert!(!f64::INFINITY.is_sign_negative());
 282     assert!(!1f64.is_sign_negative());
 283     assert!(!0f64.is_sign_negative());
 284     assert!((-0f64).is_sign_negative());
 285     assert!((-1f64).is_sign_negative());
 286     assert!(f64::NEG_INFINITY.is_sign_negative());
 287     assert!((1f64 / f64::NEG_INFINITY).is_sign_negative());
 288     assert!(!f64::NAN.is_sign_negative());
 289     assert!((-f64::NAN).is_sign_negative());
 290 }
 291
 292 #[allow(unused_macros)]
 293 macro_rules! assert_f64_biteq {
 294     ($left : expr, $right : expr) => {
 295         let l: &f64 = &$left;
 296         let r: &f64 = &$right;
 297         let lb = l.to_bits();
 298         let rb = r.to_bits();
 299         assert_eq!(lb, rb, "float {} ({:#x}) is not equal to {} ({:#x})", *l, lb, *r, rb);
 300     };
 301 }
 302
 303 // Ignore test on x87 floating point, these platforms do not guarantee NaN
 304 // payloads are preserved and flush denormals to zero, failing the tests.
 305 #[cfg(not(target_arch = "x86"))]
 306 #[test]
 307 fn test_next_up() {
 308     let tiny = f64::from_bits(1);
 309     let tiny_up = f64::from_bits(2);
 310     let max_down = f64::from_bits(0x7fef_ffff_ffff_fffe);
 311     let largest_subnormal = f64::from_bits(0x000f_ffff_ffff_ffff);
 312     let smallest_normal = f64::from_bits(0x0010_0000_0000_0000);
 313     assert_f64_biteq!(f64::NEG_INFINITY.next_up(), f64::MIN);
 314     assert_f64_biteq!(f64::MIN.next_up(), -max_down);
 315     assert_f64_biteq!((-1.0 - f64::EPSILON).next_up(), -1.0);
 316     assert_f64_biteq!((-smallest_normal).next_up(), -largest_subnormal);
 317     assert_f64_biteq!((-tiny_up).next_up(), -tiny);
 318     assert_f64_biteq!((-tiny).next_up(), -0.0f64);
 319     assert_f64_biteq!((-0.0f64).next_up(), tiny);
 320     assert_f64_biteq!(0.0f64.next_up(), tiny);
 321     assert_f64_biteq!(tiny.next_up(), tiny_up);
 322     assert_f64_biteq!(largest_subnormal.next_up(), smallest_normal);
 323     assert_f64_biteq!(1.0f64.next_up(), 1.0 + f64::EPSILON);
 324     assert_f64_biteq!(f64::MAX.next_up(), f64::INFINITY);
 325     assert_f64_biteq!(f64::INFINITY.next_up(), f64::INFINITY);
 326
 327     let nan0 = f64::NAN;
 328     let nan1 = f64::from_bits(f64::NAN.to_bits() ^ 0x000a_aaaa_aaaa_aaaa);
 329     let nan2 = f64::from_bits(f64::NAN.to_bits() ^ 0x0005_5555_5555_5555);
 330     assert_f64_biteq!(nan0.next_up(), nan0);
 331     assert_f64_biteq!(nan1.next_up(), nan1);
 332     assert_f64_biteq!(nan2.next_up(), nan2);
 333 }
 334
 335 // Ignore test on x87 floating point, these platforms do not guarantee NaN
 336 // payloads are preserved and flush denormals to zero, failing the tests.
 337 #[cfg(not(target_arch = "x86"))]
 338 #[test]
 339 fn test_next_down() {
 340     let tiny = f64::from_bits(1);
 341     let tiny_up = f64::from_bits(2);
 342     let max_down = f64::from_bits(0x7fef_ffff_ffff_fffe);
 343     let largest_subnormal = f64::from_bits(0x000f_ffff_ffff_ffff);
 344     let smallest_normal = f64::from_bits(0x0010_0000_0000_0000);
 345     assert_f64_biteq!(f64::NEG_INFINITY.next_down(), f64::NEG_INFINITY);
 346     assert_f64_biteq!(f64::MIN.next_down(), f64::NEG_INFINITY);
 347     assert_f64_biteq!((-max_down).next_down(), f64::MIN);
 348     assert_f64_biteq!((-1.0f64).next_down(), -1.0 - f64::EPSILON);
 349     assert_f64_biteq!((-largest_subnormal).next_down(), -smallest_normal);
 350     assert_f64_biteq!((-tiny).next_down(), -tiny_up);
 351     assert_f64_biteq!((-0.0f64).next_down(), -tiny);
 352     assert_f64_biteq!((0.0f64).next_down(), -tiny);
 353     assert_f64_biteq!(tiny.next_down(), 0.0f64);
 354     assert_f64_biteq!(tiny_up.next_down(), tiny);
 355     assert_f64_biteq!(smallest_normal.next_down(), largest_subnormal);
 356     assert_f64_biteq!((1.0 + f64::EPSILON).next_down(), 1.0f64);
 357     assert_f64_biteq!(f64::MAX.next_down(), max_down);
 358     assert_f64_biteq!(f64::INFINITY.next_down(), f64::MAX);
 359
 360     let nan0 = f64::NAN;
 361     let nan1 = f64::from_bits(f64::NAN.to_bits() ^ 0x000a_aaaa_aaaa_aaaa);
 362     let nan2 = f64::from_bits(f64::NAN.to_bits() ^ 0x0005_5555_5555_5555);
 363     assert_f64_biteq!(nan0.next_down(), nan0);
 364     assert_f64_biteq!(nan1.next_down(), nan1);
 365     assert_f64_biteq!(nan2.next_down(), nan2);
 366 }
 367
 368 #[test]
 369 fn test_mul_add() {
 370     let nan: f64 = f64::NAN;
 371     let inf: f64 = f64::INFINITY;
 372     let neg_inf: f64 = f64::NEG_INFINITY;
 373     assert_approx_eq!(12.3f64.mul_add(4.5, 6.7), 62.05);
 374     assert_approx_eq!((-12.3f64).mul_add(-4.5, -6.7), 48.65);
 375     assert_approx_eq!(0.0f64.mul_add(8.9, 1.2), 1.2);
 376     assert_approx_eq!(3.4f64.mul_add(-0.0, 5.6), 5.6);
 377     assert!(nan.mul_add(7.8, 9.0).is_nan());
 378     assert_eq!(inf.mul_add(7.8, 9.0), inf);
 379     assert_eq!(neg_inf.mul_add(7.8, 9.0), neg_inf);
 380     assert_eq!(8.9f64.mul_add(inf, 3.2), inf);
 381     assert_eq!((-3.2f64).mul_add(2.4, neg_inf), neg_inf);
 382 }
 383
 384 #[test]
 385 fn test_recip() {
 386     let nan: f64 = f64::NAN;
 387     let inf: f64 = f64::INFINITY;
 388     let neg_inf: f64 = f64::NEG_INFINITY;
 389     assert_eq!(1.0f64.recip(), 1.0);
 390     assert_eq!(2.0f64.recip(), 0.5);
 391     assert_eq!((-0.4f64).recip(), -2.5);
 392     assert_eq!(0.0f64.recip(), inf);
 393     assert!(nan.recip().is_nan());
 394     assert_eq!(inf.recip(), 0.0);
 395     assert_eq!(neg_inf.recip(), 0.0);
 396 }
 397
 398 #[test]
 399 fn test_powi() {
 400     let nan: f64 = f64::NAN;
 401     let inf: f64 = f64::INFINITY;
 402     let neg_inf: f64 = f64::NEG_INFINITY;
 403     assert_eq!(1.0f64.powi(1), 1.0);
 404     assert_approx_eq!((-3.1f64).powi(2), 9.61);
 405     assert_approx_eq!(5.9f64.powi(-2), 0.028727);
 406     assert_eq!(8.3f64.powi(0), 1.0);
 407     assert!(nan.powi(2).is_nan());
 408     assert_eq!(inf.powi(3), inf);
 409     assert_eq!(neg_inf.powi(2), inf);
 410 }
 411
 412 #[test]
 413 fn test_powf() {
 414     let nan: f64 = f64::NAN;
 415     let inf: f64 = f64::INFINITY;
 416     let neg_inf: f64 = f64::NEG_INFINITY;
 417     assert_eq!(1.0f64.powf(1.0), 1.0);
 418     assert_approx_eq!(3.4f64.powf(4.5), 246.408183);
 419     assert_approx_eq!(2.7f64.powf(-3.2), 0.041652);
 420     assert_approx_eq!((-3.1f64).powf(2.0), 9.61);
 421     assert_approx_eq!(5.9f64.powf(-2.0), 0.028727);
 422     assert_eq!(8.3f64.powf(0.0), 1.0);
 423     assert!(nan.powf(2.0).is_nan());
 424     assert_eq!(inf.powf(2.0), inf);
 425     assert_eq!(neg_inf.powf(3.0), neg_inf);
 426 }
 427
 428 #[test]
 429 fn test_sqrt_domain() {
 430     assert!(f64::NAN.sqrt().is_nan());
 431     assert!(f64::NEG_INFINITY.sqrt().is_nan());
 432     assert!((-1.0f64).sqrt().is_nan());
 433     assert_eq!((-0.0f64).sqrt(), -0.0);
 434     assert_eq!(0.0f64.sqrt(), 0.0);
 435     assert_eq!(1.0f64.sqrt(), 1.0);
 436     assert_eq!(f64::INFINITY.sqrt(), f64::INFINITY);
 437 }
 438
 439 #[test]
 440 fn test_exp() {
 441     assert_eq!(1.0, 0.0f64.exp());
 442     assert_approx_eq!(2.718282, 1.0f64.exp());
 443     assert_approx_eq!(148.413159, 5.0f64.exp());
 444
 445     let inf: f64 = f64::INFINITY;
 446     let neg_inf: f64 = f64::NEG_INFINITY;
 447     let nan: f64 = f64::NAN;
 448     assert_eq!(inf, inf.exp());
 449     assert_eq!(0.0, neg_inf.exp());
 450     assert!(nan.exp().is_nan());
 451 }
 452
 453 #[test]
 454 fn test_exp2() {
 455     assert_eq!(32.0, 5.0f64.exp2());
 456     assert_eq!(1.0, 0.0f64.exp2());
 457
 458     let inf: f64 = f64::INFINITY;
 459     let neg_inf: f64 = f64::NEG_INFINITY;
 460     let nan: f64 = f64::NAN;
 461     assert_eq!(inf, inf.exp2());
 462     assert_eq!(0.0, neg_inf.exp2());
 463     assert!(nan.exp2().is_nan());
 464 }
 465
 466 #[test]
 467 fn test_ln() {
 468     let nan: f64 = f64::NAN;
 469     let inf: f64 = f64::INFINITY;
 470     let neg_inf: f64 = f64::NEG_INFINITY;
 471     assert_approx_eq!(1.0f64.exp().ln(), 1.0);
 472     assert!(nan.ln().is_nan());
 473     assert_eq!(inf.ln(), inf);
 474     assert!(neg_inf.ln().is_nan());
 475     assert!((-2.3f64).ln().is_nan());
 476     assert_eq!((-0.0f64).ln(), neg_inf);
 477     assert_eq!(0.0f64.ln(), neg_inf);
 478     assert_approx_eq!(4.0f64.ln(), 1.386294);
 479 }
 480
 481 #[test]
 482 fn test_log() {
 483     let nan: f64 = f64::NAN;
 484     let inf: f64 = f64::INFINITY;
 485     let neg_inf: f64 = f64::NEG_INFINITY;
 486     assert_eq!(10.0f64.log(10.0), 1.0);
 487     assert_approx_eq!(2.3f64.log(3.5), 0.664858);
 488     assert_eq!(1.0f64.exp().log(1.0f64.exp()), 1.0);
 489     assert!(1.0f64.log(1.0).is_nan());
 490     assert!(1.0f64.log(-13.9).is_nan());
 491     assert!(nan.log(2.3).is_nan());
 492     assert_eq!(inf.log(10.0), inf);
 493     assert!(neg_inf.log(8.8).is_nan());
 494     assert!((-2.3f64).log(0.1).is_nan());
 495     assert_eq!((-0.0f64).log(2.0), neg_inf);
 496     assert_eq!(0.0f64.log(7.0), neg_inf);
 497 }
 498
 499 #[test]
 500 fn test_log2() {
 501     let nan: f64 = f64::NAN;
 502     let inf: f64 = f64::INFINITY;
 503     let neg_inf: f64 = f64::NEG_INFINITY;
 504     assert_approx_eq!(10.0f64.log2(), 3.321928);
 505     assert_approx_eq!(2.3f64.log2(), 1.201634);
 506     assert_approx_eq!(1.0f64.exp().log2(), 1.442695);
 507     assert!(nan.log2().is_nan());
 508     assert_eq!(inf.log2(), inf);
 509     assert!(neg_inf.log2().is_nan());
 510     assert!((-2.3f64).log2().is_nan());
 511     assert_eq!((-0.0f64).log2(), neg_inf);
 512     assert_eq!(0.0f64.log2(), neg_inf);
 513 }
 514
 515 #[test]
 516 fn test_log10() {
 517     let nan: f64 = f64::NAN;
 518     let inf: f64 = f64::INFINITY;
 519     let neg_inf: f64 = f64::NEG_INFINITY;
 520     assert_eq!(10.0f64.log10(), 1.0);
 521     assert_approx_eq!(2.3f64.log10(), 0.361728);
 522     assert_approx_eq!(1.0f64.exp().log10(), 0.434294);
 523     assert_eq!(1.0f64.log10(), 0.0);
 524     assert!(nan.log10().is_nan());
 525     assert_eq!(inf.log10(), inf);
 526     assert!(neg_inf.log10().is_nan());
 527     assert!((-2.3f64).log10().is_nan());
 528     assert_eq!((-0.0f64).log10(), neg_inf);
 529     assert_eq!(0.0f64.log10(), neg_inf);
 530 }
 531
 532 #[test]
 533 fn test_to_degrees() {
 534     let pi: f64 = consts::PI;
 535     let nan: f64 = f64::NAN;
 536     let inf: f64 = f64::INFINITY;
 537     let neg_inf: f64 = f64::NEG_INFINITY;
 538     assert_eq!(0.0f64.to_degrees(), 0.0);
 539     assert_approx_eq!((-5.8f64).to_degrees(), -332.315521);
 540     assert_eq!(pi.to_degrees(), 180.0);
 541     assert!(nan.to_degrees().is_nan());
 542     assert_eq!(inf.to_degrees(), inf);
 543     assert_eq!(neg_inf.to_degrees(), neg_inf);
 544 }
 545
 546 #[test]
 547 fn test_to_radians() {
 548     let pi: f64 = consts::PI;
 549     let nan: f64 = f64::NAN;
 550     let inf: f64 = f64::INFINITY;
 551     let neg_inf: f64 = f64::NEG_INFINITY;
 552     assert_eq!(0.0f64.to_radians(), 0.0);
 553     assert_approx_eq!(154.6f64.to_radians(), 2.698279);
 554     assert_approx_eq!((-332.31f64).to_radians(), -5.799903);
 555     assert_eq!(180.0f64.to_radians(), pi);
 556     assert!(nan.to_radians().is_nan());
 557     assert_eq!(inf.to_radians(), inf);
 558     assert_eq!(neg_inf.to_radians(), neg_inf);
 559 }
 560
 561 #[test]
 562 fn test_asinh() {
 563     assert_eq!(0.0f64.asinh(), 0.0f64);
 564     assert_eq!((-0.0f64).asinh(), -0.0f64);
 565
 566     let inf: f64 = f64::INFINITY;
 567     let neg_inf: f64 = f64::NEG_INFINITY;
 568     let nan: f64 = f64::NAN;
 569     assert_eq!(inf.asinh(), inf);
 570     assert_eq!(neg_inf.asinh(), neg_inf);
 571     assert!(nan.asinh().is_nan());
 572     assert!((-0.0f64).asinh().is_sign_negative());
 573     // issue 63271
 574     assert_approx_eq!(2.0f64.asinh(), 1.443635475178810342493276740273105f64);
 575     assert_approx_eq!((-2.0f64).asinh(), -1.443635475178810342493276740273105f64);
 576     // regression test for the catastrophic cancellation fixed in 72486
 577     assert_approx_eq!((-67452098.07139316f64).asinh(), -18.72007542627454439398548429400083);
 578 }
 579
 580 #[test]
 581 fn test_acosh() {
 582     assert_eq!(1.0f64.acosh(), 0.0f64);
 583     assert!(0.999f64.acosh().is_nan());
 584
 585     let inf: f64 = f64::INFINITY;
 586     let neg_inf: f64 = f64::NEG_INFINITY;
 587     let nan: f64 = f64::NAN;
 588     assert_eq!(inf.acosh(), inf);
 589     assert!(neg_inf.acosh().is_nan());
 590     assert!(nan.acosh().is_nan());
 591     assert_approx_eq!(2.0f64.acosh(), 1.31695789692481670862504634730796844f64);
 592     assert_approx_eq!(3.0f64.acosh(), 1.76274717403908605046521864995958461f64);
 593 }
 594
 595 #[test]
 596 fn test_atanh() {
 597     assert_eq!(0.0f64.atanh(), 0.0f64);
 598     assert_eq!((-0.0f64).atanh(), -0.0f64);
 599
 600     let inf: f64 = f64::INFINITY;
 601     let neg_inf: f64 = f64::NEG_INFINITY;
 602     let nan: f64 = f64::NAN;
 603     assert_eq!(1.0f64.atanh(), inf);
 604     assert_eq!((-1.0f64).atanh(), neg_inf);
 605     assert!(2f64.atanh().atanh().is_nan());
 606     assert!((-2f64).atanh().atanh().is_nan());
 607     assert!(inf.atanh().is_nan());
 608     assert!(neg_inf.atanh().is_nan());
 609     assert!(nan.atanh().is_nan());
 610     assert_approx_eq!(0.5f64.atanh(), 0.54930614433405484569762261846126285f64);
 611     assert_approx_eq!((-0.5f64).atanh(), -0.54930614433405484569762261846126285f64);
 612 }
 613
 614 #[test]
 615 fn test_real_consts() {
 616     use super::consts;
 617     let pi: f64 = consts::PI;
 618     let frac_pi_2: f64 = consts::FRAC_PI_2;
 619     let frac_pi_3: f64 = consts::FRAC_PI_3;
 620     let frac_pi_4: f64 = consts::FRAC_PI_4;
 621     let frac_pi_6: f64 = consts::FRAC_PI_6;
 622     let frac_pi_8: f64 = consts::FRAC_PI_8;
 623     let frac_1_pi: f64 = consts::FRAC_1_PI;
 624     let frac_2_pi: f64 = consts::FRAC_2_PI;
 625     let frac_2_sqrtpi: f64 = consts::FRAC_2_SQRT_PI;
 626     let sqrt2: f64 = consts::SQRT_2;
 627     let frac_1_sqrt2: f64 = consts::FRAC_1_SQRT_2;
 628     let e: f64 = consts::E;
 629     let log2_e: f64 = consts::LOG2_E;
 630     let log10_e: f64 = consts::LOG10_E;
 631     let ln_2: f64 = consts::LN_2;
 632     let ln_10: f64 = consts::LN_10;
 633
 634     assert_approx_eq!(frac_pi_2, pi / 2f64);
 635     assert_approx_eq!(frac_pi_3, pi / 3f64);
 636     assert_approx_eq!(frac_pi_4, pi / 4f64);
 637     assert_approx_eq!(frac_pi_6, pi / 6f64);
 638     assert_approx_eq!(frac_pi_8, pi / 8f64);
 639     assert_approx_eq!(frac_1_pi, 1f64 / pi);
 640     assert_approx_eq!(frac_2_pi, 2f64 / pi);
 641     assert_approx_eq!(frac_2_sqrtpi, 2f64 / pi.sqrt());
 642     assert_approx_eq!(sqrt2, 2f64.sqrt());
 643     assert_approx_eq!(frac_1_sqrt2, 1f64 / 2f64.sqrt());
 644     assert_approx_eq!(log2_e, e.log2());
 645     assert_approx_eq!(log10_e, e.log10());
 646     assert_approx_eq!(ln_2, 2f64.ln());
 647     assert_approx_eq!(ln_10, 10f64.ln());
 648 }
 649
 650 #[test]
 651 fn test_float_bits_conv() {
 652     assert_eq!((1f64).to_bits(), 0x3ff0000000000000);
 653     assert_eq!((12.5f64).to_bits(), 0x4029000000000000);
 654     assert_eq!((1337f64).to_bits(), 0x4094e40000000000);
 655     assert_eq!((-14.25f64).to_bits(), 0xc02c800000000000);
 656     assert_approx_eq!(f64::from_bits(0x3ff0000000000000), 1.0);
 657     assert_approx_eq!(f64::from_bits(0x4029000000000000), 12.5);
 658     assert_approx_eq!(f64::from_bits(0x4094e40000000000), 1337.0);
 659     assert_approx_eq!(f64::from_bits(0xc02c800000000000), -14.25);
 660
 661     // Check that NaNs roundtrip their bits regardless of signaling-ness
 662     // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
 663     let masked_nan1 = f64::NAN.to_bits() ^ 0x000A_AAAA_AAAA_AAAA;
 664     let masked_nan2 = f64::NAN.to_bits() ^ 0x0005_5555_5555_5555;
 665     assert!(f64::from_bits(masked_nan1).is_nan());
 666     assert!(f64::from_bits(masked_nan2).is_nan());
 667
 668     assert_eq!(f64::from_bits(masked_nan1).to_bits(), masked_nan1);
 669     assert_eq!(f64::from_bits(masked_nan2).to_bits(), masked_nan2);
 670 }
 671
 672 #[test]
 673 #[should_panic]
 674 fn test_clamp_min_greater_than_max() {
 675     let _ = 1.0f64.clamp(3.0, 1.0);
 676 }
 677
 678 #[test]
 679 #[should_panic]
 680 fn test_clamp_min_is_nan() {
 681     let _ = 1.0f64.clamp(f64::NAN, 1.0);
 682 }
 683
 684 #[test]
 685 #[should_panic]
 686 fn test_clamp_max_is_nan() {
 687     let _ = 1.0f64.clamp(3.0, f64::NAN);
 688 }
 689
 690 #[test]
 691 fn test_total_cmp() {
 692     use core::cmp::Ordering;
 693
 694     fn quiet_bit_mask() -> u64 {
 695         1 << (f64::MANTISSA_DIGITS - 2)
 696     }
 697
 698     fn min_subnorm() -> f64 {
 699         f64::MIN_POSITIVE / f64::powf(2.0, f64::MANTISSA_DIGITS as f64 - 1.0)
 700     }
 701
 702     fn max_subnorm() -> f64 {
 703         f64::MIN_POSITIVE - min_subnorm()
 704     }
 705
 706     fn q_nan() -> f64 {
 707         f64::from_bits(f64::NAN.to_bits() | quiet_bit_mask())
 708     }
 709
 710     fn s_nan() -> f64 {
 711         f64::from_bits((f64::NAN.to_bits() & !quiet_bit_mask()) + 42)
 712     }
 713
 714     assert_eq!(Ordering::Equal, (-q_nan()).total_cmp(&-q_nan()));
 715     assert_eq!(Ordering::Equal, (-s_nan()).total_cmp(&-s_nan()));
 716     assert_eq!(Ordering::Equal, (-f64::INFINITY).total_cmp(&-f64::INFINITY));
 717     assert_eq!(Ordering::Equal, (-f64::MAX).total_cmp(&-f64::MAX));
 718     assert_eq!(Ordering::Equal, (-2.5_f64).total_cmp(&-2.5));
 719     assert_eq!(Ordering::Equal, (-1.0_f64).total_cmp(&-1.0));
 720     assert_eq!(Ordering::Equal, (-1.5_f64).total_cmp(&-1.5));
 721     assert_eq!(Ordering::Equal, (-0.5_f64).total_cmp(&-0.5));
 722     assert_eq!(Ordering::Equal, (-f64::MIN_POSITIVE).total_cmp(&-f64::MIN_POSITIVE));
 723     assert_eq!(Ordering::Equal, (-max_subnorm()).total_cmp(&-max_subnorm()));
 724     assert_eq!(Ordering::Equal, (-min_subnorm()).total_cmp(&-min_subnorm()));
 725     assert_eq!(Ordering::Equal, (-0.0_f64).total_cmp(&-0.0));
 726     assert_eq!(Ordering::Equal, 0.0_f64.total_cmp(&0.0));
 727     assert_eq!(Ordering::Equal, min_subnorm().total_cmp(&min_subnorm()));
 728     assert_eq!(Ordering::Equal, max_subnorm().total_cmp(&max_subnorm()));
 729     assert_eq!(Ordering::Equal, f64::MIN_POSITIVE.total_cmp(&f64::MIN_POSITIVE));
 730     assert_eq!(Ordering::Equal, 0.5_f64.total_cmp(&0.5));
 731     assert_eq!(Ordering::Equal, 1.0_f64.total_cmp(&1.0));
 732     assert_eq!(Ordering::Equal, 1.5_f64.total_cmp(&1.5));
 733     assert_eq!(Ordering::Equal, 2.5_f64.total_cmp(&2.5));
 734     assert_eq!(Ordering::Equal, f64::MAX.total_cmp(&f64::MAX));
 735     assert_eq!(Ordering::Equal, f64::INFINITY.total_cmp(&f64::INFINITY));
 736     assert_eq!(Ordering::Equal, s_nan().total_cmp(&s_nan()));
 737     assert_eq!(Ordering::Equal, q_nan().total_cmp(&q_nan()));
 738
 739     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-s_nan()));
 740     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-f64::INFINITY));
 741     assert_eq!(Ordering::Less, (-f64::INFINITY).total_cmp(&-f64::MAX));
 742     assert_eq!(Ordering::Less, (-f64::MAX).total_cmp(&-2.5));
 743     assert_eq!(Ordering::Less, (-2.5_f64).total_cmp(&-1.5));
 744     assert_eq!(Ordering::Less, (-1.5_f64).total_cmp(&-1.0));
 745     assert_eq!(Ordering::Less, (-1.0_f64).total_cmp(&-0.5));
 746     assert_eq!(Ordering::Less, (-0.5_f64).total_cmp(&-f64::MIN_POSITIVE));
 747     assert_eq!(Ordering::Less, (-f64::MIN_POSITIVE).total_cmp(&-max_subnorm()));
 748     assert_eq!(Ordering::Less, (-max_subnorm()).total_cmp(&-min_subnorm()));
 749     assert_eq!(Ordering::Less, (-min_subnorm()).total_cmp(&-0.0));
 750     assert_eq!(Ordering::Less, (-0.0_f64).total_cmp(&0.0));
 751     assert_eq!(Ordering::Less, 0.0_f64.total_cmp(&min_subnorm()));
 752     assert_eq!(Ordering::Less, min_subnorm().total_cmp(&max_subnorm()));
 753     assert_eq!(Ordering::Less, max_subnorm().total_cmp(&f64::MIN_POSITIVE));
 754     assert_eq!(Ordering::Less, f64::MIN_POSITIVE.total_cmp(&0.5));
 755     assert_eq!(Ordering::Less, 0.5_f64.total_cmp(&1.0));
 756     assert_eq!(Ordering::Less, 1.0_f64.total_cmp(&1.5));
 757     assert_eq!(Ordering::Less, 1.5_f64.total_cmp(&2.5));
 758     assert_eq!(Ordering::Less, 2.5_f64.total_cmp(&f64::MAX));
 759     assert_eq!(Ordering::Less, f64::MAX.total_cmp(&f64::INFINITY));
 760     assert_eq!(Ordering::Less, f64::INFINITY.total_cmp(&s_nan()));
 761     assert_eq!(Ordering::Less, s_nan().total_cmp(&q_nan()));
 762
 763     assert_eq!(Ordering::Greater, (-s_nan()).total_cmp(&-q_nan()));
 764     assert_eq!(Ordering::Greater, (-f64::INFINITY).total_cmp(&-s_nan()));
 765     assert_eq!(Ordering::Greater, (-f64::MAX).total_cmp(&-f64::INFINITY));
 766     assert_eq!(Ordering::Greater, (-2.5_f64).total_cmp(&-f64::MAX));
 767     assert_eq!(Ordering::Greater, (-1.5_f64).total_cmp(&-2.5));
 768     assert_eq!(Ordering::Greater, (-1.0_f64).total_cmp(&-1.5));
 769     assert_eq!(Ordering::Greater, (-0.5_f64).total_cmp(&-1.0));
 770     assert_eq!(Ordering::Greater, (-f64::MIN_POSITIVE).total_cmp(&-0.5));
 771     assert_eq!(Ordering::Greater, (-max_subnorm()).total_cmp(&-f64::MIN_POSITIVE));
 772     assert_eq!(Ordering::Greater, (-min_subnorm()).total_cmp(&-max_subnorm()));
 773     assert_eq!(Ordering::Greater, (-0.0_f64).total_cmp(&-min_subnorm()));
 774     assert_eq!(Ordering::Greater, 0.0_f64.total_cmp(&-0.0));
 775     assert_eq!(Ordering::Greater, min_subnorm().total_cmp(&0.0));
 776     assert_eq!(Ordering::Greater, max_subnorm().total_cmp(&min_subnorm()));
 777     assert_eq!(Ordering::Greater, f64::MIN_POSITIVE.total_cmp(&max_subnorm()));
 778     assert_eq!(Ordering::Greater, 0.5_f64.total_cmp(&f64::MIN_POSITIVE));
 779     assert_eq!(Ordering::Greater, 1.0_f64.total_cmp(&0.5));
 780     assert_eq!(Ordering::Greater, 1.5_f64.total_cmp(&1.0));
 781     assert_eq!(Ordering::Greater, 2.5_f64.total_cmp(&1.5));
 782     assert_eq!(Ordering::Greater, f64::MAX.total_cmp(&2.5));
 783     assert_eq!(Ordering::Greater, f64::INFINITY.total_cmp(&f64::MAX));
 784     assert_eq!(Ordering::Greater, s_nan().total_cmp(&f64::INFINITY));
 785     assert_eq!(Ordering::Greater, q_nan().total_cmp(&s_nan()));
 786
 787     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-s_nan()));
 788     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-f64::INFINITY));
 789     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-f64::MAX));
 790     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-2.5));
 791     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-1.5));
 792     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-1.0));
 793     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-0.5));
 794     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-f64::MIN_POSITIVE));
 795     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-max_subnorm()));
 796     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-min_subnorm()));
 797     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-0.0));
 798     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&0.0));
 799     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&min_subnorm()));
 800     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&max_subnorm()));
 801     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&f64::MIN_POSITIVE));
 802     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&0.5));
 803     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&1.0));
 804     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&1.5));
 805     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&2.5));
 806     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&f64::MAX));
 807     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&f64::INFINITY));
 808     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&s_nan()));
 809
 810     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-f64::INFINITY));
 811     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-f64::MAX));
 812     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-2.5));
 813     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-1.5));
 814     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-1.0));
 815     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-0.5));
 816     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-f64::MIN_POSITIVE));
 817     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-max_subnorm()));
 818     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-min_subnorm()));
 819     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-0.0));
 820     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&0.0));
 821     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&min_subnorm()));
 822     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&max_subnorm()));
 823     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&f64::MIN_POSITIVE));
 824     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&0.5));
 825     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&1.0));
 826     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&1.5));
 827     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&2.5));
 828     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&f64::MAX));
 829     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&f64::INFINITY));
 830     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&s_nan()));
 831 }