src/test/run-pass/intrinsics-math.rs

   1
   2 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
   3 // file at the top-level directory of this distribution and at
   4 // http://rust-lang.org/COPYRIGHT.
   5 //
   6 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   7 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   8 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   9 // option. This file may not be copied, modified, or distributed
  10 // except according to those terms.
  11
  12 #![feature(macro_rules, intrinsics)]
  13
  14 macro_rules! assert_approx_eq(
  15     ($a:expr, $b:expr) => ({
  16         use std::num::Float;
  17         let (a, b) = (&$a, &$b);
  18         assert!((*a - *b).abs() < 1.0e-6,
  19                 "{} is not approximately equal to {}", *a, *b);
  20     })
  21 );
  22
  23 mod rusti {
  24     extern "rust-intrinsic" {
  25         pub fn sqrtf32(x: f32) -> f32;
  26         pub fn sqrtf64(x: f64) -> f64;
  27         pub fn powif32(a: f32, x: i32) -> f32;
  28         pub fn powif64(a: f64, x: i32) -> f64;
  29         pub fn sinf32(x: f32) -> f32;
  30         pub fn sinf64(x: f64) -> f64;
  31         pub fn cosf32(x: f32) -> f32;
  32         pub fn cosf64(x: f64) -> f64;
  33         pub fn powf32(a: f32, x: f32) -> f32;
  34         pub fn powf64(a: f64, x: f64) -> f64;
  35         pub fn expf32(x: f32) -> f32;
  36         pub fn expf64(x: f64) -> f64;
  37         pub fn exp2f32(x: f32) -> f32;
  38         pub fn exp2f64(x: f64) -> f64;
  39         pub fn logf32(x: f32) -> f32;
  40         pub fn logf64(x: f64) -> f64;
  41         pub fn log10f32(x: f32) -> f32;
  42         pub fn log10f64(x: f64) -> f64;
  43         pub fn log2f32(x: f32) -> f32;
  44         pub fn log2f64(x: f64) -> f64;
  45         pub fn fmaf32(a: f32, b: f32, c: f32) -> f32;
  46         pub fn fmaf64(a: f64, b: f64, c: f64) -> f64;
  47         pub fn fabsf32(x: f32) -> f32;
  48         pub fn fabsf64(x: f64) -> f64;
  49         pub fn floorf32(x: f32) -> f32;
  50         pub fn floorf64(x: f64) -> f64;
  51         pub fn ceilf32(x: f32) -> f32;
  52         pub fn ceilf64(x: f64) -> f64;
  53         pub fn truncf32(x: f32) -> f32;
  54         pub fn truncf64(x: f64) -> f64;
  55     }
  56 }
  57
  58 pub fn main() {
  59     unsafe {
  60         use rusti::*;
  61
  62         use std::f32;
  63         use std::f64;
  64
  65         assert_approx_eq!(sqrtf32(64f32), 8f32);
  66         assert_approx_eq!(sqrtf64(64f64), 8f64);
  67
  68         assert_approx_eq!(powif32(25f32, -2i32), 0.0016f32);
  69         assert_approx_eq!(powif64(23.2f64, 2i32), 538.24f64);
  70
  71         assert_approx_eq!(sinf32(0f32), 0f32);
  72         assert_approx_eq!(sinf64(f64::consts::PI / 2f64), 1f64);
  73
  74         assert_approx_eq!(cosf32(0f32), 1f32);
  75         assert_approx_eq!(cosf64(f64::consts::PI * 2f64), 1f64);
  76
  77         assert_approx_eq!(powf32(25f32, -2f32), 0.0016f32);
  78         assert_approx_eq!(powf64(400f64, 0.5f64), 20f64);
  79
  80         assert_approx_eq!(fabsf32(expf32(1f32) - f32::consts::E), 0f32);
  81         assert_approx_eq!(expf64(1f64), f64::consts::E);
  82
  83         assert_approx_eq!(exp2f32(10f32), 1024f32);
  84         assert_approx_eq!(exp2f64(50f64), 1125899906842624f64);
  85
  86         assert_approx_eq!(fabsf32(logf32(f32::consts::E) - 1f32), 0f32);
  87         assert_approx_eq!(logf64(1f64), 0f64);
  88
  89         assert_approx_eq!(log10f32(10f32), 1f32);
  90         assert_approx_eq!(log10f64(f64::consts::E), f64::consts::LOG10_E);
  91
  92         assert_approx_eq!(log2f32(8f32), 3f32);
  93         assert_approx_eq!(log2f64(f64::consts::E), f64::consts::LOG2_E);
  94
  95         assert_approx_eq!(fmaf32(1.0f32, 2.0f32, 5.0f32), 7.0f32);
  96         assert_approx_eq!(fmaf64(0.0f64, -2.0f64, f64::consts::E), f64::consts::E);
  97
  98         assert_approx_eq!(fabsf32(-1.0f32), 1.0f32);
  99         assert_approx_eq!(fabsf64(34.2f64), 34.2f64);
 100
 101         assert_approx_eq!(floorf32(3.8f32), 3.0f32);
 102         assert_approx_eq!(floorf64(-1.1f64), -2.0f64);
 103
 104         // Causes linker error
 105         // undefined reference to llvm.ceil.f32/64
 106         //assert!((ceilf32(-2.3f32) == -2.0f32));
 107         //assert!((ceilf64(3.8f64) == 4.0f64));
 108
 109         // Causes linker error
 110         // undefined reference to llvm.trunc.f32/64
 111         //assert!((truncf32(0.1f32) == 0.0f32));
 112         //assert!((truncf64(-0.1f64) == 0.0f64));
 113     }
 114
 115 }