lokacore 0.3.0

#![allow(clippy::float_cmp)]
//! Most tests here are just the example code for each method in the stdlib,
//! which is why they're a little funny compared to the usual tests.

use lokacore::*;

#[test]
fn test_abs_f32() {
  let x = 3.5_f32;
  let y = -3.5_f32;

  let abs_difference_x = abs_f32(abs_f32(x) - x);
  let abs_difference_y = abs_f32(abs_f32(y) - (-y));

  assert!(abs_difference_x <= core::f32::EPSILON);
  assert!(abs_difference_y <= core::f32::EPSILON);

  assert!(abs_f32(core::f32::NAN).is_nan());
}

#[test]
fn test_abs_f64() {
  let x = 3.5_f64;
  let y = -3.5_f64;

  let abs_difference_x = abs_f64(abs_f64(x) - x);
  let abs_difference_y = abs_f64(abs_f64(y) - (-y));

  assert!(abs_difference_x < 1e-10);
  assert!(abs_difference_y < 1e-10);

  assert!(abs_f64(core::f64::NAN).is_nan());
}

#[test]
fn test_ceil_f32() {
  assert_eq!(ceil_f32(3.01_f32), 4.0);
  assert_eq!(ceil_f32(4.0_f32), 4.0);
  assert_eq!(ceil_f32(8_388_607.5_f32), 8_388_608.0_f32);
  assert_eq!(ceil_f32(8_388_608.0_f32), 8_388_608.0_f32);
  assert_eq!(ceil_f32(8_388_609.0_f32), 8_388_609.0_f32);
  assert_eq!(ceil_f32(-0.0), -0.0);
  assert_eq!(ceil_f32(0.0), 0.0);
  assert_eq!(ceil_f32(core::f32::INFINITY), core::f32::INFINITY);
  assert_eq!(ceil_f32(core::f32::NEG_INFINITY), core::f32::NEG_INFINITY);
  assert!(ceil_f32(core::f32::NAN).is_nan());
}

#[test]
fn test_ceil_f64() {
  assert_eq!(ceil_f64(3.01_f64), 4.0);
  assert_eq!(ceil_f64(4.0_f64), 4.0);
  assert_eq!(
    ceil_f64(4_503_599_627_370_495.5_f64),
    4_503_599_627_370_496.0_f64
  );
  assert_eq!(
    ceil_f64(4_503_599_627_370_496.0_f64),
    4_503_599_627_370_496.0_f64
  );
  assert_eq!(
    ceil_f64(4_503_599_627_370_497.0_f64),
    4_503_599_627_370_497.0_f64
  );
  assert_eq!(ceil_f64(-0.0), -0.0);
  assert_eq!(ceil_f64(0.0), 0.0);
  assert_eq!(ceil_f64(core::f64::INFINITY), core::f64::INFINITY);
  assert_eq!(ceil_f64(core::f64::NEG_INFINITY), core::f64::NEG_INFINITY);
  assert!(ceil_f64(core::f64::NAN).is_nan());
}

#[test]
fn test_floor_f32() {
  assert_eq!(floor_f32(3.7_f32), 3.0);
  assert_eq!(floor_f32(3.0_f32), 3.0);
  assert_eq!(floor_f32(-3.7_f32), -4.0);
  assert_eq!(floor_f32(8_388_607.5_f32), 8_388_607.0_f32);
  assert_eq!(floor_f32(8_388_608.0_f32), 8_388_608.0_f32);
  assert_eq!(floor_f32(8_388_609.0_f32), 8_388_609.0_f32);
  assert_eq!(floor_f32(-0.0), -0.0);
  assert_eq!(floor_f32(0.0), 0.0);
  assert_eq!(floor_f32(core::f32::INFINITY), core::f32::INFINITY);
  assert_eq!(floor_f32(core::f32::NEG_INFINITY), core::f32::NEG_INFINITY);
  assert!(floor_f32(core::f32::NAN).is_nan());
}

#[test]
fn test_floor_f64() {
  assert_eq!(floor_f64(3.7_f64), 3.0);
  assert_eq!(floor_f64(3.0_f64), 3.0);
  assert_eq!(floor_f64(-3.7_f64), -4.0);
  assert_eq!(
    floor_f64(4_503_599_627_370_495.5_f64),
    4_503_599_627_370_495.0_f64
  );
  assert_eq!(
    floor_f64(4_503_599_627_370_496.0_f64),
    4_503_599_627_370_496.0_f64
  );
  assert_eq!(
    floor_f64(4_503_599_627_370_497.0_f64),
    4_503_599_627_370_497.0_f64
  );
  assert_eq!(floor_f64(-0.0), -0.0);
  assert_eq!(floor_f64(0.0), 0.0);
  assert_eq!(floor_f64(core::f64::INFINITY), core::f64::INFINITY);
  assert_eq!(floor_f64(core::f64::NEG_INFINITY), core::f64::NEG_INFINITY);
  assert!(floor_f64(core::f64::NAN).is_nan());
}

#[test]
fn test_sqrt_f32() {
  use std::f32;

  let positive = 4.0_f32;
  let negative = -4.0_f32;

  let abs_difference = (sqrt_f32(positive) - 2.0).abs();

  assert!(abs_difference <= f32::EPSILON);
  assert!(negative.sqrt().is_nan());
}

#[test]
fn test_sqrt_f64() {
  use std::f64;

  let positive = 4.0_f64;
  let negative = -4.0_f64;

  let abs_difference = (sqrt_f64(positive) - 2.0).abs();

  assert!(abs_difference <= f64::EPSILON);
  assert!(negative.sqrt().is_nan());
}