summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/bx/tests/math_test.cpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/bx/tests/math_test.cpp')
-rw-r--r--3rdparty/bx/tests/math_test.cpp288
1 files changed, 245 insertions, 43 deletions
diff --git a/3rdparty/bx/tests/math_test.cpp b/3rdparty/bx/tests/math_test.cpp
index 511655940df..f2e5c19b974 100644
--- a/3rdparty/bx/tests/math_test.cpp
+++ b/3rdparty/bx/tests/math_test.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright 2010-2022 Branimir Karadzic. All rights reserved.
+ * Copyright 2010-2023 Branimir Karadzic. All rights reserved.
* License: https://github.com/bkaradzic/bx/blob/master/LICENSE
*/
@@ -11,25 +11,37 @@
#include <stdint.h> // intXX_t
#include <limits.h> // UCHAR_*
-#if !BX_COMPILER_MSVC || BX_COMPILER_MSVC >= 1800
-TEST_CASE("isFinite, isInfinite, isNan", "")
+#if !BX_PLATFORM_BSD
+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) };
- REQUIRE(std::isnan(u.f) == bx::isNan(u.f) );
- REQUIRE(std::isfinite(u.f) == bx::isFinite(u.f) );
- REQUIRE(std::isinf(u.f) == bx::isInfinite(u.f) );
+
+#if BX_PLATFORM_OSX
+ BX_UNUSED(u);
+ REQUIRE(::__isnanf(u.f) == bx::isNan(u.f) );
+ REQUIRE(::__isfinitef(u.f) == bx::isFinite(u.f) );
+ REQUIRE(::__isinff(u.f) == bx::isInfinite(u.f) );
+#elif BX_COMPILER_MSVC
+ REQUIRE(!!::_isnanf(u.f) == bx::isNan(u.f));
+ REQUIRE(!!::_finitef(u.f) == bx::isFinite(u.f));
+ REQUIRE(!!::isinf(u.f) == bx::isInfinite(u.f));
+#else
+ 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_PLATFORM_OSX
}
}
-#endif // !BX_COMPILER_MSVC || BX_COMPILER_MSVC >= 1800
+#endif // !BX_PLATFORM_BSD
bool log2_test(float _a)
{
return bx::log2(_a) == bx::log(_a) * (1.0f / bx::log(2.0f) );
}
-TEST_CASE("log2", "")
+TEST_CASE("log2", "[math][libm]")
{
log2_test(0.0f);
log2_test(256.0f);
@@ -62,27 +74,146 @@ TEST_CASE("log2", "")
REQUIRE(8 == bx::log2(256) );
}
-TEST_CASE("libm", "")
+BX_PRAGMA_DIAGNOSTIC_PUSH();
+BX_PRAGMA_DIAGNOSTIC_IGNORED_MSVC(4723) // potential divide by 0
+
+TEST_CASE("rsqrt", "[math][libm]")
{
bx::WriterI* writer = bx::getNullOut();
bx::Error err;
+ // rsqrtRef
+ 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
+ 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.0f));
+ REQUIRE(bx::isEqual(bx::sqrtSimd(1.0f), ::sqrtf(1.0f), 0.0f));
+
+ 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.0f));
+ REQUIRE(bx::isEqual(bx::sqrt(1.0f), ::sqrtf(1.0f), 0.0f));
+
+ 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]")
+{
REQUIRE(1389.0f == bx::abs(-1389.0f) );
REQUIRE(1389.0f == bx::abs( 1389.0f) );
REQUIRE( 0.0f == bx::abs(-0.0f) );
REQUIRE( 0.0f == bx::abs( 0.0f) );
+}
+TEST_CASE("mod", "[math][libm]")
+{
REQUIRE(389.0f == bx::mod(1389.0f, 1000.0f) );
+}
+TEST_CASE("floor", "[math][libm]")
+{
REQUIRE( 13.0f == bx::floor( 13.89f) );
REQUIRE(-14.0f == bx::floor(-13.89f) );
+}
+
+TEST_CASE("ceil", "[math][libm]")
+{
REQUIRE( 14.0f == bx::ceil( 13.89f) );
REQUIRE(-13.0f == bx::ceil( -13.89f) );
+}
+TEST_CASE("trunc", "[math][libm]")
+{
REQUIRE( 13.0f == bx::trunc( 13.89f) );
REQUIRE(-13.0f == bx::trunc(-13.89f) );
+}
+
+TEST_CASE("fract", "[math][libm]")
+{
REQUIRE(bx::isEqual( 0.89f, bx::fract( 13.89f), 0.000001f) );
REQUIRE(bx::isEqual(-0.89f, bx::fract(-13.89f), 0.000001f) );
+}
+
+TEST_CASE("ldexp", "[math][libm]")
+{
+ bx::WriterI* writer = bx::getNullOut();
+ bx::Error err;
for (int32_t yy = -10; yy < 10; ++yy)
{
@@ -92,6 +223,12 @@ TEST_CASE("libm", "")
REQUIRE(bx::isEqual(bx::ldexp(xx, yy), ::ldexpf(xx, yy), 0.00001f) );
}
}
+}
+
+TEST_CASE("exp", "[math][libm]")
+{
+ bx::WriterI* writer = bx::getNullOut();
+ bx::Error err;
for (float xx = -80.0f; xx < 80.0f; xx += 0.1f)
{
@@ -99,27 +236,12 @@ TEST_CASE("libm", "")
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::exp(xx), ::expf(xx), 0.00001f) );
}
+}
- for (float xx = 0.0f; 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) );
- }
-
- 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) );
- }
+TEST_CASE("pow", "[math][libm]")
+{
+ bx::WriterI* writer = bx::getNullOut();
+ bx::Error err;
for (float xx = -100.0f; xx < 100.0f; xx += 0.1f)
{
@@ -127,6 +249,12 @@ TEST_CASE("libm", "")
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::pow(1.389f, xx), ::powf(1.389f, xx), 0.00001f) );
}
+}
+
+TEST_CASE("asin", "[math][libm]")
+{
+ bx::WriterI* writer = bx::getNullOut();
+ bx::Error err;
for (float xx = -1.0f; xx < 1.0f; xx += 0.001f)
{
@@ -134,6 +262,12 @@ TEST_CASE("libm", "")
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::asin(xx), ::asinf(xx), 0.0001f) );
}
+}
+
+TEST_CASE("sin", "[math][libm]")
+{
+ bx::WriterI* writer = bx::getNullOut();
+ bx::Error err;
for (float xx = -100.0f; xx < 100.0f; xx += 0.1f)
{
@@ -148,6 +282,12 @@ TEST_CASE("libm", "")
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::sin(xx), ::sinf(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)
{
@@ -155,6 +295,12 @@ TEST_CASE("libm", "")
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::sinh(xx), ::sinhf(xx), 0.00001f) );
}
+}
+
+TEST_CASE("acos", "[math][libm]")
+{
+ bx::WriterI* writer = bx::getNullOut();
+ bx::Error err;
for (float xx = -1.0f; xx < 1.0f; xx += 0.001f)
{
@@ -162,6 +308,12 @@ TEST_CASE("libm", "")
REQUIRE(err.isOk() );
REQUIRE(bx::isEqual(bx::acos(xx), ::acosf(xx), 0.0001f) );
}
+}
+
+TEST_CASE("cos", "[math][libm]")
+{
+ bx::WriterI* writer = bx::getNullOut();
+ bx::Error err;
for (float xx = -100.0f; xx < 100.0f; xx += 0.1f)
{
@@ -176,6 +328,12 @@ TEST_CASE("libm", "")
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)
{
@@ -183,6 +341,12 @@ TEST_CASE("libm", "")
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)
{
@@ -190,6 +354,12 @@ TEST_CASE("libm", "")
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)
{
@@ -199,7 +369,7 @@ TEST_CASE("libm", "")
}
}
-TEST_CASE("atan2", "")
+TEST_CASE("atan2", "[math][libm]")
{
bx::WriterI* writer = bx::getNullOut();
bx::Error err;
@@ -219,24 +389,47 @@ TEST_CASE("atan2", "")
}
}
-TEST_CASE("sign", "")
+TEST_CASE("sign", "[math][libm]")
{
- REQUIRE(-1 == bx::sign(-0.1389f) );
- REQUIRE( 0 == bx::sign( 0.0000f) );
- REQUIRE( 1 == bx::sign( 0.1389f) );
+ STATIC_REQUIRE(-1 == bx::sign(-0.1389f) );
+ STATIC_REQUIRE( 0 == bx::sign( 0.0000f) );
+ STATIC_REQUIRE( 1 == bx::sign( 0.1389f) );
+
+ REQUIRE(-1 == bx::sign(-bx::kFloatInfinity) );
+ 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.1389f) );
+
+ REQUIRE( bx::signbit(-bx::kFloatInfinity) );
+ REQUIRE(!bx::signbit( bx::kFloatInfinity) );
}
-TEST_CASE("ToBits", "")
+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) );
+
+ REQUIRE(-bx::kFloatInfinity == bx::copysign(bx::kFloatInfinity, -1389) );
+}
+
+TEST_CASE("bitsToFloat, floatToBits, bitsToDouble, doubleToBits", "[math]")
{
REQUIRE(UINT32_C(0x12345678) == bx::floatToBits( bx::bitsToFloat( UINT32_C(0x12345678) ) ) );
REQUIRE(UINT64_C(0x123456789abcdef0) == bx::doubleToBits(bx::bitsToDouble(UINT32_C(0x123456789abcdef0) ) ) );
}
-TEST_CASE("lerp", "")
+TEST_CASE("lerp", "[math]")
{
REQUIRE(1389.0f == bx::lerp(1389.0f, 1453.0f, 0.0f) );
REQUIRE(1453.0f == bx::lerp(1389.0f, 1453.0f, 1.0f) );
- REQUIRE(0.5f == bx::lerp(0.0f, 1.0f, 0.5f) );
+ REQUIRE( 0.5f == bx::lerp( 0.0f, 1.0f, 0.5f) );
+ REQUIRE( 0.0f == bx::lerp( 0.0f, 0.0f, 0.5f) );
}
void mtxCheck(const float* _a, const float* _b)
@@ -268,16 +461,25 @@ void mtxCheck(const float* _a, const float* _b)
}
}
-TEST_CASE("quaternion", "")
+TEST_CASE("vec3", "[math][vec3]")
+{
+ bx::Vec3 normalized = bx::normalize({0.0f, 1.0f, 0.0f});
+ REQUIRE(bx::isEqual(normalized, {0.0f, 1.0f, 0.0f}, 0.0f) );
+
+ float length = bx::length(normalized);
+ REQUIRE(bx::isEqual(length, 1.0f, 0.0f) );
+}
+
+TEST_CASE("quaternion", "[math][quaternion]")
{
float mtxQ[16];
float mtx[16];
- bx::Quaternion quat = bx::init::Identity;
- bx::Quaternion q2 = bx::init::None;
+ bx::Quaternion quat = bx::InitIdentity;
+ bx::Quaternion q2 = bx::InitNone;
- bx::Vec3 axis = bx::init::None;
- bx::Vec3 euler = bx::init::None;
+ bx::Vec3 axis = bx::InitNone;
+ bx::Vec3 euler = bx::InitNone;
float angle;
bx::mtxFromQuaternion(mtxQ, quat);
@@ -337,7 +539,7 @@ TEST_CASE("quaternion", "")
}
}
-TEST_CASE("limits", "")
+TEST_CASE("limits", "[math]")
{
STATIC_REQUIRE(bx::LimitsT<int8_t>::min == INT8_MIN);
STATIC_REQUIRE(bx::LimitsT<int8_t>::max == INT8_MAX);