mirror of
https://github.com/bkaradzic/bx.git
synced 2026-10-22 16:51:01 +00:00
Added a constexpr double math surface, and made fromString exact. (#451)
This commit is contained in:
Branimir Karadžić
committed by
GitHub
GitHub
parent
59a1e105b6
commit
89eb1775db
@@ -735,9 +735,9 @@ TEST_CASE("pow", "[math][libm]")
|
||||
STATIC_REQUIRE(0.0f == bx::pow(0.0f, 2.0f) );
|
||||
|
||||
STATIC_REQUIRE( 4.0f == bx::pow( 2.0f, 2.0f) );
|
||||
STATIC_REQUIRE( -4.0f == bx::pow(-2.0f, 2.0f) );
|
||||
STATIC_REQUIRE( 4.0f == bx::pow(-2.0f, 2.0f) );
|
||||
STATIC_REQUIRE( 0.25f == bx::pow( 2.0f, -2.0f) );
|
||||
STATIC_REQUIRE( -0.25f == bx::pow(-2.0f, -2.0f) );
|
||||
STATIC_REQUIRE( 0.25f == bx::pow(-2.0f, -2.0f) );
|
||||
STATIC_REQUIRE( 8.0f == bx::pow( 2.0f, 3.0f) );
|
||||
STATIC_REQUIRE( -8.0f == bx::pow(-2.0f, 3.0f) );
|
||||
STATIC_REQUIRE( 0.125f == bx::pow( 2.0f, -3.0f) );
|
||||
@@ -968,6 +968,622 @@ TEST_CASE("copySign", "[math][libm]")
|
||||
STATIC_REQUIRE(-bx::kFloatInfinity == bx::copySign(bx::kFloatInfinity, -1389) );
|
||||
}
|
||||
|
||||
typedef double (*MathDoubleFn)(double);
|
||||
|
||||
template<MathDoubleFn BxT, MathDoubleFn CrtT>
|
||||
static void testMathFunc1Double(double _value)
|
||||
{
|
||||
REQUIRE(CrtT(_value) == BxT(_value) );
|
||||
}
|
||||
|
||||
TEST_CASE("floor, ceil, trunc, round double", "[math][libm]")
|
||||
{
|
||||
STATIC_REQUIRE( 13.0 == bx::floor( 13.89) );
|
||||
STATIC_REQUIRE(-14.0 == bx::floor(-13.89) );
|
||||
STATIC_REQUIRE( 14.0 == bx::ceil( 13.89) );
|
||||
STATIC_REQUIRE(-13.0 == bx::ceil( -13.89) );
|
||||
STATIC_REQUIRE( 13.0 == bx::trunc( 13.89) );
|
||||
STATIC_REQUIRE(-13.0 == bx::trunc(-13.89) );
|
||||
|
||||
STATIC_REQUIRE( 2.0 == bx::round( 2.5) );
|
||||
STATIC_REQUIRE( 4.0 == bx::round( 3.5) );
|
||||
STATIC_REQUIRE( -2.0 == bx::round( -2.5) );
|
||||
STATIC_REQUIRE( 0.0 == bx::round( 0.49999999999999994) );
|
||||
|
||||
STATIC_REQUIRE( 1.0e300 == bx::trunc( 1.0e300) );
|
||||
STATIC_REQUIRE(-1.0e300 == bx::floor(-1.0e300) );
|
||||
STATIC_REQUIRE( 0x1p52 == bx::round(0x1p52) );
|
||||
|
||||
STATIC_REQUIRE(bx::kDoubleSignMask == bx::bitCast<uint64_t>(bx::trunc(-0.5) ) );
|
||||
STATIC_REQUIRE(bx::kDoubleSignMask == bx::bitCast<uint64_t>(bx::ceil( -0.5) ) );
|
||||
STATIC_REQUIRE(bx::kDoubleSignMask == bx::bitCast<uint64_t>(bx::round(-0.4) ) );
|
||||
STATIC_REQUIRE(bx::kDoubleExponentMask == bx::bitCast<uint64_t>(bx::floor(bx::kDoubleInfinity) ) );
|
||||
|
||||
testMathFunc1Double<bx::floor, ::floor>( 13.89);
|
||||
testMathFunc1Double<bx::floor, ::floor>(-13.89);
|
||||
testMathFunc1Double<bx::ceil, ::ceil >( 13.89);
|
||||
testMathFunc1Double<bx::ceil, ::ceil >(-13.89);
|
||||
testMathFunc1Double<bx::trunc, ::trunc>( 13.89);
|
||||
testMathFunc1Double<bx::trunc, ::trunc>(-13.89);
|
||||
|
||||
bx::RngMwc rng;
|
||||
|
||||
for (uint32_t ii = 0; ii < 100000; ++ii)
|
||||
{
|
||||
const uint64_t hi = uint64_t(rng.gen() );
|
||||
const uint64_t lo = uint64_t(rng.gen() );
|
||||
const uint64_t bits = (hi<<32) | lo;
|
||||
const double vv = bx::bitsToDouble(bits);
|
||||
|
||||
if (bx::isNan(vv) )
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
REQUIRE(::floor(vv) == bx::floor(vv) );
|
||||
REQUIRE(::ceil(vv) == bx::ceil(vv) );
|
||||
REQUIRE(::trunc(vv) == bx::trunc(vv) );
|
||||
REQUIRE(::nearbyint(vv) == bx::round(vv) );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("abs, sign, copySign double", "[math][libm]")
|
||||
{
|
||||
STATIC_REQUIRE(13.89 == bx::abs(-13.89) );
|
||||
STATIC_REQUIRE(13.89 == bx::abs( 13.89) );
|
||||
STATIC_REQUIRE(0.0 == bx::abs(-0.0) );
|
||||
STATIC_REQUIRE(!bx::signBit(bx::abs(-0.0) ) );
|
||||
|
||||
STATIC_REQUIRE(-1 == bx::sign(-0.1389) );
|
||||
STATIC_REQUIRE( 0 == bx::sign( 0.0000) );
|
||||
STATIC_REQUIRE( 1 == bx::sign( 0.1389) );
|
||||
|
||||
STATIC_REQUIRE( bx::signBit(-0.0) );
|
||||
STATIC_REQUIRE(!bx::signBit( 0.0) );
|
||||
STATIC_REQUIRE( bx::signBit(-bx::kDoubleInfinity) );
|
||||
|
||||
STATIC_REQUIRE(-13.89 == bx::copySign(13.89, -1.0) );
|
||||
STATIC_REQUIRE( 13.89 == bx::copySign(13.89, 1.0) );
|
||||
STATIC_REQUIRE(bx::signBit(bx::copySign(0.0, -1.0) ) );
|
||||
}
|
||||
|
||||
TEST_CASE("ldexp double", "[math][libm]")
|
||||
{
|
||||
STATIC_REQUIRE(48.0 == bx::ldexp(3.0, 4) );
|
||||
STATIC_REQUIRE(0.4375 == bx::ldexp(7.0, -4) );
|
||||
STATIC_REQUIRE(0x1p1023 == bx::ldexp(1.0, 1023) );
|
||||
STATIC_REQUIRE(0x1p-1022 == bx::ldexp(1.0, -1022) );
|
||||
|
||||
STATIC_REQUIRE(0x1p-1074 == bx::ldexp(1.0, -1074) );
|
||||
STATIC_REQUIRE(0.0 == bx::ldexp(1.0, -1200) );
|
||||
STATIC_REQUIRE(1.0 == bx::ldexp(0x1p-1074, 1074) );
|
||||
REQUIRE(bx::kDoubleInfinity == bx::ldexp(1.0, 1200) );
|
||||
STATIC_REQUIRE(bx::signBit(bx::ldexp(-0.0, 10) ) );
|
||||
|
||||
for (int32_t yy = -1100; yy < 1100; ++yy)
|
||||
{
|
||||
for (double xx = -100.0; xx < 100.0; xx += 7.3)
|
||||
{
|
||||
REQUIRE(::ldexp(xx, yy) == bx::ldexp(xx, yy) );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("frexp", "[math][libm]")
|
||||
{
|
||||
constexpr auto frexpConst = []()
|
||||
{
|
||||
int32_t exp = 0;
|
||||
const double frac = bx::frexp(12.0, &exp);
|
||||
|
||||
return 0.75 == frac && 4 == exp;
|
||||
}();
|
||||
STATIC_REQUIRE(frexpConst);
|
||||
|
||||
bx::RngMwc rng;
|
||||
|
||||
for (uint32_t ii = 0; ii < 100000; ++ii)
|
||||
{
|
||||
const uint64_t hi = uint64_t(rng.gen() );
|
||||
const uint64_t lo = uint64_t(rng.gen() );
|
||||
const uint64_t bits = (hi<<32) | lo;
|
||||
const double vv = bx::bitsToDouble(bits);
|
||||
|
||||
if (bx::isNan(vv) )
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
int32_t mine = 0;
|
||||
int theirs = 0;
|
||||
const double fa = bx::frexp(vv, &mine);
|
||||
const double fb = ::frexp(vv, &theirs);
|
||||
|
||||
REQUIRE(fa == fb);
|
||||
REQUIRE(mine == theirs);
|
||||
}
|
||||
|
||||
for (uint32_t ii = 0; ii < 100000; ++ii)
|
||||
{
|
||||
const float vv = bx::bitsToFloat(rng.gen() );
|
||||
|
||||
if (bx::isNan(vv) )
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
int32_t mine = 0;
|
||||
int theirs = 0;
|
||||
const float fa = bx::frexp(vv, &mine);
|
||||
const float fb = ::frexpf(vv, &theirs);
|
||||
|
||||
REQUIRE(fa == fb);
|
||||
REQUIRE(mine == theirs);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("modf, fmod, mod double", "[math][libm]")
|
||||
{
|
||||
constexpr auto modfConst = []()
|
||||
{
|
||||
double integral = 0.0;
|
||||
const double frac = bx::modf(-2.5, &integral);
|
||||
|
||||
return -2.0 == integral && -0.5 == frac;
|
||||
}();
|
||||
STATIC_REQUIRE(modfConst);
|
||||
|
||||
STATIC_REQUIRE(-1.0 == bx::fmod(-7.0, 3.0) );
|
||||
STATIC_REQUIRE( 2.0 == bx::mod( -7.0, 3.0) );
|
||||
STATIC_REQUIRE( 1.0 == bx::fmod( 7.0, -3.0) );
|
||||
STATIC_REQUIRE( 1.0 == bx::fmod( 7.0, 3.0) );
|
||||
STATIC_REQUIRE( 1.0 == bx::mod( 7.0, 3.0) );
|
||||
|
||||
STATIC_REQUIRE(-1.0f == bx::fmod(-7.0f, 3.0f) );
|
||||
STATIC_REQUIRE( 2.0f == bx::mod( -7.0f, 3.0f) );
|
||||
}
|
||||
|
||||
TEST_CASE("sqrt, log, exp double", "[math][libm]")
|
||||
{
|
||||
STATIC_REQUIRE(4.0 == bx::sqrt(16.0) );
|
||||
STATIC_REQUIRE(0.0 == bx::sqrt(0.0) );
|
||||
STATIC_REQUIRE(bx::signBit(bx::sqrt(-0.0) ) );
|
||||
STATIC_REQUIRE(bx::isNan(bx::sqrt(-1.0) ) );
|
||||
STATIC_REQUIRE(bx::isEqual(1.4142135623730951, bx::sqrt(2.0), 1.0e-15) );
|
||||
|
||||
STATIC_REQUIRE(bx::isEqual(0.0, bx::log(1.0), 1.0e-15) );
|
||||
STATIC_REQUIRE(bx::isEqual(1.0, bx::log(2.71828182845904524), 1.0e-15) );
|
||||
STATIC_REQUIRE(bx::isEqual(0.69314718055994531, bx::log(2.0), 1.0e-15) );
|
||||
STATIC_REQUIRE(-bx::kDoubleInfinity == bx::log(0.0) );
|
||||
STATIC_REQUIRE(bx::isNan(bx::log(-1.0) ) );
|
||||
|
||||
STATIC_REQUIRE( 8.0 == bx::log2(256.0) );
|
||||
STATIC_REQUIRE(10.0 == bx::log2(1024.0) );
|
||||
|
||||
STATIC_REQUIRE(bx::isEqual(1.0, bx::exp(0.0), 1.0e-15) );
|
||||
STATIC_REQUIRE(bx::isEqual(2.71828182845904524, bx::exp(1.0), 1.0e-15) );
|
||||
STATIC_REQUIRE(0.0 == bx::exp(-800.0) );
|
||||
STATIC_REQUIRE(bx::kDoubleInfinity == bx::exp(800.0) );
|
||||
|
||||
STATIC_REQUIRE(1024.0 == bx::exp2(10.0) );
|
||||
|
||||
STATIC_REQUIRE( 81.0 == bx::pow( 3.0, 4.0) );
|
||||
STATIC_REQUIRE( -8.0 == bx::pow(-2.0, 3.0) );
|
||||
STATIC_REQUIRE( 4.0 == bx::pow(-2.0, 2.0) );
|
||||
STATIC_REQUIRE(0.0625 == bx::pow( 2.0, -4.0) );
|
||||
STATIC_REQUIRE( 1.0 == bx::pow( 7.0, 0.0) );
|
||||
STATIC_REQUIRE(bx::isNan(bx::pow(-2.0, 0.5) ) );
|
||||
STATIC_REQUIRE(bx::isEqual(1.4142135623730951, bx::pow(2.0, 0.5), 1.0e-15) );
|
||||
|
||||
for (double xx = 0.125; xx < 1.0e12; xx *= 1.7)
|
||||
{
|
||||
REQUIRE(bx::isEqual(::sqrt(xx), bx::sqrt(xx), 1.0e-15*xx) );
|
||||
REQUIRE(bx::isEqual(::log(xx), bx::log(xx), 1.0e-14) );
|
||||
}
|
||||
|
||||
for (double xx = -700.0; xx < 700.0; xx += 3.1)
|
||||
{
|
||||
const double ref = ::exp(xx);
|
||||
|
||||
REQUIRE(bx::isEqual(ref, bx::exp(xx), 1.0e-14*ref) );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("sin, cos, tan double", "[math][libm]")
|
||||
{
|
||||
STATIC_REQUIRE(0.0 == bx::sin(0.0) );
|
||||
STATIC_REQUIRE(1.0 == bx::cos(0.0) );
|
||||
STATIC_REQUIRE(0.0 == bx::tan(0.0) );
|
||||
|
||||
for (double xx = -100.0; xx < 100.0; xx += 0.37)
|
||||
{
|
||||
REQUIRE(bx::isEqual(::sin(xx), bx::sin(xx), 1.0e-14) );
|
||||
REQUIRE(bx::isEqual(::cos(xx), bx::cos(xx), 1.0e-14) );
|
||||
}
|
||||
|
||||
REQUIRE(bx::isEqual(::sin(1.0e6), bx::sin(1.0e6), 1.0e-12) );
|
||||
REQUIRE(bx::isEqual(::cos(1.0e6), bx::cos(1.0e6), 1.0e-12) );
|
||||
}
|
||||
|
||||
TEST_CASE("asin, acos, atan double", "[math][libm]")
|
||||
{
|
||||
STATIC_REQUIRE(0.0 == bx::asin(0.0) );
|
||||
STATIC_REQUIRE(0.0 == bx::atan(0.0) );
|
||||
STATIC_REQUIRE(0.0 == bx::acos(1.0) );
|
||||
STATIC_REQUIRE(bx::isNan(bx::asin(1.5) ) );
|
||||
STATIC_REQUIRE(bx::isNan(bx::acos(1.5) ) );
|
||||
|
||||
STATIC_REQUIRE(bx::isEqual(1.57079632679489662, bx::asin(1.0), 1.0e-15) );
|
||||
STATIC_REQUIRE(bx::isEqual(3.14159265358979324, bx::acos(-1.0), 1.0e-15) );
|
||||
STATIC_REQUIRE(bx::isEqual(0.78539816339744831, bx::atan(1.0), 1.0e-15) );
|
||||
STATIC_REQUIRE(bx::isEqual(0.78539816339744831, bx::atan2(1.0,1.0), 1.0e-15) );
|
||||
|
||||
for (double xx = -1.0; xx < 1.0; xx += 0.013)
|
||||
{
|
||||
REQUIRE(bx::isEqual(::asin(xx), bx::asin(xx), 1.0e-14) );
|
||||
REQUIRE(bx::isEqual(::acos(xx), bx::acos(xx), 1.0e-14) );
|
||||
}
|
||||
|
||||
for (double xx = -1000.0; xx < 1000.0; xx += 7.3)
|
||||
{
|
||||
REQUIRE(bx::isEqual(::atan(xx), bx::atan(xx), 1.0e-14) );
|
||||
}
|
||||
|
||||
for (double yy = -10.0; yy < 10.0; yy += 1.3)
|
||||
{
|
||||
for (double xx = -10.0; xx < 10.0; xx += 1.3)
|
||||
{
|
||||
REQUIRE(bx::isEqual(::atan2(yy, xx), bx::atan2(yy, xx), 1.0e-14) );
|
||||
}
|
||||
}
|
||||
|
||||
REQUIRE(::atan2( 0.0, 1.0) == bx::atan2( 0.0, 1.0) );
|
||||
REQUIRE(::atan2(-0.0, 1.0) == bx::atan2(-0.0, 1.0) );
|
||||
REQUIRE(::atan2( 0.0, -1.0) == bx::atan2( 0.0, -1.0) );
|
||||
REQUIRE(::atan2(-0.0, -1.0) == bx::atan2(-0.0, -1.0) );
|
||||
REQUIRE(::atan2( 1.0, 0.0) == bx::atan2( 1.0, 0.0) );
|
||||
REQUIRE(::atan2(-1.0, 0.0) == bx::atan2(-1.0, 0.0) );
|
||||
}
|
||||
|
||||
TEST_CASE("sinh, cosh, tanh double", "[math][libm]")
|
||||
{
|
||||
STATIC_REQUIRE(0.0 == bx::sinh(0.0) );
|
||||
STATIC_REQUIRE(1.0 == bx::cosh(0.0) );
|
||||
STATIC_REQUIRE(0.0 == bx::tanh(0.0) );
|
||||
|
||||
for (double xx = -20.0; xx < 20.0; xx += 0.17)
|
||||
{
|
||||
const double sh = ::sinh(xx);
|
||||
const double ch = ::cosh(xx);
|
||||
|
||||
REQUIRE(bx::isEqual(sh, bx::sinh(xx), 1.0e-13*bx::abs(sh) ) );
|
||||
REQUIRE(bx::isEqual(ch, bx::cosh(xx), 1.0e-13*ch) );
|
||||
REQUIRE(bx::isEqual(::tanh(xx), bx::tanh(xx), 1.0e-14) );
|
||||
}
|
||||
|
||||
for (double xx = 1.0e-9; xx < 0.1; xx *= 1.3)
|
||||
{
|
||||
REQUIRE(bx::isEqual(::sinh(xx), bx::sinh(xx), 1.0e-13*xx) );
|
||||
REQUIRE(bx::isEqual(::tanh(xx), bx::tanh(xx), 1.0e-13*xx) );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("log1p, asinh, acosh, atanh", "[math][libm]")
|
||||
{
|
||||
STATIC_REQUIRE(0.0 == bx::log1p(0.0) );
|
||||
STATIC_REQUIRE(0.0 == bx::asinh(0.0) );
|
||||
STATIC_REQUIRE(0.0 == bx::acosh(1.0) );
|
||||
STATIC_REQUIRE(0.0 == bx::atanh(0.0) );
|
||||
STATIC_REQUIRE(-bx::kDoubleInfinity == bx::log1p(-1.0) );
|
||||
STATIC_REQUIRE(bx::kDoubleInfinity == bx::atanh(1.0) );
|
||||
STATIC_REQUIRE(bx::isNan(bx::acosh(0.5) ) );
|
||||
STATIC_REQUIRE(bx::isNan(bx::atanh(1.5) ) );
|
||||
|
||||
STATIC_REQUIRE(bx::isEqual(0.88137358701954303, bx::asinh(1.0), 1.0e-15) );
|
||||
STATIC_REQUIRE(bx::isEqual(1.31695789692481670, bx::acosh(2.0), 1.0e-15) );
|
||||
STATIC_REQUIRE(bx::isEqual(0.54930614433405489, bx::atanh(0.5), 1.0e-15) );
|
||||
|
||||
for (double xx = 1.0e-9; xx < 1.0e9; xx *= 1.7)
|
||||
{
|
||||
REQUIRE(bx::isEqual(::log1p(xx), bx::log1p(xx), 1.0e-14*bx::abs(::log1p(xx) ) ) );
|
||||
REQUIRE(bx::isEqual(::asinh(xx), bx::asinh(xx), 1.0e-14*::asinh(xx) ) );
|
||||
REQUIRE(bx::isEqual(::asinh(-xx), bx::asinh(-xx), 1.0e-14*::asinh(xx) ) );
|
||||
}
|
||||
|
||||
for (double xx = 0.0; xx < 1.0; xx += 0.0131)
|
||||
{
|
||||
REQUIRE(bx::isEqual(::atanh(xx), bx::atanh(xx), 1.0e-14) );
|
||||
}
|
||||
|
||||
for (double tt = 0x1p-40; tt < 0x1p-18; tt *= 2.0)
|
||||
{
|
||||
const double xx = 1.0 + tt;
|
||||
const double poly = 1.0 - tt/12.0 + 3.0*tt*tt/160.0;
|
||||
const double ref = bx::sqrt(2.0*tt) * poly;
|
||||
|
||||
REQUIRE(bx::isEqual(ref, bx::acosh(xx), 1.0e-14*ref) );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("ldexp float range", "[math][libm]")
|
||||
{
|
||||
STATIC_REQUIRE(0x1p127f == bx::ldexp(1.0f, 127) );
|
||||
STATIC_REQUIRE(0x1p-126f == bx::ldexp(1.0f, -126) );
|
||||
STATIC_REQUIRE(0x1p-149f == bx::ldexp(1.0f, -149) );
|
||||
STATIC_REQUIRE(0.0f == bx::ldexp(1.0f, -150) );
|
||||
STATIC_REQUIRE(0.0f == bx::ldexp(1.0f, -400) );
|
||||
STATIC_REQUIRE(1.0f == bx::ldexp(0x1p-149f, 149) );
|
||||
STATIC_REQUIRE(bx::signBit(bx::ldexp(-0.0f, 10) ) );
|
||||
|
||||
REQUIRE(bx::isInfinite(bx::ldexp(1.0f, 128) ) );
|
||||
REQUIRE(bx::isInfinite(bx::ldexp(1.0f, 400) ) );
|
||||
|
||||
for (int32_t yy = -300; yy < 300; ++yy)
|
||||
{
|
||||
for (float xx = -100.0f; xx < 100.0f; xx += 3.7f)
|
||||
{
|
||||
REQUIRE(::ldexpf(xx, yy) == bx::ldexp(xx, yy) );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("exp float overflow", "[math][libm]")
|
||||
{
|
||||
REQUIRE(bx::isInfinite(bx::exp( 89.0f) ) );
|
||||
REQUIRE(bx::isInfinite(bx::exp(100.0f) ) );
|
||||
REQUIRE(bx::isInfinite(bx::exp(500.0f) ) );
|
||||
REQUIRE(0.0f == bx::exp(-500.0f) );
|
||||
|
||||
REQUIRE(bx::isInfinite(bx::exp( 800.0) ) );
|
||||
REQUIRE(0.0 == bx::exp(-800.0) );
|
||||
}
|
||||
|
||||
TEST_CASE("sinh, cosh, tanh saturation", "[math][libm]")
|
||||
{
|
||||
REQUIRE( 1.0f == bx::tanh( 90.0f) );
|
||||
REQUIRE(-1.0f == bx::tanh(-90.0f) );
|
||||
REQUIRE( 1.0 == bx::tanh( 9876.0) );
|
||||
REQUIRE(-1.0 == bx::tanh(-9876.0) );
|
||||
|
||||
REQUIRE(bx::isFinite(bx::cosh(88.5f) ) );
|
||||
REQUIRE(bx::isFinite(bx::sinh(88.5f) ) );
|
||||
REQUIRE(bx::isFinite(bx::cosh(710.0) ) );
|
||||
REQUIRE(bx::isFinite(bx::sinh(710.0) ) );
|
||||
REQUIRE(bx::isInfinite(bx::cosh(720.0) ) );
|
||||
|
||||
for (float xx = 1.0e-7f; xx < 1.0f; xx *= 1.3f)
|
||||
{
|
||||
const float ref = float(bx::tanh(double(xx) ) );
|
||||
|
||||
REQUIRE(bx::isEqual(ref, bx::tanh(xx), 1.0e-6f*ref) );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("log1p, asinh, acosh, atanh float", "[math][libm]")
|
||||
{
|
||||
STATIC_REQUIRE(0.0f == bx::log1p(0.0f) );
|
||||
STATIC_REQUIRE(0.0f == bx::asinh(0.0f) );
|
||||
STATIC_REQUIRE(0.0f == bx::acosh(1.0f) );
|
||||
STATIC_REQUIRE(0.0f == bx::atanh(0.0f) );
|
||||
STATIC_REQUIRE(-bx::kFloatInfinity == bx::log1p(-1.0f) );
|
||||
STATIC_REQUIRE( bx::kFloatInfinity == bx::atanh(1.0f) );
|
||||
STATIC_REQUIRE(bx::isNan(bx::acosh(0.5f) ) );
|
||||
STATIC_REQUIRE(bx::isNan(bx::atanh(1.5f) ) );
|
||||
|
||||
for (float xx = 1.0e-6f; xx < 1.0e6f; xx *= 1.7f)
|
||||
{
|
||||
const float rl = float(bx::log1p(double(xx) ) );
|
||||
const float ra = float(bx::asinh(double(xx) ) );
|
||||
|
||||
REQUIRE(bx::isEqual(rl, bx::log1p(xx), 1.0e-6f*bx::abs(rl) ) );
|
||||
REQUIRE(bx::isEqual(ra, bx::asinh(xx), 1.0e-6f*ra) );
|
||||
REQUIRE(bx::isEqual(-ra, bx::asinh(-xx), 1.0e-6f*ra) );
|
||||
}
|
||||
|
||||
for (float tt = 1.0e-6f; tt < 100.0f; tt *= 1.7f)
|
||||
{
|
||||
const float xx = 1.0f + tt;
|
||||
const float ref = float(bx::acosh(double(xx) ) );
|
||||
|
||||
REQUIRE(bx::isEqual(ref, bx::acosh(xx), 1.0e-6f*ref) );
|
||||
}
|
||||
|
||||
for (float xx = 0.0f; xx < 1.0f; xx += 0.013f)
|
||||
{
|
||||
const float ref = float(bx::atanh(double(xx) ) );
|
||||
|
||||
REQUIRE(bx::isEqual(ref, bx::atanh(xx), 1.0e-6f) );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("odd and even symmetry", "[math][libm]")
|
||||
{
|
||||
bx::RngMwc rng;
|
||||
|
||||
for (uint32_t ii = 0; ii < 20000; ++ii)
|
||||
{
|
||||
const double uu = double(rng.gen() ) / 4294967296.0;
|
||||
const double xx = bx::pow(10.0, uu*14.0 - 7.0);
|
||||
|
||||
REQUIRE(bx::sin(-xx) == -bx::sin(xx) );
|
||||
REQUIRE(bx::cos(-xx) == bx::cos(xx) );
|
||||
REQUIRE(bx::tan(-xx) == -bx::tan(xx) );
|
||||
REQUIRE(bx::sinh(-xx) == -bx::sinh(xx) );
|
||||
REQUIRE(bx::cosh(-xx) == bx::cosh(xx) );
|
||||
REQUIRE(bx::tanh(-xx) == -bx::tanh(xx) );
|
||||
REQUIRE(bx::atan(-xx) == -bx::atan(xx) );
|
||||
REQUIRE(bx::asinh(-xx) == -bx::asinh(xx) );
|
||||
REQUIRE(bx::atan2(-xx, 3.0) == -bx::atan2(xx, 3.0) );
|
||||
REQUIRE(bx::atan2(-xx,-3.0) == -bx::atan2(xx,-3.0) );
|
||||
|
||||
const double ss = uu*2.0 - 1.0;
|
||||
|
||||
REQUIRE(bx::asin(-ss) == -bx::asin(ss) );
|
||||
REQUIRE(bx::atanh(-ss*0.999) == -bx::atanh(ss*0.999) );
|
||||
}
|
||||
|
||||
STATIC_REQUIRE(bx::signBit(bx::sin(-0.0) ) );
|
||||
STATIC_REQUIRE(bx::signBit(bx::tan(-0.0) ) );
|
||||
STATIC_REQUIRE(bx::signBit(bx::asin(-0.0) ) );
|
||||
STATIC_REQUIRE(bx::signBit(bx::atan(-0.0) ) );
|
||||
STATIC_REQUIRE(bx::signBit(bx::sinh(-0.0) ) );
|
||||
STATIC_REQUIRE(bx::signBit(bx::tanh(-0.0) ) );
|
||||
STATIC_REQUIRE(bx::signBit(bx::asinh(-0.0) ) );
|
||||
STATIC_REQUIRE(bx::signBit(bx::atanh(-0.0) ) );
|
||||
STATIC_REQUIRE(bx::signBit(bx::log1p(-0.0) ) );
|
||||
STATIC_REQUIRE(bx::signBit(bx::log1p(-0.0f) ) );
|
||||
|
||||
for (double xx = 1.0e-9; xx < 0.4375; xx *= 1.3)
|
||||
{
|
||||
REQUIRE(bx::atan(-xx) == -bx::atan(xx) );
|
||||
REQUIRE(bx::isEqual(::atan(-xx), bx::atan(-xx), 1.0e-14) );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("pow negative base", "[math][libm]")
|
||||
{
|
||||
STATIC_REQUIRE( 4.0f == bx::pow(-2.0f, 2.0f) );
|
||||
STATIC_REQUIRE( -8.0f == bx::pow(-2.0f, 3.0f) );
|
||||
STATIC_REQUIRE( 16.0f == bx::pow(-2.0f, 4.0f) );
|
||||
STATIC_REQUIRE(-0.125f == bx::pow(-2.0f, -3.0f) );
|
||||
STATIC_REQUIRE(bx::isNan(bx::pow(-2.0f, 0.5f) ) );
|
||||
STATIC_REQUIRE(bx::isNan(bx::pow(-2.0f, 1.5f) ) );
|
||||
|
||||
STATIC_REQUIRE( 4.0 == bx::pow(-2.0, 2.0) );
|
||||
STATIC_REQUIRE( -8.0 == bx::pow(-2.0, 3.0) );
|
||||
STATIC_REQUIRE(bx::isNan(bx::pow(-2.0, 0.5) ) );
|
||||
|
||||
STATIC_REQUIRE( 81.0f == bx::pow(3.0f, 4.0f) );
|
||||
STATIC_REQUIRE( 1024.0f == bx::pow(2.0f, 10.0f) );
|
||||
STATIC_REQUIRE( 0.0625f == bx::pow(2.0f, -4.0f) );
|
||||
STATIC_REQUIRE( 1024.0f == bx::exp2(10.0f) );
|
||||
STATIC_REQUIRE( 1.0f == bx::pow(7.0f, 0.0f) );
|
||||
STATIC_REQUIRE( 4.0f == bx::sqrt(16.0f) );
|
||||
|
||||
STATIC_REQUIRE(bx::kFloatInfinity == bx::pow(0.0f, -2.0f) );
|
||||
STATIC_REQUIRE(0.0f == bx::pow(0.0f, 2.0f) );
|
||||
}
|
||||
|
||||
TEST_CASE("exp float accuracy", "[math][libm]")
|
||||
{
|
||||
for (float xx = -103.0f; xx < 88.0f; xx += 0.37f)
|
||||
{
|
||||
const float ref = float(bx::exp(double(xx) ) );
|
||||
|
||||
if (ref >= bx::kFloatSmallest)
|
||||
{
|
||||
REQUIRE(bx::isEqual(ref, bx::exp(xx), 1.0e-6f*ref) );
|
||||
}
|
||||
}
|
||||
|
||||
REQUIRE(::expf(-100.0f) == bx::exp(-100.0f) );
|
||||
REQUIRE(::expf(-103.9f) == bx::exp(-103.9f) );
|
||||
REQUIRE(0.0f == bx::exp(-104.1f) );
|
||||
REQUIRE(bx::isFinite(bx::exp(88.7f) ) );
|
||||
REQUIRE(bx::isInfinite(bx::exp(88.8f) ) );
|
||||
}
|
||||
|
||||
TEST_CASE("sinh, cosh near overflow", "[math][libm]")
|
||||
{
|
||||
for (float xx = 88.0f; xx < 89.4f; xx += 0.013f)
|
||||
{
|
||||
const float rs = float(bx::sinh(double(xx) ) );
|
||||
const float rc = float(bx::cosh(double(xx) ) );
|
||||
|
||||
if (bx::isFinite(rs) )
|
||||
{
|
||||
REQUIRE(bx::isEqual(rs, bx::sinh(xx), 1.0e-6f*rs) );
|
||||
REQUIRE(bx::isEqual(rc, bx::cosh(xx), 1.0e-6f*rc) );
|
||||
}
|
||||
}
|
||||
|
||||
REQUIRE(bx::isFinite(bx::sinh(709.5) ) );
|
||||
REQUIRE(bx::isFinite(bx::cosh(709.5) ) );
|
||||
REQUIRE(bx::isInfinite(bx::cosh(711.0) ) );
|
||||
REQUIRE(bx::signBit(bx::sinh(-709.5) ) );
|
||||
}
|
||||
|
||||
TEST_CASE("trig large argument reduction", "[math][libm]")
|
||||
{
|
||||
REQUIRE(bx::isFinite(bx::sin(1.0e308) ) );
|
||||
REQUIRE(bx::isFinite(bx::cos(1.0e308) ) );
|
||||
REQUIRE(bx::isFinite(bx::tan(1.0e308) ) );
|
||||
REQUIRE(bx::isFinite(bx::sin(7.8145278949113378e+202) ) );
|
||||
REQUIRE(bx::isFinite(bx::cos(7.8145278949113378e+202) ) );
|
||||
|
||||
{
|
||||
int32_t quadrant = 0;
|
||||
const double reduced = bx::reducePiHalfLarge(1.0e16, &quadrant);
|
||||
|
||||
REQUIRE(1 == quadrant);
|
||||
REQUIRE(bx::isEqual(0.4307553505349006*1.5707963267948966, reduced, 1.0e-16) );
|
||||
}
|
||||
|
||||
{
|
||||
int32_t quadrant = 0;
|
||||
const double reduced = bx::reducePiHalfLarge(1.0e22, &quadrant);
|
||||
|
||||
REQUIRE(3 == quadrant);
|
||||
REQUIRE(bx::isEqual(0.35053490057448137839*1.5707963267948966, reduced, 1.0e-16) );
|
||||
}
|
||||
|
||||
for (double xx = 1.0e3; xx < 1.6e6; xx *= 1.3)
|
||||
{
|
||||
int32_t quadrant = 0;
|
||||
|
||||
const double large = bx::reducePiHalfLarge(xx, &quadrant);
|
||||
const double small = bx::sin(xx);
|
||||
|
||||
switch (quadrant)
|
||||
{
|
||||
case 0: REQUIRE(bx::isEqual(small, bx::sinPiQuarter(large), 1.0e-15) ); break;
|
||||
case 1: REQUIRE(bx::isEqual(small, bx::cosPiQuarter(large), 1.0e-15) ); break;
|
||||
case 2: REQUIRE(bx::isEqual(small, -bx::sinPiQuarter(large), 1.0e-15) ); break;
|
||||
default: REQUIRE(bx::isEqual(small, -bx::cosPiQuarter(large), 1.0e-15) ); break;
|
||||
}
|
||||
}
|
||||
|
||||
for (int32_t pp = 21; pp <= 52; ++pp)
|
||||
{
|
||||
const double xx = bx::ldexp(1.0, pp) + 1.0;
|
||||
const double dd = bx::ldexp(1.0, -8);
|
||||
|
||||
if (xx + dd - xx != dd)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
const double lhs = bx::sin(xx + dd);
|
||||
const double rhs = bx::sin(xx)*bx::cos(dd) + bx::cos(xx)*bx::sin(dd);
|
||||
|
||||
REQUIRE(bx::isEqual(lhs, rhs, 1.0e-15) );
|
||||
}
|
||||
|
||||
bx::RngMwc rng;
|
||||
|
||||
for (uint32_t ii = 0; ii < 50000; ++ii)
|
||||
{
|
||||
const uint64_t hi = uint64_t(rng.gen() );
|
||||
const uint64_t lo = uint64_t(rng.gen() );
|
||||
const uint64_t bits = (hi<<32) | lo;
|
||||
const double xx = bx::bitsToDouble(bits);
|
||||
|
||||
if (bx::isNan(xx) || bx::isInfinite(xx) )
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
const double ss = bx::sin(xx);
|
||||
const double cc = bx::cos(xx);
|
||||
|
||||
REQUIRE(bx::isFinite(ss) );
|
||||
REQUIRE(bx::isFinite(cc) );
|
||||
REQUIRE(bx::abs(ss) <= 1.0);
|
||||
REQUIRE(bx::abs(cc) <= 1.0);
|
||||
REQUIRE(bx::isEqual(1.0, ss*ss + cc*cc, 1.0e-15) );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("bitsToFloat, floatToBits, bitsToDouble, doubleToBits", "[math]")
|
||||
{
|
||||
STATIC_REQUIRE(0x12345678u == bx::floatToBits( bx::bitsToFloat (0x12345678u) ) );
|
||||
|
||||
Reference in New Issue
Block a user