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 #[test]
 293 fn test_next_up() {
 294     let tiny = f64::from_bits(1);
 295     let tiny_up = f64::from_bits(2);
 296     let max_down = f64::from_bits(0x7fef_ffff_ffff_fffe);
 297     let largest_subnormal = f64::from_bits(0x000f_ffff_ffff_ffff);
 298     let smallest_normal = f64::from_bits(0x0010_0000_0000_0000);
 299
 300     // Check that NaNs roundtrip.
 301     let nan0 = f64::NAN;
 302     let nan1 = f64::from_bits(f64::NAN.to_bits() ^ 0x000a_aaaa_aaaa_aaaa);
 303     let nan2 = f64::from_bits(f64::NAN.to_bits() ^ 0x0005_5555_5555_5555);
 304     assert_eq!(nan0.next_up().to_bits(), nan0.to_bits());
 305     assert_eq!(nan1.next_up().to_bits(), nan1.to_bits());
 306     assert_eq!(nan2.next_up().to_bits(), nan2.to_bits());
 307
 308     assert_eq!(f64::NEG_INFINITY.next_up(), f64::MIN);
 309     assert_eq!(f64::MIN.next_up(), -max_down);
 310     assert_eq!((-1.0 - f64::EPSILON).next_up(), -1.0);
 311     assert_eq!((-smallest_normal).next_up(), -largest_subnormal);
 312     assert_eq!((-tiny_up).next_up(), -tiny);
 313     assert_eq!((-tiny).next_up().to_bits(), (-0.0f64).to_bits());
 314     assert_eq!((-0.0f64).next_up(), tiny);
 315     assert_eq!(0.0f64.next_up(), tiny);
 316     assert_eq!(tiny.next_up(), tiny_up);
 317     assert_eq!(largest_subnormal.next_up(), smallest_normal);
 318     assert_eq!(1.0f64.next_up(), 1.0 + f64::EPSILON);
 319     assert_eq!(f64::MAX.next_up(), f64::INFINITY);
 320     assert_eq!(f64::INFINITY.next_up(), f64::INFINITY);
 321 }
 322
 323 #[test]
 324 fn test_next_down() {
 325     let tiny = f64::from_bits(1);
 326     let tiny_up = f64::from_bits(2);
 327     let max_down = f64::from_bits(0x7fef_ffff_ffff_fffe);
 328     let largest_subnormal = f64::from_bits(0x000f_ffff_ffff_ffff);
 329     let smallest_normal = f64::from_bits(0x0010_0000_0000_0000);
 330
 331     // Check that NaNs roundtrip.
 332     let nan0 = f64::NAN;
 333     let nan1 = f64::from_bits(f64::NAN.to_bits() ^ 0x000a_aaaa_aaaa_aaaa);
 334     let nan2 = f64::from_bits(f64::NAN.to_bits() ^ 0x0005_5555_5555_5555);
 335     assert_eq!(nan0.next_down().to_bits(), nan0.to_bits());
 336     assert_eq!(nan1.next_down().to_bits(), nan1.to_bits());
 337     assert_eq!(nan2.next_down().to_bits(), nan2.to_bits());
 338
 339     assert_eq!(f64::NEG_INFINITY.next_down(), f64::NEG_INFINITY);
 340     assert_eq!(f64::MIN.next_down(), f64::NEG_INFINITY);
 341     assert_eq!((-max_down).next_down(), f64::MIN);
 342     assert_eq!((-1.0f64).next_down(), -1.0 - f64::EPSILON);
 343     assert_eq!((-largest_subnormal).next_down(), -smallest_normal);
 344     assert_eq!((-tiny).next_down(), -tiny_up);
 345     assert_eq!((-0.0f64).next_down(), -tiny);
 346     assert_eq!((0.0f64).next_down(), -tiny);
 347     assert_eq!(tiny.next_down().to_bits(), 0.0f64.to_bits());
 348     assert_eq!(tiny_up.next_down(), tiny);
 349     assert_eq!(smallest_normal.next_down(), largest_subnormal);
 350     assert_eq!((1.0 + f64::EPSILON).next_down(), 1.0f64);
 351     assert_eq!(f64::MAX.next_down(), max_down);
 352     assert_eq!(f64::INFINITY.next_down(), f64::MAX);
 353 }
 354
 355 #[test]
 356 fn test_mul_add() {
 357     let nan: f64 = f64::NAN;
 358     let inf: f64 = f64::INFINITY;
 359     let neg_inf: f64 = f64::NEG_INFINITY;
 360     assert_approx_eq!(12.3f64.mul_add(4.5, 6.7), 62.05);
 361     assert_approx_eq!((-12.3f64).mul_add(-4.5, -6.7), 48.65);
 362     assert_approx_eq!(0.0f64.mul_add(8.9, 1.2), 1.2);
 363     assert_approx_eq!(3.4f64.mul_add(-0.0, 5.6), 5.6);
 364     assert!(nan.mul_add(7.8, 9.0).is_nan());
 365     assert_eq!(inf.mul_add(7.8, 9.0), inf);
 366     assert_eq!(neg_inf.mul_add(7.8, 9.0), neg_inf);
 367     assert_eq!(8.9f64.mul_add(inf, 3.2), inf);
 368     assert_eq!((-3.2f64).mul_add(2.4, neg_inf), neg_inf);
 369 }
 370
 371 #[test]
 372 fn test_recip() {
 373     let nan: f64 = f64::NAN;
 374     let inf: f64 = f64::INFINITY;
 375     let neg_inf: f64 = f64::NEG_INFINITY;
 376     assert_eq!(1.0f64.recip(), 1.0);
 377     assert_eq!(2.0f64.recip(), 0.5);
 378     assert_eq!((-0.4f64).recip(), -2.5);
 379     assert_eq!(0.0f64.recip(), inf);
 380     assert!(nan.recip().is_nan());
 381     assert_eq!(inf.recip(), 0.0);
 382     assert_eq!(neg_inf.recip(), 0.0);
 383 }
 384
 385 #[test]
 386 fn test_powi() {
 387     let nan: f64 = f64::NAN;
 388     let inf: f64 = f64::INFINITY;
 389     let neg_inf: f64 = f64::NEG_INFINITY;
 390     assert_eq!(1.0f64.powi(1), 1.0);
 391     assert_approx_eq!((-3.1f64).powi(2), 9.61);
 392     assert_approx_eq!(5.9f64.powi(-2), 0.028727);
 393     assert_eq!(8.3f64.powi(0), 1.0);
 394     assert!(nan.powi(2).is_nan());
 395     assert_eq!(inf.powi(3), inf);
 396     assert_eq!(neg_inf.powi(2), inf);
 397 }
 398
 399 #[test]
 400 fn test_powf() {
 401     let nan: f64 = f64::NAN;
 402     let inf: f64 = f64::INFINITY;
 403     let neg_inf: f64 = f64::NEG_INFINITY;
 404     assert_eq!(1.0f64.powf(1.0), 1.0);
 405     assert_approx_eq!(3.4f64.powf(4.5), 246.408183);
 406     assert_approx_eq!(2.7f64.powf(-3.2), 0.041652);
 407     assert_approx_eq!((-3.1f64).powf(2.0), 9.61);
 408     assert_approx_eq!(5.9f64.powf(-2.0), 0.028727);
 409     assert_eq!(8.3f64.powf(0.0), 1.0);
 410     assert!(nan.powf(2.0).is_nan());
 411     assert_eq!(inf.powf(2.0), inf);
 412     assert_eq!(neg_inf.powf(3.0), neg_inf);
 413 }
 414
 415 #[test]
 416 fn test_sqrt_domain() {
 417     assert!(f64::NAN.sqrt().is_nan());
 418     assert!(f64::NEG_INFINITY.sqrt().is_nan());
 419     assert!((-1.0f64).sqrt().is_nan());
 420     assert_eq!((-0.0f64).sqrt(), -0.0);
 421     assert_eq!(0.0f64.sqrt(), 0.0);
 422     assert_eq!(1.0f64.sqrt(), 1.0);
 423     assert_eq!(f64::INFINITY.sqrt(), f64::INFINITY);
 424 }
 425
 426 #[test]
 427 fn test_exp() {
 428     assert_eq!(1.0, 0.0f64.exp());
 429     assert_approx_eq!(2.718282, 1.0f64.exp());
 430     assert_approx_eq!(148.413159, 5.0f64.exp());
 431
 432     let inf: f64 = f64::INFINITY;
 433     let neg_inf: f64 = f64::NEG_INFINITY;
 434     let nan: f64 = f64::NAN;
 435     assert_eq!(inf, inf.exp());
 436     assert_eq!(0.0, neg_inf.exp());
 437     assert!(nan.exp().is_nan());
 438 }
 439
 440 #[test]
 441 fn test_exp2() {
 442     assert_eq!(32.0, 5.0f64.exp2());
 443     assert_eq!(1.0, 0.0f64.exp2());
 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.exp2());
 449     assert_eq!(0.0, neg_inf.exp2());
 450     assert!(nan.exp2().is_nan());
 451 }
 452
 453 #[test]
 454 fn test_ln() {
 455     let nan: f64 = f64::NAN;
 456     let inf: f64 = f64::INFINITY;
 457     let neg_inf: f64 = f64::NEG_INFINITY;
 458     assert_approx_eq!(1.0f64.exp().ln(), 1.0);
 459     assert!(nan.ln().is_nan());
 460     assert_eq!(inf.ln(), inf);
 461     assert!(neg_inf.ln().is_nan());
 462     assert!((-2.3f64).ln().is_nan());
 463     assert_eq!((-0.0f64).ln(), neg_inf);
 464     assert_eq!(0.0f64.ln(), neg_inf);
 465     assert_approx_eq!(4.0f64.ln(), 1.386294);
 466 }
 467
 468 #[test]
 469 fn test_log() {
 470     let nan: f64 = f64::NAN;
 471     let inf: f64 = f64::INFINITY;
 472     let neg_inf: f64 = f64::NEG_INFINITY;
 473     assert_eq!(10.0f64.log(10.0), 1.0);
 474     assert_approx_eq!(2.3f64.log(3.5), 0.664858);
 475     assert_eq!(1.0f64.exp().log(1.0f64.exp()), 1.0);
 476     assert!(1.0f64.log(1.0).is_nan());
 477     assert!(1.0f64.log(-13.9).is_nan());
 478     assert!(nan.log(2.3).is_nan());
 479     assert_eq!(inf.log(10.0), inf);
 480     assert!(neg_inf.log(8.8).is_nan());
 481     assert!((-2.3f64).log(0.1).is_nan());
 482     assert_eq!((-0.0f64).log(2.0), neg_inf);
 483     assert_eq!(0.0f64.log(7.0), neg_inf);
 484 }
 485
 486 #[test]
 487 fn test_log2() {
 488     let nan: f64 = f64::NAN;
 489     let inf: f64 = f64::INFINITY;
 490     let neg_inf: f64 = f64::NEG_INFINITY;
 491     assert_approx_eq!(10.0f64.log2(), 3.321928);
 492     assert_approx_eq!(2.3f64.log2(), 1.201634);
 493     assert_approx_eq!(1.0f64.exp().log2(), 1.442695);
 494     assert!(nan.log2().is_nan());
 495     assert_eq!(inf.log2(), inf);
 496     assert!(neg_inf.log2().is_nan());
 497     assert!((-2.3f64).log2().is_nan());
 498     assert_eq!((-0.0f64).log2(), neg_inf);
 499     assert_eq!(0.0f64.log2(), neg_inf);
 500 }
 501
 502 #[test]
 503 fn test_log10() {
 504     let nan: f64 = f64::NAN;
 505     let inf: f64 = f64::INFINITY;
 506     let neg_inf: f64 = f64::NEG_INFINITY;
 507     assert_eq!(10.0f64.log10(), 1.0);
 508     assert_approx_eq!(2.3f64.log10(), 0.361728);
 509     assert_approx_eq!(1.0f64.exp().log10(), 0.434294);
 510     assert_eq!(1.0f64.log10(), 0.0);
 511     assert!(nan.log10().is_nan());
 512     assert_eq!(inf.log10(), inf);
 513     assert!(neg_inf.log10().is_nan());
 514     assert!((-2.3f64).log10().is_nan());
 515     assert_eq!((-0.0f64).log10(), neg_inf);
 516     assert_eq!(0.0f64.log10(), neg_inf);
 517 }
 518
 519 #[test]
 520 fn test_to_degrees() {
 521     let pi: f64 = consts::PI;
 522     let nan: f64 = f64::NAN;
 523     let inf: f64 = f64::INFINITY;
 524     let neg_inf: f64 = f64::NEG_INFINITY;
 525     assert_eq!(0.0f64.to_degrees(), 0.0);
 526     assert_approx_eq!((-5.8f64).to_degrees(), -332.315521);
 527     assert_eq!(pi.to_degrees(), 180.0);
 528     assert!(nan.to_degrees().is_nan());
 529     assert_eq!(inf.to_degrees(), inf);
 530     assert_eq!(neg_inf.to_degrees(), neg_inf);
 531 }
 532
 533 #[test]
 534 fn test_to_radians() {
 535     let pi: f64 = consts::PI;
 536     let nan: f64 = f64::NAN;
 537     let inf: f64 = f64::INFINITY;
 538     let neg_inf: f64 = f64::NEG_INFINITY;
 539     assert_eq!(0.0f64.to_radians(), 0.0);
 540     assert_approx_eq!(154.6f64.to_radians(), 2.698279);
 541     assert_approx_eq!((-332.31f64).to_radians(), -5.799903);
 542     assert_eq!(180.0f64.to_radians(), pi);
 543     assert!(nan.to_radians().is_nan());
 544     assert_eq!(inf.to_radians(), inf);
 545     assert_eq!(neg_inf.to_radians(), neg_inf);
 546 }
 547
 548 #[test]
 549 fn test_asinh() {
 550     assert_eq!(0.0f64.asinh(), 0.0f64);
 551     assert_eq!((-0.0f64).asinh(), -0.0f64);
 552
 553     let inf: f64 = f64::INFINITY;
 554     let neg_inf: f64 = f64::NEG_INFINITY;
 555     let nan: f64 = f64::NAN;
 556     assert_eq!(inf.asinh(), inf);
 557     assert_eq!(neg_inf.asinh(), neg_inf);
 558     assert!(nan.asinh().is_nan());
 559     assert!((-0.0f64).asinh().is_sign_negative());
 560     // issue 63271
 561     assert_approx_eq!(2.0f64.asinh(), 1.443635475178810342493276740273105f64);
 562     assert_approx_eq!((-2.0f64).asinh(), -1.443635475178810342493276740273105f64);
 563     // regression test for the catastrophic cancellation fixed in 72486
 564     assert_approx_eq!((-67452098.07139316f64).asinh(), -18.72007542627454439398548429400083);
 565 }
 566
 567 #[test]
 568 fn test_acosh() {
 569     assert_eq!(1.0f64.acosh(), 0.0f64);
 570     assert!(0.999f64.acosh().is_nan());
 571
 572     let inf: f64 = f64::INFINITY;
 573     let neg_inf: f64 = f64::NEG_INFINITY;
 574     let nan: f64 = f64::NAN;
 575     assert_eq!(inf.acosh(), inf);
 576     assert!(neg_inf.acosh().is_nan());
 577     assert!(nan.acosh().is_nan());
 578     assert_approx_eq!(2.0f64.acosh(), 1.31695789692481670862504634730796844f64);
 579     assert_approx_eq!(3.0f64.acosh(), 1.76274717403908605046521864995958461f64);
 580 }
 581
 582 #[test]
 583 fn test_atanh() {
 584     assert_eq!(0.0f64.atanh(), 0.0f64);
 585     assert_eq!((-0.0f64).atanh(), -0.0f64);
 586
 587     let inf: f64 = f64::INFINITY;
 588     let neg_inf: f64 = f64::NEG_INFINITY;
 589     let nan: f64 = f64::NAN;
 590     assert_eq!(1.0f64.atanh(), inf);
 591     assert_eq!((-1.0f64).atanh(), neg_inf);
 592     assert!(2f64.atanh().atanh().is_nan());
 593     assert!((-2f64).atanh().atanh().is_nan());
 594     assert!(inf.atanh().is_nan());
 595     assert!(neg_inf.atanh().is_nan());
 596     assert!(nan.atanh().is_nan());
 597     assert_approx_eq!(0.5f64.atanh(), 0.54930614433405484569762261846126285f64);
 598     assert_approx_eq!((-0.5f64).atanh(), -0.54930614433405484569762261846126285f64);
 599 }
 600
 601 #[test]
 602 fn test_real_consts() {
 603     use super::consts;
 604     let pi: f64 = consts::PI;
 605     let frac_pi_2: f64 = consts::FRAC_PI_2;
 606     let frac_pi_3: f64 = consts::FRAC_PI_3;
 607     let frac_pi_4: f64 = consts::FRAC_PI_4;
 608     let frac_pi_6: f64 = consts::FRAC_PI_6;
 609     let frac_pi_8: f64 = consts::FRAC_PI_8;
 610     let frac_1_pi: f64 = consts::FRAC_1_PI;
 611     let frac_2_pi: f64 = consts::FRAC_2_PI;
 612     let frac_2_sqrtpi: f64 = consts::FRAC_2_SQRT_PI;
 613     let sqrt2: f64 = consts::SQRT_2;
 614     let frac_1_sqrt2: f64 = consts::FRAC_1_SQRT_2;
 615     let e: f64 = consts::E;
 616     let log2_e: f64 = consts::LOG2_E;
 617     let log10_e: f64 = consts::LOG10_E;
 618     let ln_2: f64 = consts::LN_2;
 619     let ln_10: f64 = consts::LN_10;
 620
 621     assert_approx_eq!(frac_pi_2, pi / 2f64);
 622     assert_approx_eq!(frac_pi_3, pi / 3f64);
 623     assert_approx_eq!(frac_pi_4, pi / 4f64);
 624     assert_approx_eq!(frac_pi_6, pi / 6f64);
 625     assert_approx_eq!(frac_pi_8, pi / 8f64);
 626     assert_approx_eq!(frac_1_pi, 1f64 / pi);
 627     assert_approx_eq!(frac_2_pi, 2f64 / pi);
 628     assert_approx_eq!(frac_2_sqrtpi, 2f64 / pi.sqrt());
 629     assert_approx_eq!(sqrt2, 2f64.sqrt());
 630     assert_approx_eq!(frac_1_sqrt2, 1f64 / 2f64.sqrt());
 631     assert_approx_eq!(log2_e, e.log2());
 632     assert_approx_eq!(log10_e, e.log10());
 633     assert_approx_eq!(ln_2, 2f64.ln());
 634     assert_approx_eq!(ln_10, 10f64.ln());
 635 }
 636
 637 #[test]
 638 fn test_float_bits_conv() {
 639     assert_eq!((1f64).to_bits(), 0x3ff0000000000000);
 640     assert_eq!((12.5f64).to_bits(), 0x4029000000000000);
 641     assert_eq!((1337f64).to_bits(), 0x4094e40000000000);
 642     assert_eq!((-14.25f64).to_bits(), 0xc02c800000000000);
 643     assert_approx_eq!(f64::from_bits(0x3ff0000000000000), 1.0);
 644     assert_approx_eq!(f64::from_bits(0x4029000000000000), 12.5);
 645     assert_approx_eq!(f64::from_bits(0x4094e40000000000), 1337.0);
 646     assert_approx_eq!(f64::from_bits(0xc02c800000000000), -14.25);
 647
 648     // Check that NaNs roundtrip their bits regardless of signaling-ness
 649     // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
 650     let masked_nan1 = f64::NAN.to_bits() ^ 0x000A_AAAA_AAAA_AAAA;
 651     let masked_nan2 = f64::NAN.to_bits() ^ 0x0005_5555_5555_5555;
 652     assert!(f64::from_bits(masked_nan1).is_nan());
 653     assert!(f64::from_bits(masked_nan2).is_nan());
 654
 655     assert_eq!(f64::from_bits(masked_nan1).to_bits(), masked_nan1);
 656     assert_eq!(f64::from_bits(masked_nan2).to_bits(), masked_nan2);
 657 }
 658
 659 #[test]
 660 #[should_panic]
 661 fn test_clamp_min_greater_than_max() {
 662     let _ = 1.0f64.clamp(3.0, 1.0);
 663 }
 664
 665 #[test]
 666 #[should_panic]
 667 fn test_clamp_min_is_nan() {
 668     let _ = 1.0f64.clamp(f64::NAN, 1.0);
 669 }
 670
 671 #[test]
 672 #[should_panic]
 673 fn test_clamp_max_is_nan() {
 674     let _ = 1.0f64.clamp(3.0, f64::NAN);
 675 }
 676
 677 #[test]
 678 fn test_total_cmp() {
 679     use core::cmp::Ordering;
 680
 681     fn quiet_bit_mask() -> u64 {
 682         1 << (f64::MANTISSA_DIGITS - 2)
 683     }
 684
 685     fn min_subnorm() -> f64 {
 686         f64::MIN_POSITIVE / f64::powf(2.0, f64::MANTISSA_DIGITS as f64 - 1.0)
 687     }
 688
 689     fn max_subnorm() -> f64 {
 690         f64::MIN_POSITIVE - min_subnorm()
 691     }
 692
 693     fn q_nan() -> f64 {
 694         f64::from_bits(f64::NAN.to_bits() | quiet_bit_mask())
 695     }
 696
 697     fn s_nan() -> f64 {
 698         f64::from_bits((f64::NAN.to_bits() & !quiet_bit_mask()) + 42)
 699     }
 700
 701     assert_eq!(Ordering::Equal, (-q_nan()).total_cmp(&-q_nan()));
 702     assert_eq!(Ordering::Equal, (-s_nan()).total_cmp(&-s_nan()));
 703     assert_eq!(Ordering::Equal, (-f64::INFINITY).total_cmp(&-f64::INFINITY));
 704     assert_eq!(Ordering::Equal, (-f64::MAX).total_cmp(&-f64::MAX));
 705     assert_eq!(Ordering::Equal, (-2.5_f64).total_cmp(&-2.5));
 706     assert_eq!(Ordering::Equal, (-1.0_f64).total_cmp(&-1.0));
 707     assert_eq!(Ordering::Equal, (-1.5_f64).total_cmp(&-1.5));
 708     assert_eq!(Ordering::Equal, (-0.5_f64).total_cmp(&-0.5));
 709     assert_eq!(Ordering::Equal, (-f64::MIN_POSITIVE).total_cmp(&-f64::MIN_POSITIVE));
 710     assert_eq!(Ordering::Equal, (-max_subnorm()).total_cmp(&-max_subnorm()));
 711     assert_eq!(Ordering::Equal, (-min_subnorm()).total_cmp(&-min_subnorm()));
 712     assert_eq!(Ordering::Equal, (-0.0_f64).total_cmp(&-0.0));
 713     assert_eq!(Ordering::Equal, 0.0_f64.total_cmp(&0.0));
 714     assert_eq!(Ordering::Equal, min_subnorm().total_cmp(&min_subnorm()));
 715     assert_eq!(Ordering::Equal, max_subnorm().total_cmp(&max_subnorm()));
 716     assert_eq!(Ordering::Equal, f64::MIN_POSITIVE.total_cmp(&f64::MIN_POSITIVE));
 717     assert_eq!(Ordering::Equal, 0.5_f64.total_cmp(&0.5));
 718     assert_eq!(Ordering::Equal, 1.0_f64.total_cmp(&1.0));
 719     assert_eq!(Ordering::Equal, 1.5_f64.total_cmp(&1.5));
 720     assert_eq!(Ordering::Equal, 2.5_f64.total_cmp(&2.5));
 721     assert_eq!(Ordering::Equal, f64::MAX.total_cmp(&f64::MAX));
 722     assert_eq!(Ordering::Equal, f64::INFINITY.total_cmp(&f64::INFINITY));
 723     assert_eq!(Ordering::Equal, s_nan().total_cmp(&s_nan()));
 724     assert_eq!(Ordering::Equal, q_nan().total_cmp(&q_nan()));
 725
 726     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-s_nan()));
 727     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-f64::INFINITY));
 728     assert_eq!(Ordering::Less, (-f64::INFINITY).total_cmp(&-f64::MAX));
 729     assert_eq!(Ordering::Less, (-f64::MAX).total_cmp(&-2.5));
 730     assert_eq!(Ordering::Less, (-2.5_f64).total_cmp(&-1.5));
 731     assert_eq!(Ordering::Less, (-1.5_f64).total_cmp(&-1.0));
 732     assert_eq!(Ordering::Less, (-1.0_f64).total_cmp(&-0.5));
 733     assert_eq!(Ordering::Less, (-0.5_f64).total_cmp(&-f64::MIN_POSITIVE));
 734     assert_eq!(Ordering::Less, (-f64::MIN_POSITIVE).total_cmp(&-max_subnorm()));
 735     assert_eq!(Ordering::Less, (-max_subnorm()).total_cmp(&-min_subnorm()));
 736     assert_eq!(Ordering::Less, (-min_subnorm()).total_cmp(&-0.0));
 737     assert_eq!(Ordering::Less, (-0.0_f64).total_cmp(&0.0));
 738     assert_eq!(Ordering::Less, 0.0_f64.total_cmp(&min_subnorm()));
 739     assert_eq!(Ordering::Less, min_subnorm().total_cmp(&max_subnorm()));
 740     assert_eq!(Ordering::Less, max_subnorm().total_cmp(&f64::MIN_POSITIVE));
 741     assert_eq!(Ordering::Less, f64::MIN_POSITIVE.total_cmp(&0.5));
 742     assert_eq!(Ordering::Less, 0.5_f64.total_cmp(&1.0));
 743     assert_eq!(Ordering::Less, 1.0_f64.total_cmp(&1.5));
 744     assert_eq!(Ordering::Less, 1.5_f64.total_cmp(&2.5));
 745     assert_eq!(Ordering::Less, 2.5_f64.total_cmp(&f64::MAX));
 746     assert_eq!(Ordering::Less, f64::MAX.total_cmp(&f64::INFINITY));
 747     assert_eq!(Ordering::Less, f64::INFINITY.total_cmp(&s_nan()));
 748     assert_eq!(Ordering::Less, s_nan().total_cmp(&q_nan()));
 749
 750     assert_eq!(Ordering::Greater, (-s_nan()).total_cmp(&-q_nan()));
 751     assert_eq!(Ordering::Greater, (-f64::INFINITY).total_cmp(&-s_nan()));
 752     assert_eq!(Ordering::Greater, (-f64::MAX).total_cmp(&-f64::INFINITY));
 753     assert_eq!(Ordering::Greater, (-2.5_f64).total_cmp(&-f64::MAX));
 754     assert_eq!(Ordering::Greater, (-1.5_f64).total_cmp(&-2.5));
 755     assert_eq!(Ordering::Greater, (-1.0_f64).total_cmp(&-1.5));
 756     assert_eq!(Ordering::Greater, (-0.5_f64).total_cmp(&-1.0));
 757     assert_eq!(Ordering::Greater, (-f64::MIN_POSITIVE).total_cmp(&-0.5));
 758     assert_eq!(Ordering::Greater, (-max_subnorm()).total_cmp(&-f64::MIN_POSITIVE));
 759     assert_eq!(Ordering::Greater, (-min_subnorm()).total_cmp(&-max_subnorm()));
 760     assert_eq!(Ordering::Greater, (-0.0_f64).total_cmp(&-min_subnorm()));
 761     assert_eq!(Ordering::Greater, 0.0_f64.total_cmp(&-0.0));
 762     assert_eq!(Ordering::Greater, min_subnorm().total_cmp(&0.0));
 763     assert_eq!(Ordering::Greater, max_subnorm().total_cmp(&min_subnorm()));
 764     assert_eq!(Ordering::Greater, f64::MIN_POSITIVE.total_cmp(&max_subnorm()));
 765     assert_eq!(Ordering::Greater, 0.5_f64.total_cmp(&f64::MIN_POSITIVE));
 766     assert_eq!(Ordering::Greater, 1.0_f64.total_cmp(&0.5));
 767     assert_eq!(Ordering::Greater, 1.5_f64.total_cmp(&1.0));
 768     assert_eq!(Ordering::Greater, 2.5_f64.total_cmp(&1.5));
 769     assert_eq!(Ordering::Greater, f64::MAX.total_cmp(&2.5));
 770     assert_eq!(Ordering::Greater, f64::INFINITY.total_cmp(&f64::MAX));
 771     assert_eq!(Ordering::Greater, s_nan().total_cmp(&f64::INFINITY));
 772     assert_eq!(Ordering::Greater, q_nan().total_cmp(&s_nan()));
 773
 774     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-s_nan()));
 775     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-f64::INFINITY));
 776     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-f64::MAX));
 777     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-2.5));
 778     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-1.5));
 779     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-1.0));
 780     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-0.5));
 781     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-f64::MIN_POSITIVE));
 782     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-max_subnorm()));
 783     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-min_subnorm()));
 784     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-0.0));
 785     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&0.0));
 786     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&min_subnorm()));
 787     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&max_subnorm()));
 788     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&f64::MIN_POSITIVE));
 789     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&0.5));
 790     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&1.0));
 791     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&1.5));
 792     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&2.5));
 793     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&f64::MAX));
 794     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&f64::INFINITY));
 795     assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&s_nan()));
 796
 797     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-f64::INFINITY));
 798     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-f64::MAX));
 799     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-2.5));
 800     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-1.5));
 801     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-1.0));
 802     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-0.5));
 803     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-f64::MIN_POSITIVE));
 804     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-max_subnorm()));
 805     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-min_subnorm()));
 806     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-0.0));
 807     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&0.0));
 808     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&min_subnorm()));
 809     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&max_subnorm()));
 810     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&f64::MIN_POSITIVE));
 811     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&0.5));
 812     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&1.0));
 813     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&1.5));
 814     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&2.5));
 815     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&f64::MAX));
 816     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&f64::INFINITY));
 817     assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&s_nan()));
 818 }