e1251f7b00
All the files below had at least one instance of the ternary operator present in the source. All have been changed to the equivalent if/then/else expression.
314 lines
8.8 KiB
Rust
314 lines
8.8 KiB
Rust
// Generic functions that have been defined for all numeric types
|
|
//
|
|
// (may very well go away again soon)
|
|
|
|
/*
|
|
Function: min
|
|
|
|
Returns the minimum of two values
|
|
*/
|
|
pure fn min<T: copy>(x: T, y: T) -> T { if x < y { x } else { y} }
|
|
|
|
/*
|
|
Function: max
|
|
|
|
Returns the maximum of two values
|
|
*/
|
|
pure fn max<T: copy>(x: T, y: T) -> T { if x < y { y } else { x } }
|
|
|
|
#[test]
|
|
fn test_max_min() {
|
|
assert max(0, 1) == 1;
|
|
assert min(0, 1) == 0;
|
|
assert max(0, -1) == 0;
|
|
assert min(0, -1) == -1;
|
|
assert max(0.0, 1.0) == 1.0;
|
|
assert min(0.0, 1.0) == 0.0;
|
|
}
|
|
|
|
// FIXME use macros to execute the tests below for all float types
|
|
|
|
/*
|
|
#[test]
|
|
fn test_trig() {
|
|
assert sin(0.0) == 0.0;
|
|
assert sin(-0.0) == 0.0;
|
|
|
|
assert float::isNaN(sin(float::infinity));
|
|
assert float::isNaN(sin(float::neg_infinity));
|
|
|
|
assert cos(0.0) == 1.0;
|
|
assert cos(-0.0) == 1.0;
|
|
assert float::isNaN(cos(float::infinity));
|
|
assert float::isNaN(cos(float::neg_infinity));
|
|
|
|
assert tan(0.0) == 0.0;
|
|
assert tan(-0.0) == 0.0;;
|
|
assert float::isNaN(tan(float::infinity));
|
|
assert float::isNaN(tan(float::neg_infinity));
|
|
}
|
|
|
|
#[test]
|
|
fn test_inv_trig() {
|
|
assert asin(0.0) == 0.0;
|
|
assert asin(-0.0) == -0.0;
|
|
assert float::isNaN(asin(1.1));
|
|
assert float::isNaN(asin(-1.1));
|
|
|
|
assert acos(1.0) == 0.0;
|
|
assert float::isNaN(acos(1.1));
|
|
assert float::isNaN(acos(-1.1));
|
|
|
|
assert atan(0.0) == 0.0;
|
|
assert atan(-0.0) == 0.0;
|
|
assert atan(float::infinity) == consts::frac_pi_2;
|
|
assert atan(float::neg_infinity) == - consts::frac_pi_2;
|
|
|
|
assert atan2(0.0, -0.0) == consts::pi;
|
|
assert atan2(-0.0, -0.0) == -consts::pi;
|
|
|
|
assert atan2(0.0, 0.0) == 0.0;
|
|
assert atan2(-0.0, 0.0) == -0.0;
|
|
|
|
assert atan2(0.0, -1.0) == consts::pi;
|
|
assert atan2(-0.0, -1.0) == -consts::pi;
|
|
|
|
assert atan2(0.0, 1.0) == 0.0;
|
|
assert atan2(-0.0, 1.0) == -0.0;
|
|
|
|
assert atan2(1.0, 0.0) == consts::frac_pi_2;
|
|
assert atan2(1.0, -0.0) == consts::frac_pi_2;
|
|
}
|
|
|
|
// FIXME (1222): The commented-out tests give different results on windows
|
|
#[test]
|
|
fn test_pow() {
|
|
assert pow(2.0, 4.0) == 16.0;
|
|
|
|
assert pow(0.0, -3.0) == float::infinity;
|
|
assert pow(-0.0, -3.0) == float::neg_infinity;
|
|
|
|
assert pow(0.0, -4.0) == float::infinity;
|
|
assert pow(-0.0, -4.0) == float::infinity;
|
|
|
|
assert pow(0.0, 3.0) == 0.0;
|
|
assert pow(-0.0, 3.0) == -0.0;
|
|
assert pow(0.0, 4.0) == 0.0;
|
|
assert pow(-0.0, 4.0) == 0.0;
|
|
|
|
assert pow(-1.0, float::infinity) == 1.0;
|
|
//assert pow(-1.0, float::neg_infinity) == 1.0;
|
|
|
|
assert pow(1.0, 4.0) == 1.0;
|
|
assert pow(1.0, 0.0) == 1.0;
|
|
assert pow(1.0, -0.0) == 1.0;
|
|
//assert pow(1.0, float::NaN) == 1.0;
|
|
assert pow(1.0, float::infinity) == 1.0;
|
|
//assert pow(1.0, float::neg_infinity) == 1.0;
|
|
assert pow(1.0, -3.0) == 1.0;
|
|
assert pow(1.0, -4.0) == 1.0;
|
|
|
|
assert pow(4.0, 0.0) == 1.0;
|
|
assert pow(0.0, 0.0) == 1.0;
|
|
assert pow(-0.0, 0.0) == 1.0;
|
|
//assert pow(float::NaN, 0.0) == 1.0;
|
|
assert pow(float::infinity, 0.0) == 1.0;
|
|
assert pow(float::neg_infinity, 0.0) == 1.0;
|
|
assert pow(-3.0, 0.0) == 1.0;
|
|
assert pow(-4.0, 0.0) == 1.0;
|
|
|
|
assert pow(4.0, -0.0) == 1.0;
|
|
assert pow(0.0, -0.0) == 1.0;
|
|
assert pow(-0.0, -0.0) == 1.0;
|
|
//assert pow(float::NaN, -0.0) == 1.0;
|
|
assert pow(float::infinity, -0.0) == 1.0;
|
|
assert pow(float::neg_infinity, -0.0) == 1.0;
|
|
assert pow(-3.0, -0.0) == 1.0;
|
|
assert pow(-4.0, -0.0) == 1.0;
|
|
|
|
assert float::isNaN(pow(-1.0, -1.5));
|
|
assert float::isNaN(pow(-1.0, 1.5));
|
|
|
|
assert float::isNaN(pow(-1.2, -1.5));
|
|
assert float::isNaN(pow(-1.2, 1.5));
|
|
|
|
assert pow(0.5, float::neg_infinity) == float::infinity;
|
|
assert pow(-0.5, float::neg_infinity) == float::infinity;
|
|
|
|
assert pow(1.5, float::neg_infinity) == 0.0;
|
|
assert pow(-1.5, float::neg_infinity) == 0.0;
|
|
|
|
assert pow(0.5, float::infinity) == 0.0;
|
|
assert pow(-0.5, float::infinity) == 0.0;
|
|
|
|
assert pow(-1.5, float::infinity) == float::infinity;
|
|
assert pow(1.5, float::infinity) == float::infinity;
|
|
|
|
assert pow(float::neg_infinity, -3.0) == -0.0;
|
|
assert pow(float::neg_infinity, -4.0) == 0.0;
|
|
|
|
assert pow(float::neg_infinity, 3.0) == float::neg_infinity;
|
|
assert pow(float::neg_infinity, 4.0) == float::infinity;
|
|
|
|
assert pow(float::infinity, -16.0) == 0.0;
|
|
assert pow(float::infinity, 16.0) == float::infinity;
|
|
}
|
|
|
|
// FIXME (1222): The commented-out tests give different results on windows
|
|
#[test]
|
|
fn test_exp_and_mod() {
|
|
assert exp(0.0) == 1.0;
|
|
assert exp(-0.0) == 1.0;
|
|
assert exp(float::neg_infinity) == 0.0;
|
|
assert exp(float::infinity) == float::infinity;
|
|
|
|
let d1: c_int = 1 as c_int;
|
|
assert frexp(0.0, d1) == 0.0;
|
|
assert frexp(-0.0, d1) == 0.0;
|
|
//assert frexp(float::infinity, d1) == float::infinity;
|
|
//assert frexp(float::neg_infinity, d1) == float::neg_infinity;
|
|
assert float::isNaN(frexp(float::NaN, d1));
|
|
|
|
let d2: float = 1.0;
|
|
assert modf(float::infinity, d2) == 0.0;
|
|
assert d2 == float::infinity;
|
|
assert modf(float::neg_infinity, d2) == -0.0;
|
|
assert d2 == float::neg_infinity;
|
|
assert float::isNaN(modf(float::NaN, d2));
|
|
assert float::isNaN(d2);
|
|
}
|
|
|
|
#[test]
|
|
fn test_round_and_abs() {
|
|
assert abs(0.0) == 0.0;
|
|
assert abs(-0.0) == 0.0;
|
|
assert abs(float::infinity) == float::infinity;
|
|
assert abs(float::neg_infinity) == float::infinity;
|
|
|
|
assert abs(-2.5) == 2.5;
|
|
assert abs(2.5) == 2.5;
|
|
|
|
assert ceil(0.0) == 0.0;
|
|
assert ceil(-0.0) == -0.0;
|
|
assert ceil(float::infinity) == float::infinity;
|
|
assert ceil(float::neg_infinity) == float::neg_infinity;
|
|
|
|
assert ceil(1.9) == 2.0;
|
|
assert ceil(-1.9) == -1.0;
|
|
|
|
assert floor(0.0) == 0.0;
|
|
assert floor(-0.0) == -0.0;
|
|
assert floor(float::infinity) == float::infinity;
|
|
assert floor(float::neg_infinity) == float::neg_infinity;
|
|
|
|
assert floor(1.9) == 1.0;
|
|
assert floor(-1.9) == -2.0;
|
|
|
|
assert trunc(0.0) == 0.0;
|
|
assert trunc(-0.0) == -0.0;
|
|
assert trunc(float::infinity) == float::infinity;
|
|
assert trunc(float::neg_infinity) == float::neg_infinity;
|
|
|
|
assert trunc(1.5) == 1.0;
|
|
assert trunc(1.2) == 1.0;
|
|
assert trunc(1.0) == 1.0;
|
|
assert trunc(1.9) == 1.0;
|
|
assert trunc(-1.5) == -1.0;
|
|
assert trunc(-1.2) == -1.0;
|
|
assert trunc(-1.0) == -1.0;
|
|
assert trunc(-1.9) == -1.0;
|
|
|
|
assert round(0.0) == 0.0;
|
|
assert round(-0.0) == -0.0;
|
|
assert round(float::infinity) == float::infinity;
|
|
assert round(float::neg_infinity) == float::neg_infinity;
|
|
|
|
assert rint(0.0) == 0.0;
|
|
assert rint(-0.0) == -0.0;
|
|
assert rint(float::infinity) == float::infinity;
|
|
assert rint(float::neg_infinity) == float::neg_infinity;
|
|
}
|
|
|
|
#[test]
|
|
fn test_hyp_trig() {
|
|
assert sinh(0.0) == 0.0;
|
|
assert sinh(-0.0) == 0.0;
|
|
assert sinh(float::infinity) == float::infinity;
|
|
assert sinh(float::neg_infinity) == float::neg_infinity;
|
|
|
|
assert cosh(0.0) == 1.0;
|
|
assert cosh(-0.0) == 1.0;
|
|
assert cosh(float::infinity) == float::infinity;
|
|
assert cosh(float::neg_infinity) == float::infinity;
|
|
|
|
assert tanh(0.0) == 0.0;
|
|
assert tanh(-0.0) == 0.0;
|
|
assert tanh(float::infinity) == 1.0;
|
|
assert tanh(float::neg_infinity) == -1.0;
|
|
}
|
|
|
|
#[test]
|
|
fn test_sqrt() {
|
|
assert sqrt(9.0) == 3.0;
|
|
assert sqrt(4.0) == 2.0;
|
|
assert sqrt(1.0) == 1.0;
|
|
assert sqrt(0.0) == 0.0;
|
|
}
|
|
|
|
|
|
#[test]
|
|
fn test_angle() {
|
|
fn angle(vec: (float, float)) -> float {
|
|
alt vec {
|
|
(0f, y) if y < 0f { 1.5 * consts::pi }
|
|
(0f, y) { 0.5 * consts::pi }
|
|
(x, y) { float::atan(y / x) }
|
|
}
|
|
}
|
|
assert angle((1f, 0f)) == 0f;
|
|
assert angle((1f, 1f)) == 0.25 * consts::pi;
|
|
assert angle((0f, 1f)) == 0.5 * consts::pi;
|
|
}
|
|
|
|
|
|
#[test]
|
|
fn test_log_functions() {
|
|
assert ln(1.0) == 0.0;
|
|
assert log2(1.0) == 0.0;
|
|
assert log10(1.0) == 0.0;
|
|
|
|
// FIXME remove round-up due to valgrind weirdness
|
|
assert ceil(ln(consts::e)) == 1.0; /* ln(e) == 0.999.. under valgrind */
|
|
assert log2(2.0) == 1.0;
|
|
assert log10(10.0) == 1.0;
|
|
|
|
// FIXME remove round-up due to valgrind weirdness
|
|
assert ceil(ln(consts::e*consts::e*consts::e*consts::e)) == 4.0;
|
|
assert log2(256.0) == 8.0;
|
|
assert log10(1000.0) == 3.0;
|
|
|
|
assert ln(0.0) == float::neg_infinity;
|
|
assert log2(0.0) == float::neg_infinity;
|
|
assert log10(0.0) == float::neg_infinity;
|
|
|
|
assert ln(-0.0) == float::neg_infinity;
|
|
assert log2(-0.0) == float::neg_infinity;
|
|
assert log10(-0.0) == float::neg_infinity;
|
|
|
|
assert float::isNaN(ln(-1.0));
|
|
assert float::isNaN(log2(-1.0));
|
|
assert float::isNaN(log10(-1.0));
|
|
|
|
assert ln(float::infinity) == float::infinity;
|
|
assert log2(float::infinity) == float::infinity;
|
|
assert log10(float::infinity) == float::infinity;
|
|
|
|
assert ln1p(0.0) == 0.0;
|
|
assert ln1p(-0.0) == 0.0;
|
|
assert ln1p(-1.0) == float::neg_infinity;
|
|
assert float::isNaN(ln1p(-2.0f));
|
|
assert ln1p(float::infinity) == float::infinity;
|
|
}
|
|
|
|
*/
|