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