use std::{f32, f64};
use sigils::Constants;


#[test]
fn constant_check_f32()
{
   let val: f32 = Constants::SQRT_2;
   assert_eq!(val, f32::consts::SQRT_2);
   let val: f32 = Constants::SQRT_3;
   assert_eq!(val, 1.73205080756887729352f32);
   let val: f32 = Constants::INVERSE_SQRT_2;
   assert_eq!(val, 1.0f32 / f32::consts::SQRT_2);
   let val: f32 = Constants::INVERSE_SQRT_3;
   assert_eq!(val, 1.0f32 / 1.73205080756887729352f32);

   let val: f32 = Constants::E;
   assert_eq!(val, f32::consts::E);

   let val: f32 = Constants::LOG2_E;
   assert_eq!(val, f32::consts::LOG2_E);
   let val: f32 = Constants::LOG10_E;
   assert_eq!(val, f32::consts::LOG10_E);
   let val: f32 = Constants::LOGE_2;
   assert_eq!(val, 2f32.ln());
   let val: f32 = Constants::LOGE_10;
   assert_eq!(val, 10f32.ln());

   let val: f32 = Constants::TWO_PI;
   assert_eq!(val, 2f32 * f32::consts::PI);
   let val: f32 = Constants::PI;
   assert_eq!(val, f32::consts::PI);
   let val: f32 = Constants::HALF_PI;
   assert_eq!(val, f32::consts::PI / 2f32);
   let val: f32 = Constants::THIRD_PI;
   assert_eq!(val, f32::consts::PI / 3f32);
   let val: f32 = Constants::QUARTER_PI;
   assert_eq!(val, f32::consts::PI / 4f32);
   let val: f32 = Constants::SIXTH_PI;
   assert_eq!(val, f32::consts::PI / 6f32);
   let val: f32 = Constants::EIGHTH_PI;
   assert_eq!(val, f32::consts::PI / 8f32);
   let val: f32 = Constants::INVERSE_PI;
   assert_eq!(val, 1.0f32 / f32::consts::PI);
   let val: f32 = Constants::TWO_INVERSE_PI;
   assert_eq!(val, 2.0f32 / f32::consts::PI);
   let val: f32 = Constants::TWO_INVERSE_SQRT_PI;
   assert_eq!(val, 2.0f32 / (f32::consts::PI).sqrt());
}

#[test]
fn constant_check_f64()
{
   let val: f64 = Constants::SQRT_2;
   assert_eq!(val, f64::consts::SQRT_2);
   let val: f64 = Constants::SQRT_3;
   assert_eq!(val, 1.73205080756887729352f64);
   let val: f64 = Constants::INVERSE_SQRT_2;
   assert_eq!(val, 1.0f64 / f64::consts::SQRT_2);
   let val: f64 = Constants::INVERSE_SQRT_3;
   assert_eq!(val, 1.0f64 / 1.73205080756887729352f64);

   let val: f64 = Constants::E;
   assert_eq!(val, f64::consts::E);

   let val: f64 = Constants::LOG2_E;
   assert_eq!(val, f64::consts::LOG2_E);
   let val: f64 = Constants::LOG10_E;
   assert_eq!(val, f64::consts::LOG10_E);
   let val: f64 = Constants::LOGE_2;
   assert_eq!(val, 2f64.ln());
   let val: f64 = Constants::LOGE_10;
   assert_eq!(val, 10f64.ln());

   let val: f64 = Constants::TWO_PI;
   assert_eq!(val, 2f64 * f64::consts::PI);
   let val: f64 = Constants::PI;
   assert_eq!(val, f64::consts::PI);
   let val: f64 = Constants::HALF_PI;
   assert_eq!(val, f64::consts::PI / 2f64);
   let val: f64 = Constants::THIRD_PI;
   assert_eq!(val, f64::consts::PI / 3f64);
   let val: f64 = Constants::QUARTER_PI;
   assert_eq!(val, f64::consts::PI / 4f64);
   let val: f64 = Constants::SIXTH_PI;
   assert_eq!(val, f64::consts::PI / 6f64);
   let val: f64 = Constants::EIGHTH_PI;
   assert_eq!(val, f64::consts::PI / 8f64);
   let val: f64 = Constants::INVERSE_PI;
   assert_eq!(val, 1.0f64 / f64::consts::PI);
   let val: f64 = Constants::TWO_INVERSE_PI;
   assert_eq!(val, 2.0f64 / f64::consts::PI);
   let val: f64 = Constants::TWO_INVERSE_SQRT_PI;
   assert_eq!(val, 2.0f64 / (f64::consts::PI).sqrt());
}