Scarfski/bx
1
0
Fork 0
mirror of https://github.com/bkaradzic/bx.git synced 2026-10-22 16:51:01 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
97aa6da7dbef52f13c738010bbcc5a89825e7365
bx/tests/math_test.cpp
Branimir Karadžić fbadfc3abc Added SIMD version of BitArray find. (#464)
2026-10-17 09:37:35 -07:00

1844 lines
56 KiB
C++
Raw Blame History

/*
* Copyright 2010-2026 Branimir Karadzic. All rights reserved.
* License: https://github.com/bkaradzic/bx/blob/master/LICENSE
*/
#include "test.h"
#include <bx/math.h>
#include <bx/file.h>
#include <bx/rng.h>
#include <math.h>
#include <stdint.h> // intXX_t
#include <limits.h> // UCHAR_*
#include <float.h> // LDBL_MANT_DIG
TEST_CASE("fast-math is disabled", "[math][config]")
{
#if (defined(__FAST_MATH__) && __FAST_MATH__) || defined(_M_FP_FAST)
FAIL("Built with fast math enabled. bx math requires IEEE semantics: drop"
" `-ffast-math` / `/fp:fast` (`FloatFast` in scripts/toolchain.lua)."
);
#else
SUCCEED("IEEE semantics available.");
#endif // (defined(__FAST_MATH__) && __FAST_MATH__) || defined(_M_FP_FAST)
}
TEST_CASE("isFinite, isInfinite, isNan", "[math]")
{
for (uint64_t ii = 0; ii < UINT32_MAX; ii += rand()%(1<<13)+1)
{
union { uint32_t ui; float f; } u = { uint32_t(ii) };
BX_UNUSED(u);
#if BX_PLATFORM_OSX \
|| BX_PLATFORM_IOS \
|| BX_COMPILER_MSVC \
|| BX_PLATFORM_ANDROID
REQUIRE(!!::isnan(u.f) == bx::isNan(u.f) );
REQUIRE(!!::isfinite(u.f) == bx::isFinite(u.f) );
REQUIRE(!!::isinf(u.f) == bx::isInfinite(u.f) );
#elif !BX_CRT_MINGW
REQUIRE(::isnanf(u.f) == bx::isNan(u.f) );
REQUIRE(::finitef(u.f) == bx::isFinite(u.f) );
REQUIRE(::isinff(u.f) == bx::isInfinite(u.f) );
#endif // BX_*
}
}
TEST_CASE("log", "[math][libm]")
{
STATIC_REQUIRE(bx::isEqual( 0.0f, bx::log( 1.0f), 0.0000001f) );
STATIC_REQUIRE(bx::isEqual( 1.0f, bx::log(bx::kE), 0.0000001f) );
STATIC_REQUIRE(bx::isEqual(bx::kLogNat2, bx::log( 2.0f), 0.0000001f) );
}
static void testLog2(float _a)
{
REQUIRE(bx::log2(_a) == bx::log(_a) * (1.0f / bx::log(2.0f) ) );
}
TEST_CASE("log2", "[math][libm]")
{
testLog2(0.0f);
testLog2(256.0f);
STATIC_REQUIRE(bx::isEqual(0.0f, bx::log2( 1.0f), 0.0000001f) );
STATIC_REQUIRE(bx::isEqual(1.0f, bx::log2( 2.0f), 0.0000001f) );
STATIC_REQUIRE(bx::isEqual(2.0f, bx::log2( 4.0f), 0.0000001f) );
STATIC_REQUIRE(bx::isEqual(3.0f, bx::log2( 8.0f), 0.0000001f) );
STATIC_REQUIRE(bx::isEqual(4.0f, bx::log2( 16.0f), 0.0000001f) );
STATIC_REQUIRE(bx::isEqual(5.0f, bx::log2( 32.0f), 0.0000001f) );
STATIC_REQUIRE(bx::isEqual(6.0f, bx::log2( 64.0f), 0.0000001f) );
STATIC_REQUIRE(bx::isEqual(7.0f, bx::log2(128.0f), 0.0000001f) );
STATIC_REQUIRE(bx::isEqual(8.0f, bx::log2(256.0f), 0.0000001f) );
}
TEST_CASE("ceilLog2", "[math]")
{
STATIC_REQUIRE(0 == bx::ceilLog2(-1) );
STATIC_REQUIRE(0 == bx::ceilLog2(0) );
STATIC_REQUIRE(0 == bx::ceilLog2(1) );
STATIC_REQUIRE(1 == bx::ceilLog2(2) );
STATIC_REQUIRE(2 == bx::ceilLog2(4) );
STATIC_REQUIRE(3 == bx::ceilLog2(8) );
STATIC_REQUIRE(4 == bx::ceilLog2(16) );
STATIC_REQUIRE(5 == bx::ceilLog2(32) );
STATIC_REQUIRE(6 == bx::ceilLog2(64) );
STATIC_REQUIRE(7 == bx::ceilLog2(128) );
STATIC_REQUIRE(8 == bx::ceilLog2(256) );
{
uint32_t ii = 0;
for (; ii < 8; ++ii)
{
REQUIRE(ii == bx::ceilLog2(uint8_t(1<<ii) ) );
REQUIRE(ii == bx::ceilLog2(uint16_t(1<<ii) ) );
REQUIRE(ii == bx::ceilLog2(uint32_t(1<<ii) ) );
REQUIRE(ii == bx::ceilLog2(uint64_t(1ull<<ii) ) );
}
for (; ii < 16; ++ii)
{
REQUIRE(ii == bx::ceilLog2(uint16_t(1<<ii) ) );
REQUIRE(ii == bx::ceilLog2(uint32_t(1<<ii) ) );
REQUIRE(ii == bx::ceilLog2(uint64_t(1ull<<ii) ) );
}
for (; ii < 32; ++ii)
{
REQUIRE(ii == bx::ceilLog2(uint32_t(1<<ii) ) );
REQUIRE(ii == bx::ceilLog2(uint64_t(1ull<<ii) ) );
}
for (; ii < 64; ++ii)
{
REQUIRE(ii == bx::ceilLog2(uint64_t(1ull<<ii) ) );
}
}
for (uint32_t ii = 1; ii < INT32_MAX; ii += rand()%(1<<13)+1)
{
REQUIRE(bx::nextPow2(ii) == bx::simd32_u32_nextpow2(bx::simd32_splat(ii)).u32 );
}
}
TEST_CASE("floorLog2", "[math]")
{
STATIC_REQUIRE(0 == bx::floorLog2(-1) );
STATIC_REQUIRE(0 == bx::floorLog2(0) );
STATIC_REQUIRE(0 == bx::floorLog2(1) );
STATIC_REQUIRE(1 == bx::floorLog2(2) );
STATIC_REQUIRE(2 == bx::floorLog2(4) );
STATIC_REQUIRE(3 == bx::floorLog2(8) );
STATIC_REQUIRE(4 == bx::floorLog2(16) );
STATIC_REQUIRE(5 == bx::floorLog2(32) );
STATIC_REQUIRE(6 == bx::floorLog2(64) );
STATIC_REQUIRE(7 == bx::floorLog2(128) );
STATIC_REQUIRE(8 == bx::floorLog2(256) );
{
uint32_t ii = 0;
for (; ii < 8; ++ii)
{
REQUIRE(ii == bx::floorLog2(uint8_t(1<<ii) ) );
REQUIRE(ii == bx::floorLog2(uint16_t(1<<ii) ) );
REQUIRE(ii == bx::floorLog2(uint32_t(1<<ii) ) );
REQUIRE(ii == bx::floorLog2(uint64_t(1ull<<ii) ) );
}
for (; ii < 16; ++ii)
{
REQUIRE(ii == bx::floorLog2(uint16_t(1<<ii) ) );
REQUIRE(ii == bx::floorLog2(uint32_t(1<<ii) ) );
REQUIRE(ii == bx::floorLog2(uint64_t(1ull<<ii) ) );
}
for (; ii < 32; ++ii)
{
REQUIRE(ii == bx::floorLog2(uint32_t(1<<ii) ) );
REQUIRE(ii == bx::floorLog2(uint64_t(1ull<<ii) ) );
}
for (; ii < 64; ++ii)
{
REQUIRE(ii == bx::floorLog2(uint64_t(1ull<<ii) ) );
}
}
}
TEST_CASE("ceilLog2 & floorLog2", "[math]")
{
{
uint32_t prev = 0;
uint32_t next = 0;
for (uint32_t ii = 0; ii < (1<<18); ++ii)
{
if (bx::isPowerOf2(ii) )
{
REQUIRE(bx::ceilLog2(ii) == bx::floorLog2(ii) );
prev = next;
++next;
}
else
{
REQUIRE(prev == bx::floorLog2(ii) );
REQUIRE(next == bx::ceilLog2(ii) );
}
}
}
}
TEST_CASE("countTrailingZeros", "[math]")
{
STATIC_REQUIRE( 0 == bx::countTrailingZeros<uint8_t >(1) );
STATIC_REQUIRE( 7 == bx::countTrailingZeros<uint8_t >(1<<7) );
STATIC_REQUIRE( 8 == bx::countTrailingZeros<uint8_t >(0) );
STATIC_REQUIRE( 1 == bx::countTrailingZeros<uint8_t >(0x3e) );
STATIC_REQUIRE( 0 == bx::countTrailingZeros<uint16_t>(1) );
STATIC_REQUIRE(15 == bx::countTrailingZeros<uint16_t>(1<<15) );
STATIC_REQUIRE(16 == bx::countTrailingZeros<uint16_t>(0) );
STATIC_REQUIRE( 0 == bx::countTrailingZeros<uint32_t>(1) );
STATIC_REQUIRE(32 == bx::countTrailingZeros<uint32_t>(0) );
STATIC_REQUIRE(31 == bx::countTrailingZeros<uint32_t>(1u<<31) );
STATIC_REQUIRE( 0 == bx::countTrailingZeros<uint64_t>(1) );
STATIC_REQUIRE(64 == bx::countTrailingZeros<uint64_t>(0) );
}
template<typename Ty>
static uint8_t countLeadingZerosRef(Ty _val)
{
uint8_t count = 0;
for (int32_t ii = sizeof(Ty)*8 - 1; ii >= 0 && 0 == ( (_val >> ii) & 1); --ii)
{
++count;
}
return count;
}
template<typename Ty>
static uint8_t countTrailingZerosRef(Ty _val)
{
uint8_t count = 0;
for (uint32_t ii = 0; ii < sizeof(Ty)*8 && 0 == ( (_val >> ii) & 1); ++ii)
{
++count;
}
return count;
}
template<typename Ty>
static void testCountZeros(Ty _val)
{
volatile Ty val = _val;
REQUIRE(countLeadingZerosRef<Ty>(_val) == bx::countLeadingZeros<Ty>(val) );
REQUIRE(countTrailingZerosRef<Ty>(_val) == bx::countTrailingZeros<Ty>(val) );
}
TEST_CASE("countLeadingZeros/countTrailingZeros runtime", "[math]")
{
testCountZeros<uint32_t>(0);
testCountZeros<uint64_t>(0);
for (uint32_t ii = 0; ii < 64; ++ii)
{
testCountZeros<uint32_t>(uint32_t(1) << (ii & 31) );
testCountZeros<uint64_t>(uint64_t(1) << ii);
testCountZeros<uint64_t>(UINT64_MAX << ii);
testCountZeros<uint64_t>(UINT64_MAX >> ii);
}
bx::RngMwc rng;
for (uint32_t ii = 0; ii < 10000; ++ii)
{
const uint64_t val = (uint64_t(rng.gen() ) << 32) | rng.gen();
const uint32_t shift = rng.gen() % 64;
testCountZeros<uint32_t>(uint32_t(val) >> (shift & 31) );
testCountZeros<uint64_t>(val >> shift);
testCountZeros<uint64_t>(val << shift);
}
}
TEST_CASE("countLeadingZeros", "[math]")
{
STATIC_REQUIRE( 7 == bx::countLeadingZeros<uint8_t >(1) );
STATIC_REQUIRE( 8 == bx::countLeadingZeros<uint8_t >(0) );
STATIC_REQUIRE( 2 == bx::countLeadingZeros<uint8_t >(0x3e) );
STATIC_REQUIRE(15 == bx::countLeadingZeros<uint16_t>(1) );
STATIC_REQUIRE(16 == bx::countLeadingZeros<uint16_t>(0) );
STATIC_REQUIRE(31 == bx::countLeadingZeros<uint32_t>(1) );
STATIC_REQUIRE(32 == bx::countLeadingZeros<uint32_t>(0) );
STATIC_REQUIRE(63 == bx::countLeadingZeros<uint64_t>(1) );
STATIC_REQUIRE(64 == bx::countLeadingZeros<uint64_t>(0) );
}
TEST_CASE("countBits", "[math]")
{
STATIC_REQUIRE( 0 == bx::countBits(0) );
STATIC_REQUIRE( 1 == bx::countBits(1) );
STATIC_REQUIRE( 4 == bx::countBits<uint8_t>(0x55) );
STATIC_REQUIRE( 8 == bx::countBits<uint16_t>(0x5555) );
STATIC_REQUIRE(16 == bx::countBits<uint32_t>(0x55555555) );
STATIC_REQUIRE(32 == bx::countBits<uint64_t>(0x5555555555555555ull) );
STATIC_REQUIRE( 8 == bx::countBits(UINT8_MAX) );
STATIC_REQUIRE(16 == bx::countBits(UINT16_MAX) );
STATIC_REQUIRE(32 == bx::countBits(UINT32_MAX) );
STATIC_REQUIRE(64 == bx::countBits(UINT64_MAX) );
}
TEST_CASE("satAdd", "[math]")
{
STATIC_REQUIRE( 0 == bx::satAdd<uint8_t >(0, 0) );
STATIC_REQUIRE(200 == bx::satAdd<uint8_t >(100, 100) );
STATIC_REQUIRE(255 == bx::satAdd<uint8_t >(UINT8_MAX, 0) );
STATIC_REQUIRE(255 == bx::satAdd<uint8_t >(UINT8_MAX, 1) );
STATIC_REQUIRE(255 == bx::satAdd<uint8_t >(UINT8_MAX, 10) );
STATIC_REQUIRE(255 == bx::satAdd<uint8_t >(254, 254) );
STATIC_REQUIRE(255 == bx::satAdd<uint8_t >(200, 100) );
STATIC_REQUIRE(UINT16_MAX == bx::satAdd<uint16_t>(UINT16_MAX, 0) );
STATIC_REQUIRE(UINT16_MAX == bx::satAdd<uint16_t>(UINT16_MAX, 1) );
STATIC_REQUIRE(UINT16_MAX == bx::satAdd<uint16_t>(65530, 10) );
STATIC_REQUIRE(uint16_t(65534)== bx::satAdd<uint16_t>(65530, 4) );
STATIC_REQUIRE(UINT32_MAX == bx::satAdd<uint32_t>(UINT32_MAX, 0) );
STATIC_REQUIRE(UINT32_MAX == bx::satAdd<uint32_t>(UINT32_MAX, 1) );
STATIC_REQUIRE(UINT32_MAX == bx::satAdd<uint32_t>(UINT32_MAX-1, 10) );
STATIC_REQUIRE(UINT64_MAX == bx::satAdd<uint64_t>(UINT64_MAX, 1) );
STATIC_REQUIRE(UINT64_MAX == bx::satAdd<uint64_t>(UINT64_MAX-1, 10) );
// signed
STATIC_REQUIRE( 127 == bx::satAdd<int8_t >( 127, 1) );
STATIC_REQUIRE( 127 == bx::satAdd<int8_t >( 100, 100) );
STATIC_REQUIRE(-128 == bx::satAdd<int8_t >(-128, -1) );
STATIC_REQUIRE(-128 == bx::satAdd<int8_t >(-100,-100) );
STATIC_REQUIRE( -1 == bx::satAdd<int8_t >( 127,-128) );
STATIC_REQUIRE(INT32_MAX == bx::satAdd<int32_t>(INT32_MAX, 1) );
STATIC_REQUIRE(INT32_MAX == bx::satAdd<int32_t>(INT32_MAX, INT32_MAX) );
STATIC_REQUIRE(INT32_MIN == bx::satAdd<int32_t>(INT32_MIN, -1) );
STATIC_REQUIRE(INT32_MIN == bx::satAdd<int32_t>(INT32_MIN, INT32_MIN) );
STATIC_REQUIRE( -1 == bx::satAdd<int32_t>(INT32_MAX, INT32_MIN) );
STATIC_REQUIRE(INT64_MAX == bx::satAdd<int64_t>(INT64_MAX, 1) );
STATIC_REQUIRE(INT64_MIN == bx::satAdd<int64_t>(INT64_MIN, -1) );
}
TEST_CASE("satSub", "[math]")
{
STATIC_REQUIRE( 0 == bx::satSub<uint8_t >(0, 0) );
STATIC_REQUIRE( 0 == bx::satSub<uint8_t >(10, 20) );
STATIC_REQUIRE( 0 == bx::satSub<uint8_t >(0, UINT8_MAX) );
STATIC_REQUIRE( 10 == bx::satSub<uint8_t >(20, 10) );
STATIC_REQUIRE(UINT8_MAX == bx::satSub<uint8_t >(UINT8_MAX, 0) );
STATIC_REQUIRE( 0 == bx::satSub<uint16_t>(10, 20) );
STATIC_REQUIRE( 0 == bx::satSub<uint16_t>(0, UINT16_MAX) );
STATIC_REQUIRE(UINT16_MAX == bx::satSub<uint16_t>(UINT16_MAX, 0) );
STATIC_REQUIRE( 0 == bx::satSub<uint32_t>(10, 20) );
STATIC_REQUIRE( 0 == bx::satSub<uint32_t>(0, UINT32_MAX) );
STATIC_REQUIRE(UINT32_MAX == bx::satSub<uint32_t>(UINT32_MAX, 0) );
STATIC_REQUIRE( 0 == bx::satSub<uint64_t>(10, 20) );
STATIC_REQUIRE(UINT64_MAX == bx::satSub<uint64_t>(UINT64_MAX, 0) );
// signed
STATIC_REQUIRE(-128 == bx::satSub<int8_t >(-128, 1) );
STATIC_REQUIRE( 127 == bx::satSub<int8_t >( 127, -1) );
STATIC_REQUIRE( 127 == bx::satSub<int8_t >( 0,-128) );
STATIC_REQUIRE(INT32_MIN == bx::satSub<int32_t>(INT32_MIN, 1) );
STATIC_REQUIRE(INT32_MIN == bx::satSub<int32_t>(INT32_MIN, INT32_MAX) );
STATIC_REQUIRE(INT32_MAX == bx::satSub<int32_t>( 0, INT32_MIN) );
STATIC_REQUIRE(INT32_MAX == bx::satSub<int32_t>(INT32_MAX, -1) );
STATIC_REQUIRE(INT32_MAX == bx::satSub<int32_t>(INT32_MAX, INT32_MIN) );
STATIC_REQUIRE(INT64_MIN == bx::satSub<int64_t>(INT64_MIN, 1) );
STATIC_REQUIRE(INT64_MAX == bx::satSub<int64_t>( 0, INT64_MIN) );
}
template<typename Ty>
static void testFindFirstSet()
{
for (uint8_t ii = 0, num = sizeof(Ty)*8; ii < num; ++ii)
{
{
const Ty val = Ty(1) << ii;
const uint8_t result = bx::findFirstSet<Ty>(val);
REQUIRE(result == ii + 1);
}
{
const Ty val = ( (Ty(1) << ii) ) | (Ty(1) << (num - 1) );
const uint8_t result = bx::findFirstSet<Ty>(val);
REQUIRE(result == ii + 1);
}
}
}
TEST_CASE("findFirstSet", "[math]")
{
STATIC_REQUIRE( 1 == bx::findFirstSet<uint8_t >(1) );
STATIC_REQUIRE( 8 == bx::findFirstSet<uint8_t >(1<<7) );
STATIC_REQUIRE( 0 == bx::findFirstSet<uint8_t >(0) );
STATIC_REQUIRE( 2 == bx::findFirstSet<uint8_t >(0x3e) );
STATIC_REQUIRE( 1 == bx::findFirstSet<uint16_t>(1) );
STATIC_REQUIRE(16 == bx::findFirstSet<uint16_t>(1<<15) );
STATIC_REQUIRE( 0 == bx::findFirstSet<uint16_t>(0) );
STATIC_REQUIRE( 1 == bx::findFirstSet<uint32_t>(1) );
STATIC_REQUIRE( 0 == bx::findFirstSet<uint32_t>(0) );
STATIC_REQUIRE(32 == bx::findFirstSet<uint32_t>(1u<<31) );
STATIC_REQUIRE( 1 == bx::findFirstSet<uint64_t>(1) );
STATIC_REQUIRE( 0 == bx::findFirstSet<uint64_t>(0) );
STATIC_REQUIRE(64 == bx::findFirstSet<uint64_t>(0x8000000000000000ull) );
STATIC_REQUIRE( 1 == bx::findFirstSet<uint64_t>(0x8000000000000001ull) );
testFindFirstSet<uint8_t>();
testFindFirstSet<uint16_t>();
testFindFirstSet<uint32_t>();
testFindFirstSet<uint64_t>();
}
template<typename Ty>
static void testFindLastSet()
{
for (uint8_t ii = 0, num = sizeof(Ty)*8; ii < num; ++ii)
{
{
const Ty val = Ty(1) << ii;
const uint8_t result = bx::findLastSet<Ty>(val);
REQUIRE(result == ii + 1);
}
{
const Ty val = (Ty(1) << ii) - 1;
const uint8_t result = bx::findLastSet<Ty>(val);
REQUIRE(result == ii);
}
}
}
TEST_CASE("findLastSet", "[math]")
{
STATIC_REQUIRE( 1 == bx::findLastSet<uint8_t >(1) );
STATIC_REQUIRE( 8 == bx::findLastSet<uint8_t >(1<<7) );
STATIC_REQUIRE( 0 == bx::findLastSet<uint8_t >(0) );
STATIC_REQUIRE( 6 == bx::findLastSet<uint8_t >(0x3e) );
STATIC_REQUIRE( 1 == bx::findLastSet<uint16_t>(1) );
STATIC_REQUIRE(16 == bx::findLastSet<uint16_t>(1<<15) );
STATIC_REQUIRE( 0 == bx::findLastSet<uint16_t>(0) );
STATIC_REQUIRE( 1 == bx::findLastSet<uint32_t>(1) );
STATIC_REQUIRE( 0 == bx::findLastSet<uint32_t>(0) );
STATIC_REQUIRE(32 == bx::findLastSet<uint32_t>(1u<<31) );
STATIC_REQUIRE( 1 == bx::findLastSet<uint64_t>(1) );
STATIC_REQUIRE( 0 == bx::findLastSet<uint64_t>(0) );
STATIC_REQUIRE( 1 == bx::findLastSet<uint64_t>(1ull) );
STATIC_REQUIRE(64 == bx::findLastSet<uint64_t>(0x8000000000000000ull) );
STATIC_REQUIRE(64 == bx::findLastSet<uint64_t>(0x8000000000000001ull) );
testFindLastSet<uint8_t>();
testFindLastSet<uint16_t>();
testFindLastSet<uint32_t>();
testFindLastSet<uint64_t>();
}
BX_PRAGMA_DIAGNOSTIC_PUSH();
BX_PRAGMA_DIAGNOSTIC_IGNORED_MSVC(4723) // potential divide by 0
TEST_CASE("rcp", "[math][libm]")
{
STATIC_REQUIRE(1.0f == bx::rcp(1.0f) );
STATIC_REQUIRE(2.0f == bx::rcp(0.5f) );
}
TEST_CASE("rcpSafe", "[math][libm]")
{
STATIC_REQUIRE(1.0f == bx::rcpSafe(1.0f) );
STATIC_REQUIRE(2.0f == bx::rcpSafe(0.5f) );
STATIC_REQUIRE(bx::isFinite(bx::rcpSafe( 0.0f) ) );
STATIC_REQUIRE(bx::isFinite(bx::rcpSafe(-0.0f) ) );
}
TEST_CASE("rsqrt", "[math][libm]")
{
bx::WriterI* writer = bx::getNullOut();
bx::Error err;
// rsqrtRef
STATIC_REQUIRE(bx::isInfinite(bx::rsqrtRef(0.0f) ) );
for (float xx = bx::kNearZero; xx < 100.0f; xx += 0.1f)
{
bx::write(writer, &err, "rsqrtRef(%f) == %f (expected: %f)\n", xx, bx::rsqrtRef(xx), 1.0f / ::sqrtf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::rsqrtRef(xx), 1.0f / ::sqrtf(xx), 0.00001f) );
}
// rsqrtSimd
REQUIRE(bx::isInfinite(bx::rsqrtSimd(0.0f) ) );
for (float xx = bx::kNearZero; xx < 100.0f; xx += 0.1f)
{
bx::write(writer, &err, "rsqrtSimd(%f) == %f (expected: %f)\n", xx, bx::rsqrtSimd(xx), 1.0f / ::sqrtf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::rsqrtSimd(xx), 1.0f / ::sqrtf(xx), 0.00001f) );
}
// rsqrt
REQUIRE(bx::isInfinite(1.0f / ::sqrtf(0.0f) ) );
REQUIRE(bx::isInfinite(bx::rsqrt(0.0f) ) );
for (float xx = bx::kNearZero; xx < 100.0f; xx += 0.1f)
{
bx::write(writer, &err, "rsqrt(%f) == %f (expected: %f)\n", xx, bx::rsqrt(xx), 1.0f / ::sqrtf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::rsqrt(xx), 1.0f / ::sqrtf(xx), 0.00001f) );
}
}
TEST_CASE("sqrt", "[math][libm]")
{
bx::WriterI* writer = bx::getNullOut();
bx::Error err;
// sqrtRef
STATIC_REQUIRE(bx::isNan(bx::sqrtRef(-1.0f) ) );
REQUIRE(bx::isEqual(bx::sqrtRef(0.0f), ::sqrtf(0.0f), 0.0f) );
REQUIRE(bx::isEqual(bx::sqrtRef(1.0f), ::sqrtf(1.0f), 0.0f) );
for (float xx = 0.0f; xx < 1000000.0f; xx += 1000.f)
{
bx::write(writer, &err, "sqrtRef(%f) == %f (expected: %f)\n", xx, bx::sqrtRef(xx), ::sqrtf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::sqrtRef(xx), ::sqrtf(xx), 0.00001f) );
}
// sqrtSimd
REQUIRE(bx::isNan(bx::sqrtSimd(-1.0f) ) );
REQUIRE(bx::isEqual(bx::sqrtSimd(0.0f), ::sqrtf(0.0f), 0.00001f) );
REQUIRE(bx::isEqual(bx::sqrtSimd(1.0f), ::sqrtf(1.0f), 0.00001f) );
for (float xx = 0.0f; xx < 1000000.0f; xx += 1000.f)
{
bx::write(writer, &err, "sqrtSimd(%f) == %f (expected: %f)\n", xx, bx::sqrtSimd(xx), ::sqrtf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::sqrtSimd(xx), ::sqrtf(xx), 0.00001f) );
}
for (float xx = 0.0f; xx < 100.0f; xx += 0.1f)
{
bx::write(writer, &err, "sqrt(%f) == %f (expected: %f)\n", xx, bx::sqrt(xx), ::sqrtf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::sqrt(xx), ::sqrtf(xx), 0.00001f) );
}
// sqrt
REQUIRE(bx::isNan(::sqrtf(-1.0f) ) );
REQUIRE(bx::isNan(bx::sqrt(-1.0f) ) );
REQUIRE(bx::isEqual(bx::sqrt(0.0f), ::sqrtf(0.0f), 0.00001f) );
REQUIRE(bx::isEqual(bx::sqrt(1.0f), ::sqrtf(1.0f), 0.00001f) );
for (float xx = 0.0f; xx < 1000000.0f; xx += 1000.f)
{
bx::write(writer, &err, "sqrt(%f) == %f (expected: %f)\n", xx, bx::sqrt(xx), ::sqrtf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::sqrt(xx), ::sqrtf(xx), 0.00001f) );
}
for (float xx = 0.0f; xx < 100.0f; xx += 0.1f)
{
bx::write(writer, &err, "sqrt(%f) == %f (expected: %f)\n", xx, bx::sqrt(xx), ::sqrtf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::sqrt(xx), ::sqrtf(xx), 0.00001f) );
}
}
BX_PRAGMA_DIAGNOSTIC_POP();
TEST_CASE("abs", "[math][libm]")
{
STATIC_REQUIRE(1389.0f == bx::abs(-1389.0f) );
STATIC_REQUIRE(1389.0f == bx::abs( 1389.0f) );
STATIC_REQUIRE( 0.0f == bx::abs(-0.0f) );
STATIC_REQUIRE( 0.0f == bx::abs( 0.0f) );
}
TEST_CASE("mod", "[math][libm]")
{
STATIC_REQUIRE(389.0f == bx::mod(1389.0f, 1000.0f) );
STATIC_REQUIRE( 89.0f == bx::mod(1389.0f, 100.0f) );
STATIC_REQUIRE( 9.0f == bx::mod(1389.0f, 10.0f) );
STATIC_REQUIRE( 4.0f == bx::mod(1389.0f, 5.0f) );
STATIC_REQUIRE( 1.0f == bx::mod(1389.0f, 2.0f) );
}
static float madSplit(float _a, float _b, float _c)
{
volatile float ab = _a * _b;
return ab + _c;
}
static constexpr float maddRef(float _a, float _b, float _c)
{
return bx::bitCast<float>(
bx::simd32_f32_madd_ref(bx::simd32_ld(_a), bx::simd32_ld(_b), bx::simd32_ld(_c) )
);
}
TEST_CASE("mad", "[math]")
{
constexpr float kA = 0x1.000002p+0f;
constexpr float kB = 0x1.fffffcp-1f;
constexpr float kFused = -0x1p-46f;
STATIC_REQUIRE(kFused == maddRef(kA, kB, -1.0f) );
volatile float va = kA;
volatile float vb = kB;
volatile float vc = -1.0f;
REQUIRE(kFused == maddRef(va, vb, vc) );
STATIC_REQUIRE( kFused == bx::mad(kA, kB, -1.0f) );
STATIC_REQUIRE(-kFused == bx::nms(kA, kB, 1.0f) );
#if BX_CONFIG_FMA
REQUIRE(kFused == bx::mad(va, vb, vc) );
#else
REQUIRE(0.0f == bx::mad(va, vb, vc) );
#endif // BX_CONFIG_FMA
REQUIRE(0.0f == madSplit(va, vb, vc) );
REQUIRE(bx::isNan(bx::mad(bx::kFloatInfinity, 0.0f, 1.0f) ) );
REQUIRE(bx::isNan(bx::mad(bx::kFloatInfinity, 1.0f, -bx::kFloatInfinity) ) );
REQUIRE(bx::kFloatExponentMask == bx::bitCast<uint32_t>(bx::mad(3.0e38f, 2.0f, 0.0f) ) );
#if BX_CONFIG_FMA
REQUIRE( (bx::kFloatSignMask|bx::kFloatExponentMask) == bx::bitCast<uint32_t>(bx::mad(3.0e38f, 2.0f, -bx::kFloatInfinity) ) );
#else
REQUIRE(bx::isNan(bx::mad(3.0e38f, 2.0f, -bx::kFloatInfinity) ) );
#endif // BX_CONFIG_FMA
STATIC_REQUIRE( (bx::kFloatSignMask|bx::kFloatExponentMask) == bx::bitCast<uint32_t>(maddRef(3.0e38f, 2.0f, -bx::kFloatInfinity) ) );
REQUIRE(0 == bx::bitCast<uint32_t>(bx::mad( 1.0f, 1.0f, -1.0f) ) );
REQUIRE(bx::kFloatSignMask == bx::bitCast<uint32_t>(bx::mad(-1.0f, 0.0f, -0.0f) ) );
REQUIRE(0 == bx::bitCast<uint32_t>(bx::mad(-1.0f, 0.0f, 0.0f) ) );
STATIC_REQUIRE(bx::bitCast<uint32_t>(0x1p-140f) == bx::bitCast<uint32_t>(maddRef(0x1p-100f, 0x1p-40f, 0.0f) ) );
STATIC_REQUIRE(bx::bitCast<uint32_t>(0x1p-149f) == bx::bitCast<uint32_t>(maddRef(0x1p-75f, 0x1.000002p-75f, 0.0f) ) );
STATIC_REQUIRE(bx::bitCast<uint32_t>(0.0f) == bx::bitCast<uint32_t>(maddRef(0x1p-75f, 0x1p-75f, 0.0f) ) );
STATIC_REQUIRE(bx::bitCast<uint32_t>(0x1p-148f) == bx::bitCast<uint32_t>(maddRef(0x1p-75f, 0x1p-75f, 0x1p-149f) ) );
STATIC_REQUIRE(0x1p-46f == maddRef(0x1.000002p+0f, 0x1.000002p+0f, -0x1.000004p+0f) );
STATIC_REQUIRE(1.0f == maddRef(0x1.fffffep+22f, 2.0f, -0x1.fffffcp+23f) );
bx::RngMwc rng;
for (uint32_t ii = 0; ii < 65536; ++ii)
{
auto gen = [&rng]() -> float
{
const uint32_t bits = rng.gen();
const uint32_t exp = 96 + (bits>>23)%64;
return bx::bitCast<float>( (bits & 0x807fffff) | (exp<<23) );
};
const float aa = gen();
const float bb = gen();
const float cc = gen();
#if LDBL_MANT_DIG >= 64
const float ref = float( (long double)(aa) * (long double)(bb) + (long double)(cc) );
#else
const float ref = ::fmaf(aa, bb, cc);
#endif // LDBL_MANT_DIG >= 64
const float sw = maddRef(aa, bb, cc);
REQUIRE(bx::bitCast<uint32_t>(ref) == bx::bitCast<uint32_t>(sw) );
#if BX_CONFIG_FMA
const float mad = bx::mad(aa, bb, cc);
REQUIRE(bx::bitCast<uint32_t>(ref) == bx::bitCast<uint32_t>(mad) );
#endif // BX_CONFIG_FMA
}
}
typedef float (*MathFloatFn)(float);
template<MathFloatFn BxT, MathFloatFn CrtT>
static void testMathFunc1Float(float _value)
{
REQUIRE(CrtT(_value) == BxT(_value) );
}
TEST_CASE("floor", "[math][libm]")
{
STATIC_REQUIRE( 13.0f == bx::floor( 13.89f) );
STATIC_REQUIRE(-14.0f == bx::floor(-13.89f) );
testMathFunc1Float<bx::floor, ::floorf>( 13.89f);
testMathFunc1Float<bx::floor, ::floorf>(-13.89f);
}
TEST_CASE("ceil", "[math][libm]")
{
STATIC_REQUIRE( 14.0f == bx::ceil( 13.89f) );
STATIC_REQUIRE(-13.0f == bx::ceil( -13.89f) );
testMathFunc1Float<bx::ceil, ::ceilf>( 13.89f);
testMathFunc1Float<bx::ceil, ::ceilf>(-13.89f);
}
TEST_CASE("round", "[math][libm]")
{
STATIC_REQUIRE( 14.0f == bx::round( 13.89f) );
STATIC_REQUIRE(-14.0f == bx::round( -13.89f) );
STATIC_REQUIRE( 2.0f == bx::round( 2.5f) );
STATIC_REQUIRE( 4.0f == bx::round( 3.5f) );
STATIC_REQUIRE( -2.0f == bx::round( -2.5f) );
STATIC_REQUIRE( 0.0f == bx::round( 0.49999997f) );
STATIC_REQUIRE( 0x1p22f == bx::round(0x1p22f + 0.5f) );
STATIC_REQUIRE( 0x1p22f + 2.0f == bx::round(0x1p22f + 1.5f) );
STATIC_REQUIRE(bx::kFloatSignMask == bx::bitCast<uint32_t>(bx::round(-0.4f) ) );
testMathFunc1Float<bx::round, ::roundf>( 13.89f);
testMathFunc1Float<bx::round, ::roundf>(-13.89f);
}
TEST_CASE("trunc", "[math][libm]")
{
STATIC_REQUIRE( 13.0f == bx::trunc( 13.89f) );
STATIC_REQUIRE(-13.0f == bx::trunc(-13.89f) );
STATIC_REQUIRE( 1.0e10f == bx::trunc( 1.0e10f) );
STATIC_REQUIRE(-1.0e10f == bx::trunc(-1.0e10f) );
STATIC_REQUIRE( 1.0e10f == bx::floor( 1.0e10f) );
STATIC_REQUIRE(-1.0e10f == bx::ceil( -1.0e10f) );
STATIC_REQUIRE(bx::kFloatSignMask == bx::bitCast<uint32_t>(bx::trunc(-0.5f) ) );
STATIC_REQUIRE(bx::kFloatSignMask == bx::bitCast<uint32_t>(bx::ceil( -0.5f) ) );
STATIC_REQUIRE(bx::kFloatExponentMask == bx::bitCast<uint32_t>(bx::floor(bx::kFloatInfinity) ) );
volatile float nan = bx::bitCast<float>(0x7fc00000u);
REQUIRE(bx::isNan(bx::trunc(nan) ) );
REQUIRE(bx::isNan(bx::floor(nan) ) );
testMathFunc1Float<bx::trunc, ::truncf>( 13.89f);
testMathFunc1Float<bx::trunc, ::truncf>(-13.89f);
}
TEST_CASE("fract", "[math][libm]")
{
STATIC_REQUIRE(bx::isEqual( 0.89f, bx::fract( 13.89f), 0.000001f) );
STATIC_REQUIRE(bx::isEqual(-0.89f, bx::fract(-13.89f), 0.000001f) );
}
TEST_CASE("ldexp", "[math][libm]")
{
STATIC_REQUIRE( 1389.0f == bx::ldexp(86.8125, 4) );
STATIC_REQUIRE(0.437500f == bx::ldexp(7.0f, -4) );
STATIC_REQUIRE(bx::isEqual(-0.0f, bx::ldexp(-0.0f, 10), 0.000000001f) );
STATIC_REQUIRE(0x1p127f == bx::ldexp(1.0f, 127) );
STATIC_REQUIRE(0x1p-126f == bx::ldexp(1.0f, -126) );
STATIC_REQUIRE(0x1p24f == bx::ldexp(1.0f, 24) );
bx::WriterI* writer = bx::getNullOut();
bx::Error err;
for (int32_t yy = -10; yy < 10; ++yy)
{
for (float xx = -100.0f; xx < 100.0f; xx += 0.1f)
{
bx::write(writer, &err, "ldexp(%f, %d) == %f (expected: %f)\n", xx, yy, bx::ldexp(xx, yy), ::ldexpf(xx, yy) );
REQUIRE(bx::isEqual(bx::ldexp(xx, yy), ::ldexpf(xx, yy), 0.00001f) );
}
}
}
TEST_CASE("exp", "[math][libm]")
{
STATIC_REQUIRE( 1.0f == bx::exp(-0.0f) );
STATIC_REQUIRE( 0.0f == bx::exp(-bx::kFloatInfinity) );
STATIC_REQUIRE(bx::exp(bx::log(bx::kFloatSmallest) ) <= bx::kFloatSmallest);
bx::WriterI* writer = bx::getNullOut();
bx::Error err;
for (float xx = -80.0f; xx < 80.0f; xx += 0.1f)
{
bx::write(writer, &err, "exp(%f) == %f (expected: %f)\n", xx, bx::exp(xx), ::expf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::exp(xx), ::expf(xx), 0.00001f) );
}
}
TEST_CASE("pow", "[math][libm]")
{
STATIC_REQUIRE(1.0f == bx::pow(0.0f, 0.0f) );
STATIC_REQUIRE(1.0f == bx::pow(1.0f, 0.0f) );
STATIC_REQUIRE(1.0f == bx::pow(3.0f, 0.0f) );
STATIC_REQUIRE(1.0f == bx::pow(8.0f, 0.0f) );
STATIC_REQUIRE(1.0f == bx::pow(9.0f, 0.0f) );
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( 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) );
STATIC_REQUIRE(-0.125f == bx::pow(-2.0f, -3.0f) );
bx::WriterI* writer = bx::getNullOut();
bx::Error err;
for (float xx = -100.0f; xx < 100.0f; xx += 0.1f)
{
bx::write(writer, &err, "pow(1.389f, %f) == %f (expected: %f)\n", xx, bx::pow(1.389f, xx), ::powf(1.389f, xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::pow(1.389f, xx), ::powf(1.389f, xx), 0.00001f) );
}
}
TEST_CASE("asin", "[math][libm]")
{
STATIC_REQUIRE(bx::isEqual( 0.0f, bx::asin(0.0f), 0.0001f) );
STATIC_REQUIRE(bx::isEqual(bx::kPiHalf, bx::asin(1.0f), 0.0001f) );
bx::WriterI* writer = bx::getNullOut();
bx::Error err;
for (float xx = -1.0f; xx < 1.0f; xx += 0.001f)
{
bx::write(writer, &err, "asin(%f) == %f (expected: %f)\n", xx, bx::asin(xx), ::asinf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::asin(xx), ::asinf(xx), 0.0001f) );
}
}
TEST_CASE("sin", "[math][libm]")
{
STATIC_REQUIRE(bx::isEqual( 0.0f, bx::sin(0.0f ), 0.0000001f) );
STATIC_REQUIRE(bx::isEqual( 1.0f, bx::sin(bx::kPiHalf ), 0.0000001f) );
STATIC_REQUIRE(bx::isEqual( 0.0f, bx::sin(bx::kPi ), 0.0000001f) );
STATIC_REQUIRE(bx::isEqual(-1.0f, bx::sin(bx::kPiHalf*3.0f), 0.0000001f) );
bx::WriterI* writer = bx::getNullOut();
bx::Error err;
for (float xx = -100.0f; xx < 100.0f; xx += 0.1f)
{
bx::write(writer, &err, "sin(%f) == %f (expected: %f)\n", xx, bx::sin(xx), ::sinf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::sin(xx), ::sinf(xx), 0.00001f) );
}
for (float xx = -bx::kPi2; xx < bx::kPi2; xx += 0.0001f)
{
bx::write(writer, &err, "sin(%f) == %f (expected: %f)\n", xx, bx::sin(xx), ::sinf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::sin(xx), ::sinf(xx), 0.00001f) );
}
}
TEST_CASE("sinCos", "[math][libm]")
{
bx::WriterI* writer = bx::getNullOut();
bx::Error err;
for (float xx = -100.0f; xx < 100.0f; xx += 0.1f)
{
float ss, cc;
bx::sinCosApprox(ss, cc, xx);
bx::write(writer, &err, "sinCos(%f) == sin %f (expected: %f)\n", xx, ss, ::sinf(xx) );
bx::write(writer, &err, "sinCos(%f) == cos %f (expected: %f)\n", xx, cc, ::cosf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(ss, ::sinf(xx), 0.001f) );
REQUIRE(bx::isEqual(cc, ::cosf(xx), 0.00001f) );
}
for (float xx = -bx::kPi2; xx < bx::kPi2; xx += 0.0001f)
{
float ss, cc;
bx::sinCosApprox(ss, cc, xx);
bx::write(writer, &err, "sinCos(%f) == sin %f (expected: %f)\n", xx, ss, ::sinf(xx) );
bx::write(writer, &err, "sinCos(%f) == cos %f (expected: %f)\n", xx, cc, ::cosf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(ss, ::sinf(xx), 0.001f) );
REQUIRE(bx::isEqual(cc, ::cosf(xx), 0.00001f) );
}
}
TEST_CASE("sinh", "[math][libm]")
{
bx::WriterI* writer = bx::getNullOut();
bx::Error err;
for (float xx = -1.0f; xx < 1.0f; xx += 0.1f)
{
bx::write(writer, &err, "sinh(%f) == %f (expected: %f)\n", xx, bx::sinh(xx), ::sinhf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::sinh(xx), ::sinhf(xx), 0.00001f) );
}
}
TEST_CASE("acos", "[math][libm]")
{
STATIC_REQUIRE(bx::isEqual(bx::kPiHalf, bx::acos(0.0f), 0.0001f) );
STATIC_REQUIRE(bx::isEqual( 0.0f, bx::acos(1.0f), 0.0001f) );
bx::WriterI* writer = bx::getNullOut();
bx::Error err;
for (float xx = -1.0f; xx < 1.0f; xx += 0.001f)
{
bx::write(writer, &err, "acos(%f) == %f (expected: %f\n)", xx, bx::acos(xx), ::acosf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::acos(xx), ::acosf(xx), 0.0001f) );
}
}
TEST_CASE("cos", "[math][libm]")
{
STATIC_REQUIRE(bx::isEqual( 1.0f, bx::cos(0.0f ), 0.0000001f) );
STATIC_REQUIRE(bx::isEqual( 0.0f, bx::cos(bx::kPiHalf ), 0.0000001f) );
STATIC_REQUIRE(bx::isEqual(-1.0f, bx::cos(bx::kPi ), 0.0000001f) );
STATIC_REQUIRE(bx::isEqual( 0.0f, bx::cos(bx::kPiHalf*3.0f), 0.0000001f) );
bx::WriterI* writer = bx::getNullOut();
bx::Error err;
for (float xx = -100.0f; xx < 100.0f; xx += 0.1f)
{
bx::write(writer, &err, "cos(%f) == %f (expected: %f)\n", xx, bx::cos(xx), ::cosf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::cos(xx), ::cosf(xx), 0.00001f) );
}
for (float xx = -bx::kPi2; xx < bx::kPi2; xx += 0.0001f)
{
bx::write(writer, &err, "cos(%f) == %f (expected: %f)\n", xx, bx::cos(xx), ::cosf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::cos(xx), ::cosf(xx), 0.00001f) );
}
}
TEST_CASE("tan", "[math][libm]")
{
bx::WriterI* writer = bx::getNullOut();
bx::Error err;
for (float xx = -100.0f; xx < 100.0f; xx += 0.1f)
{
bx::write(writer, &err, "tan(%f) == %f (expected: %f)\n", xx, bx::tan(xx), ::tanf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::tan(xx), ::tanf(xx), 0.001f) );
}
}
TEST_CASE("tanh", "[math][libm]")
{
bx::WriterI* writer = bx::getNullOut();
bx::Error err;
for (float xx = -1.0f; xx < 1.0f; xx += 0.1f)
{
bx::write(writer, &err, "tanh(%f) == %f (expected: %f\n", xx, bx::tanh(xx), ::tanhf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::tanh(xx), ::tanhf(xx), 0.00001f) );
}
}
TEST_CASE("atan", "[math][libm]")
{
bx::WriterI* writer = bx::getNullOut();
bx::Error err;
for (float xx = -100.0f; xx < 100.0f; xx += 0.1f)
{
bx::write(writer, &err, "atan(%f) == %f (expected: %f)\n", xx, bx::atan(xx), ::atanf(xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::atan(xx), ::atanf(xx), 0.00001f) );
}
}
TEST_CASE("atan2", "[math][libm]")
{
bx::WriterI* writer = bx::getNullOut();
bx::Error err;
REQUIRE(bx::isEqual(bx::atan2(0.0f, 0.0f), ::atan2f(0.0f, 0.0f), 0.00001f) );
REQUIRE(bx::isEqual(bx::atan2(0.0f, 1.0f), ::atan2f(0.0f, 1.0f), 0.00001f) );
REQUIRE(bx::isEqual(bx::atan2(0.0f, -1.0f), ::atan2f(0.0f, -1.0f), 0.00001f) );
for (float yy = -100.0f; yy < 100.0f; yy += 0.1f)
{
for (float xx = -100.0f; xx < 100.0f; xx += 0.1f)
{
bx::write(writer, &err, "atan2(%f, %f) == %f (expected: %f)\n", yy, xx, bx::atan2(yy, xx), ::atan2f(yy, xx) );
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::atan2(yy, xx), ::atan2f(yy, xx), 0.00001f) );
}
}
}
TEST_CASE("sign", "[math][libm]")
{
STATIC_REQUIRE(-1 == bx::sign(-0.1389f) );
STATIC_REQUIRE( 0 == bx::sign( 0.0000f) );
STATIC_REQUIRE( 1 == bx::sign( 0.1389f) );
STATIC_REQUIRE(-1 == bx::sign(-bx::kFloatInfinity) );
STATIC_REQUIRE( 1 == bx::sign( bx::kFloatInfinity) );
}
TEST_CASE("signBit", "[math][libm]")
{
STATIC_REQUIRE( bx::signBit(-0.1389f) );
STATIC_REQUIRE(!bx::signBit( 0.0000f) );
STATIC_REQUIRE( bx::signBit(-0.0000f) );
STATIC_REQUIRE(!bx::signBit( 0.1389f) );
STATIC_REQUIRE( bx::signBit(-bx::kFloatInfinity) );
STATIC_REQUIRE(!bx::signBit( bx::kFloatInfinity) );
}
TEST_CASE("copySign", "[math][libm]")
{
STATIC_REQUIRE( 0.1389f == bx::copySign(-0.1389f, +1389) );
STATIC_REQUIRE(-0.0000f == bx::copySign( 0.0000f, -1389) );
STATIC_REQUIRE(-0.1389f == bx::copySign( 0.1389f, -1389) );
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) ) );
STATIC_REQUIRE(0x123456789abcdef0ull == bx::doubleToBits(bx::bitsToDouble(0x123456789abcdef0ull) ) );
}
TEST_CASE("floatFlip", "[math]")
{
const float values[] =
{
bx::LimitsT<float>::min,
-1000.0f,
-30.0f,
-10.0f,
-1.0f,
-0.5f,
-0.0f,
0.0f,
0.5f,
1.0f,
10.0f,
30.0f,
1000.0f,
bx::LimitsT<float>::max,
};
for (uint32_t ii = 1; ii < BX_COUNTOF(values); ++ii)
{
const uint32_t prev = bx::floatFlip(bx::floatToBits(values[ii-1]) );
const uint32_t curr = bx::floatFlip(bx::floatToBits(values[ii ]) );
INFO("values[" << ii-1 << "] = " << values[ii-1] << " -> " << prev);
INFO("values[" << ii << "] = " << values[ii ] << " -> " << curr);
REQUIRE(prev <= curr);
}
REQUIRE(bx::floatFlip(bx::floatToBits(-0.0f) ) < bx::floatFlip(bx::floatToBits(0.0f) ) );
REQUIRE(bx::floatFlip(bx::floatToBits( 1.0f) ) != bx::floatFlip(bx::floatToBits(bx::bitsToFloat(bx::floatToBits( 1.0f)+1) ) ) );
REQUIRE(bx::floatFlip(bx::floatToBits(-1.0f) ) != bx::floatFlip(bx::floatToBits(bx::bitsToFloat(bx::floatToBits(-1.0f)+1) ) ) );
}
TEST_CASE("lerp", "[math]")
{
STATIC_REQUIRE(1389.0f == bx::lerp(1389.0f, 1453.0f, 0.0f) );
STATIC_REQUIRE(1453.0f == bx::lerp(1389.0f, 1453.0f, 1.0f) );
STATIC_REQUIRE( 0.5f == bx::lerp( 0.0f, 1.0f, 0.5f) );
STATIC_REQUIRE( 0.0f == bx::lerp( 0.0f, 0.0f, 0.5f) );
}
void mtxCheck(const float* _a, const float* _b)
{
if (!bx::isEqual(_a, _b, 16, 0.01f) )
{
DBG("\n"
"A:\n"
"%10.4f %10.4f %10.4f %10.4f\n"
"%10.4f %10.4f %10.4f %10.4f\n"
"%10.4f %10.4f %10.4f %10.4f\n"
"%10.4f %10.4f %10.4f %10.4f\n"
"B:\n"
"%10.4f %10.4f %10.4f %10.4f\n"
"%10.4f %10.4f %10.4f %10.4f\n"
"%10.4f %10.4f %10.4f %10.4f\n"
"%10.4f %10.4f %10.4f %10.4f\n"
, _a[ 0], _a[ 1], _a[ 2], _a[ 3]
, _a[ 4], _a[ 5], _a[ 6], _a[ 7]
, _a[ 8], _a[ 9], _a[10], _a[11]
, _a[12], _a[13], _a[14], _a[15]
, _b[ 0], _b[ 1], _b[ 2], _b[ 3]
, _b[ 4], _b[ 5], _b[ 6], _b[ 7]
, _b[ 8], _b[ 9], _b[10], _b[11]
, _b[12], _b[13], _b[14], _b[15]
);
REQUIRE(false);
}
}
TEST_CASE("vec3", "[math][vec3]")
{
REQUIRE(bx::isEqual({0.0f, 0.0f, 0.0f}, bx::normalize({0.0f, 0.0f, 0.0f}), 0.0f) );
bx::Vec3 normalized = bx::normalize({0.0f, 1.0f, 0.0f});
REQUIRE(bx::isEqual(normalized, {0.0f, 1.0f, 0.0f}, 0.00001f) );
float length = bx::length(normalized);
REQUIRE(bx::isEqual(length, 1.0f, 0.00001f) );
}
TEST_CASE("quaternion", "[math][quaternion]")
{
float mtxQ[16];
float mtx[16];
bx::Quaternion quat = bx::InitIdentity;
bx::Quaternion q2 = bx::InitNone;
bx::Vec3 axis = bx::InitNone;
bx::Vec3 euler = bx::InitNone;
float angle;
bx::mtxFromQuaternion(mtxQ, quat);
bx::mtxIdentity(mtx);
mtxCheck(mtxQ, mtx);
float ax = bx::kPi/27.0f;
float ay = bx::kPi/13.0f;
float az = bx::kPi/7.0f;
{ // x
quat = bx::rotateX(ax);
bx::mtxFromQuaternion(mtxQ, quat);
bx::mtxRotateX(mtx, ax);
mtxCheck(mtxQ, mtx);
bx::toAxisAngle(axis, angle, quat);
REQUIRE(bx::isEqual(axis, bx::Vec3{1.0f, 0.0f, 0.0f}, 0.01f) );
REQUIRE(bx::isEqual(angle, ax, 0.01f) );
euler = bx::toEuler(quat);
REQUIRE(bx::isEqual(euler.x, ax, 0.001f) );
q2 = bx::fromEuler(euler);
REQUIRE(bx::isEqual(quat, q2, 0.001f) );
}
{ // y
quat = bx::rotateY(ay);
bx::mtxFromQuaternion(mtxQ, quat);
bx::mtxRotateY(mtx, ay);
mtxCheck(mtxQ, mtx);
bx::toAxisAngle(axis, angle, quat);
REQUIRE(bx::isEqual(axis, bx::Vec3{0.0f, 1.0f, 0.0f}, 0.01f) );
REQUIRE(bx::isEqual(angle, ay, 0.01f) );
euler = bx::toEuler(quat);
REQUIRE(bx::isEqual(euler.y, ay, 0.001f) );
q2 = bx::fromEuler(euler);
REQUIRE(bx::isEqual(quat, q2, 0.001f) );
}
{ // z
quat = bx::rotateZ(az);
bx::mtxFromQuaternion(mtxQ, quat);
bx::mtxRotateZ(mtx, az);
mtxCheck(mtxQ, mtx);
bx::toAxisAngle(axis, angle, quat);
REQUIRE(bx::isEqual(axis, bx::Vec3{0.0f, 0.0f, 1.0f}, 0.01f) );
REQUIRE(bx::isEqual(angle, az, 0.01f) );
euler = bx::toEuler(quat);
REQUIRE(bx::isEqual(euler.z, az, 0.001f) );
q2 = bx::fromEuler(euler);
REQUIRE(bx::isEqual(quat, q2, 0.001f) );
}
}
TEST_CASE("limits", "[math]")
{
STATIC_REQUIRE(bx::LimitsT<int8_t>::min == INT8_MIN);
STATIC_REQUIRE(bx::LimitsT<int8_t>::max == INT8_MAX);
STATIC_REQUIRE(bx::LimitsT<signed char>::min == SCHAR_MIN);
STATIC_REQUIRE(bx::LimitsT<signed char>::max == SCHAR_MAX);
STATIC_REQUIRE(bx::LimitsT<unsigned char>::min == 0);
STATIC_REQUIRE(bx::LimitsT<unsigned char>::max == UCHAR_MAX);
STATIC_REQUIRE(bx::LimitsT<int16_t>::min == INT16_MIN);
STATIC_REQUIRE(bx::LimitsT<int16_t>::max == INT16_MAX);
STATIC_REQUIRE(bx::LimitsT<uint16_t>::min == 0);
STATIC_REQUIRE(bx::LimitsT<uint16_t>::max == UINT16_MAX);
STATIC_REQUIRE(bx::LimitsT<int32_t>::min == INT32_MIN);
STATIC_REQUIRE(bx::LimitsT<int32_t>::max == INT32_MAX);
STATIC_REQUIRE(bx::LimitsT<uint32_t>::min == 0);
STATIC_REQUIRE(bx::LimitsT<uint32_t>::max == UINT32_MAX);
STATIC_REQUIRE(bx::LimitsT<int64_t>::min == INT64_MIN);
STATIC_REQUIRE(bx::LimitsT<int64_t>::max == INT64_MAX);
STATIC_REQUIRE(bx::LimitsT<uint64_t>::min == 0);
STATIC_REQUIRE(bx::LimitsT<uint64_t>::max == UINT64_MAX);
STATIC_REQUIRE(bx::LimitsT<float>::min == std::numeric_limits<float>::lowest() );
STATIC_REQUIRE(bx::LimitsT<float>::max == std::numeric_limits<float>::max() );
STATIC_REQUIRE(bx::LimitsT<double>::min == std::numeric_limits<double>::lowest() );
STATIC_REQUIRE(bx::LimitsT<double>::max == std::numeric_limits<double>::max() );
STATIC_REQUIRE(bx::kFloatSmallest == std::numeric_limits<float>::min() );
STATIC_REQUIRE(bx::kDoubleSmallest == std::numeric_limits<double>::min() );
}
Reference in New Issue View Git Blame Copy Permalink