src/tools/miri/tests/pass/intrinsics-math.rs

   1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 macro_rules! assert_approx_eq {
  12     ($a:expr, $b:expr) => {{
  13         let (a, b) = (&$a, &$b);
  14         assert!((*a - *b).abs() < 1.0e-6, "{} is not approximately equal to {}", *a, *b);
  15     }};
  16 }
  17
  18 fn ldexp(a: f64, b: i32) -> f64 {
  19     extern "C" {
  20         fn ldexp(x: f64, n: i32) -> f64;
  21     }
  22     unsafe { ldexp(a, b) }
  23 }
  24
  25 pub fn main() {
  26     use std::f32;
  27     use std::f64;
  28
  29     assert_approx_eq!(64f32.sqrt(), 8f32);
  30     assert_approx_eq!(64f64.sqrt(), 8f64);
  31
  32     assert_approx_eq!(25f32.powi(-2), 0.0016f32);
  33     assert_approx_eq!(23.2f64.powi(2), 538.24f64);
  34
  35     assert_approx_eq!(25f32.powf(-2f32), 0.0016f32);
  36     assert_approx_eq!(400f64.powf(0.5f64), 20f64);
  37
  38     assert_approx_eq!(1f32.exp(), f32::consts::E);
  39     assert_approx_eq!(1f64.exp(), f64::consts::E);
  40
  41     assert_approx_eq!(1f32.exp_m1(), f32::consts::E - 1.0);
  42     assert_approx_eq!(1f64.exp_m1(), f64::consts::E - 1.0);
  43
  44     assert_approx_eq!(10f32.exp2(), 1024f32);
  45     assert_approx_eq!(50f64.exp2(), 1125899906842624f64);
  46
  47     assert_approx_eq!(f32::consts::E.ln(), 1f32);
  48     assert_approx_eq!(1f64.ln(), 0f64);
  49
  50     assert_approx_eq!(0f32.ln_1p(), 0f32);
  51     assert_approx_eq!(0f64.ln_1p(), 0f64);
  52
  53     assert_approx_eq!(10f32.log10(), 1f32);
  54     assert_approx_eq!(f64::consts::E.log10(), f64::consts::LOG10_E);
  55
  56     assert_approx_eq!(8f32.log2(), 3f32);
  57     assert_approx_eq!(f64::consts::E.log2(), f64::consts::LOG2_E);
  58
  59     assert_approx_eq!(3.0f32.mul_add(2.0f32, 5.0f32), 11.0);
  60     assert_eq!(0.0f32.mul_add(-2.0, f32::consts::E), f32::consts::E);
  61     assert_approx_eq!(3.0f64.mul_add(2.0, 5.0), 11.0);
  62     assert_eq!(0.0f64.mul_add(-2.0f64, f64::consts::E), f64::consts::E);
  63     assert_eq!((-3.2f32).mul_add(2.4, f32::NEG_INFINITY), f32::NEG_INFINITY);
  64     assert_eq!((-3.2f64).mul_add(2.4, f64::NEG_INFINITY), f64::NEG_INFINITY);
  65
  66     assert_approx_eq!((-1.0f32).abs(), 1.0f32);
  67     assert_approx_eq!(34.2f64.abs(), 34.2f64);
  68
  69     #[allow(deprecated)]
  70     {
  71         assert_approx_eq!(5.0f32.abs_sub(3.0), 2.0);
  72         assert_approx_eq!(3.0f64.abs_sub(5.0), 0.0);
  73     }
  74
  75     assert_approx_eq!(3.8f32.floor(), 3.0f32);
  76     assert_approx_eq!((-1.1f64).floor(), -2.0f64);
  77
  78     assert_approx_eq!((-2.3f32).ceil(), -2.0f32);
  79     assert_approx_eq!(3.8f64.ceil(), 4.0f64);
  80
  81     assert_approx_eq!(0.1f32.trunc(), 0.0f32);
  82     assert_approx_eq!((-0.1f64).trunc(), 0.0f64);
  83
  84     assert_approx_eq!(27.0f32.cbrt(), 3.0f32);
  85     assert_approx_eq!(27.0f64.cbrt(), 3.0f64);
  86
  87     assert_approx_eq!(3.0f32.hypot(4.0f32), 5.0f32);
  88     assert_approx_eq!(3.0f64.hypot(4.0f64), 5.0f64);
  89
  90     assert_eq!(3.3_f32.round(), 3.0);
  91     assert_eq!(3.3_f64.round(), 3.0);
  92
  93     assert_eq!(ldexp(0.65f64, 3i32), 5.2f64);
  94     assert_eq!(ldexp(1.42, 0xFFFF), f64::INFINITY);
  95     assert_eq!(ldexp(1.42, -0xFFFF), 0f64);
  96
  97     // Trigonometric functions.
  98
  99     assert_approx_eq!(0f32.sin(), 0f32);
 100     assert_approx_eq!((f64::consts::PI / 2f64).sin(), 1f64);
 101     assert_approx_eq!(f32::consts::FRAC_PI_6.sin(), 0.5);
 102     assert_approx_eq!(f64::consts::FRAC_PI_6.sin(), 0.5);
 103     assert_approx_eq!(f32::consts::FRAC_PI_4.sin().asin(), f32::consts::FRAC_PI_4);
 104     assert_approx_eq!(f64::consts::FRAC_PI_4.sin().asin(), f64::consts::FRAC_PI_4);
 105
 106     assert_approx_eq!(1.0f32.sinh(), 1.1752012f32);
 107     assert_approx_eq!(1.0f64.sinh(), 1.1752012f64);
 108     assert_approx_eq!(2.0f32.asinh(), 1.443635475178810342493276740273105f32);
 109     assert_approx_eq!((-2.0f64).asinh(), -1.443635475178810342493276740273105f64);
 110
 111     assert_approx_eq!(0f32.cos(), 1f32);
 112     assert_approx_eq!((f64::consts::PI * 2f64).cos(), 1f64);
 113     assert_approx_eq!(f32::consts::FRAC_PI_3.cos(), 0.5);
 114     assert_approx_eq!(f64::consts::FRAC_PI_3.cos(), 0.5);
 115     assert_approx_eq!(f32::consts::FRAC_PI_4.cos().acos(), f32::consts::FRAC_PI_4);
 116     assert_approx_eq!(f64::consts::FRAC_PI_4.cos().acos(), f64::consts::FRAC_PI_4);
 117
 118     assert_approx_eq!(1.0f32.cosh(), 1.54308f32);
 119     assert_approx_eq!(1.0f64.cosh(), 1.54308f64);
 120     assert_approx_eq!(2.0f32.acosh(), 1.31695789692481670862504634730796844f32);
 121     assert_approx_eq!(3.0f64.acosh(), 1.76274717403908605046521864995958461f64);
 122
 123     assert_approx_eq!(1.0f32.tan(), 1.557408f32);
 124     assert_approx_eq!(1.0f64.tan(), 1.557408f64);
 125     assert_approx_eq!(1.0_f32, 1.0_f32.tan().atan());
 126     assert_approx_eq!(1.0_f64, 1.0_f64.tan().atan());
 127     assert_approx_eq!(1.0f32.atan2(2.0f32), 0.46364761f32);
 128     assert_approx_eq!(1.0f32.atan2(2.0f32), 0.46364761f32);
 129
 130     assert_approx_eq!(
 131         1.0f32.tanh(),
 132         (1.0 - f32::consts::E.powi(-2)) / (1.0 + f32::consts::E.powi(-2))
 133     );
 134     assert_approx_eq!(
 135         1.0f64.tanh(),
 136         (1.0 - f64::consts::E.powi(-2)) / (1.0 + f64::consts::E.powi(-2))
 137     );
 138     assert_approx_eq!(0.5f32.atanh(), 0.54930614433405484569762261846126285f32);
 139     assert_approx_eq!(0.5f64.atanh(), 0.54930614433405484569762261846126285f64);
 140 }