BlackMATov/vmath.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/vmath.hpp.git synced 2025-12-15 04:35:25 +07:00
Code Issues Packages Projects Releases Wiki Activity

support "no-exceptions" environment #8

Browse Source
This commit is contained in:
BlackMATov
2021-02-13 13:55:37 +07:00
parent 9da099fabf
commit 81e1245d38
13 changed files with 1013 additions and 1005 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
untests/doctest/doctest.hpp
View File

@@ -2,10 +2,10 @@
#include "doctest.h"
#define STATIC_REQUIRE(...)\
#define STATIC_CHECK(...)\
static_assert(__VA_ARGS__, #__VA_ARGS__);\
REQUIRE(__VA_ARGS__);
CHECK(__VA_ARGS__);
#define STATIC_REQUIRE_FALSE(...)\
#define STATIC_CHECK_FALSE(...)\
static_assert(!(__VA_ARGS__), "!(" #__VA_ARGS__ ")");\
REQUIRE(!(__VA_ARGS__));
CHECK(!(__VA_ARGS__));

334
untests/vmath_ext_tests.cpp
View File

@@ -22,138 +22,138 @@ namespace
}
TEST_CASE("vmath/ext/units") {
STATIC_REQUIRE(zero2<int> == int2(0,0));
STATIC_REQUIRE(zero3<int> == int3(0,0,0));
STATIC_REQUIRE(zero4<int> == int4(0,0,0,0));
STATIC_CHECK(zero2<int> == int2(0,0));
STATIC_CHECK(zero3<int> == int3(0,0,0));
STATIC_CHECK(zero4<int> == int4(0,0,0,0));
STATIC_REQUIRE(unit2<int> == int2(1,1));
STATIC_REQUIRE(unit2_x<int> == int2(1,0));
STATIC_REQUIRE(unit2_y<int> == int2(0,1));
STATIC_CHECK(unit2<int> == int2(1,1));
STATIC_CHECK(unit2_x<int> == int2(1,0));
STATIC_CHECK(unit2_y<int> == int2(0,1));
STATIC_REQUIRE(unit3<int> == int3(1,1,1));
STATIC_REQUIRE(unit3_x<int> == int3(1,0,0));
STATIC_REQUIRE(unit3_y<int> == int3(0,1,0));
STATIC_REQUIRE(unit3_z<int> == int3(0,0,1));
STATIC_CHECK(unit3<int> == int3(1,1,1));
STATIC_CHECK(unit3_x<int> == int3(1,0,0));
STATIC_CHECK(unit3_y<int> == int3(0,1,0));
STATIC_CHECK(unit3_z<int> == int3(0,0,1));
STATIC_REQUIRE(unit4<int> == int4(1,1,1,1));
STATIC_REQUIRE(unit4_x<int> == int4(1,0,0,0));
STATIC_REQUIRE(unit4_y<int> == int4(0,1,0,0));
STATIC_REQUIRE(unit4_z<int> == int4(0,0,1,0));
STATIC_REQUIRE(unit4_w<int> == int4(0,0,0,1));
STATIC_CHECK(unit4<int> == int4(1,1,1,1));
STATIC_CHECK(unit4_x<int> == int4(1,0,0,0));
STATIC_CHECK(unit4_y<int> == int4(0,1,0,0));
STATIC_CHECK(unit4_z<int> == int4(0,0,1,0));
STATIC_CHECK(unit4_w<int> == int4(0,0,0,1));
STATIC_REQUIRE(zero2x2<int> == int2x2(0,0,0,0));
STATIC_REQUIRE(zero3x3<int> == int3x3(0,0,0,0,0,0,0,0,0));
STATIC_REQUIRE(zero4x4<int> == int4x4(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0));
STATIC_CHECK(zero2x2<int> == int2x2(0,0,0,0));
STATIC_CHECK(zero3x3<int> == int3x3(0,0,0,0,0,0,0,0,0));
STATIC_CHECK(zero4x4<int> == int4x4(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0));
STATIC_REQUIRE(unit2x2<int> == int2x2(1,1,1,1));
STATIC_REQUIRE(unit3x3<int> == int3x3(1,1,1,1,1,1,1,1,1));
STATIC_REQUIRE(unit4x4<int> == int4x4(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1));
STATIC_CHECK(unit2x2<int> == int2x2(1,1,1,1));
STATIC_CHECK(unit3x3<int> == int3x3(1,1,1,1,1,1,1,1,1));
STATIC_CHECK(unit4x4<int> == int4x4(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1));
STATIC_REQUIRE(identity2x2<int> == int2x2());
STATIC_REQUIRE(identity3x3<int> == int3x3());
STATIC_REQUIRE(identity4x4<int> == int4x4());
STATIC_CHECK(identity2x2<int> == int2x2());
STATIC_CHECK(identity3x3<int> == int3x3());
STATIC_CHECK(identity4x4<int> == int4x4());
}
TEST_CASE("vmath/ext/hash") {
SUBCASE("vector") {
REQUIRE(std::hash<int2>{}({1,2}) == std::hash<int2>{}({1,2}));
REQUIRE_FALSE(std::hash<int2>{}({1,2}) == std::hash<int2>{}({2,1}));
CHECK(std::hash<int2>{}({1,2}) == std::hash<int2>{}({1,2}));
CHECK_FALSE(std::hash<int2>{}({1,2}) == std::hash<int2>{}({2,1}));
REQUIRE(std::hash<int3>{}({1,2,3}) == std::hash<int3>{}({1,2,3}));
REQUIRE_FALSE(std::hash<int3>{}({1,2,3}) == std::hash<int3>{}({3,2,1}));
CHECK(std::hash<int3>{}({1,2,3}) == std::hash<int3>{}({1,2,3}));
CHECK_FALSE(std::hash<int3>{}({1,2,3}) == std::hash<int3>{}({3,2,1}));
REQUIRE(std::hash<int4>{}({1,2,3,4}) == std::hash<int4>{}({1,2,3,4}));
REQUIRE_FALSE(std::hash<int4>{}({1,2,3,4}) == std::hash<int4>{}({3,2,1,4}));
CHECK(std::hash<int4>{}({1,2,3,4}) == std::hash<int4>{}({1,2,3,4}));
CHECK_FALSE(std::hash<int4>{}({1,2,3,4}) == std::hash<int4>{}({3,2,1,4}));
{
std::set<int2> s;
s.insert(int2(1,2));
REQUIRE(s.count(int2(1,2)) > 0);
REQUIRE_FALSE(s.count(int2(1,1)) > 0);
CHECK(s.count(int2(1,2)) > 0);
CHECK_FALSE(s.count(int2(1,1)) > 0);
}
{
std::map<int2, int> s;
s.emplace(int2(1,2),3);
s.emplace(int2(2,3),5);
REQUIRE(s[int2(1,2)] == 3);
REQUIRE(s[int2(2,3)] == 5);
CHECK(s[int2(1,2)] == 3);
CHECK(s[int2(2,3)] == 5);
}
{
std::unordered_set<int2> s;
s.insert(int2(1,2));
REQUIRE(s.count(int2(1,2)) > 0);
REQUIRE_FALSE(s.count(int2(1,1)) > 0);
CHECK(s.count(int2(1,2)) > 0);
CHECK_FALSE(s.count(int2(1,1)) > 0);
}
{
std::unordered_map<int2, int> s;
s.emplace(int2(1,2),3);
s.emplace(int2(2,3),5);
REQUIRE(s[int2(1,2)] == 3);
REQUIRE(s[int2(2,3)] == 5);
CHECK(s[int2(1,2)] == 3);
CHECK(s[int2(2,3)] == 5);
}
}
SUBCASE("matrix") {
REQUIRE(std::hash<int2x2>{}({1,2,3,4}) == std::hash<int2x2>{}({1,2,3,4}));
REQUIRE_FALSE(std::hash<int2x2>{}({1,2,3,4}) == std::hash<int2x2>{}({1,2,4,3}));
CHECK(std::hash<int2x2>{}({1,2,3,4}) == std::hash<int2x2>{}({1,2,3,4}));
CHECK_FALSE(std::hash<int2x2>{}({1,2,3,4}) == std::hash<int2x2>{}({1,2,4,3}));
{
std::set<int2x2> s;
s.insert(int2x2(1,2,3,4));
REQUIRE(s.count(int2x2(1,2,3,4)) > 0);
REQUIRE_FALSE(s.count(int2x2(1,1,1,1)) > 0);
CHECK(s.count(int2x2(1,2,3,4)) > 0);
CHECK_FALSE(s.count(int2x2(1,1,1,1)) > 0);
}
{
std::map<int2x2, int> s;
s.emplace(int2x2(1,2,3,4),3);
s.emplace(int2x2(2,3,4,5),5);
REQUIRE(s[int2x2(1,2,3,4)] == 3);
REQUIRE(s[int2x2(2,3,4,5)] == 5);
CHECK(s[int2x2(1,2,3,4)] == 3);
CHECK(s[int2x2(2,3,4,5)] == 5);
}
{
std::unordered_set<int2x2> s;
s.insert(int2x2(1,2,3,4));
REQUIRE(s.count(int2x2(1,2,3,4)) > 0);
REQUIRE_FALSE(s.count(int2x2(1,1,1,1)) > 0);
CHECK(s.count(int2x2(1,2,3,4)) > 0);
CHECK_FALSE(s.count(int2x2(1,1,1,1)) > 0);
}
{
std::unordered_map<int2x2, int> s;
s.emplace(int2x2(1,2,3,4),3);
s.emplace(int2x2(2,3,4,5),5);
REQUIRE(s[int2x2(1,2,3,4)] == 3);
REQUIRE(s[int2x2(2,3,4,5)] == 5);
CHECK(s[int2x2(1,2,3,4)] == 3);
CHECK(s[int2x2(2,3,4,5)] == 5);
}
}
SUBCASE("quaternion") {
REQUIRE(std::hash<qfloat>{}({1,2,3,4}) == std::hash<qfloat>{}({1,2,3,4}));
REQUIRE_FALSE(std::hash<qfloat>{}({1,2,3,4}) == std::hash<qfloat>{}({3,2,1,4}));
CHECK(std::hash<qfloat>{}({1,2,3,4}) == std::hash<qfloat>{}({1,2,3,4}));
CHECK_FALSE(std::hash<qfloat>{}({1,2,3,4}) == std::hash<qfloat>{}({3,2,1,4}));
{
std::set<qua<int>> s;
s.insert(qua(1,2,3,4));
REQUIRE(s.count(qua(1,2,3,4)) > 0);
REQUIRE_FALSE(s.count(qua(1,1,1,1)) > 0);
CHECK(s.count(qua(1,2,3,4)) > 0);
CHECK_FALSE(s.count(qua(1,1,1,1)) > 0);
}
{
std::map<qua<int>, int> s;
s.emplace(qua(1,2,3,4),3);
s.emplace(qua(2,3,4,5),5);
REQUIRE(s[qua(1,2,3,4)] == 3);
REQUIRE(s[qua(2,3,4,5)] == 5);
CHECK(s[qua(1,2,3,4)] == 3);
CHECK(s[qua(2,3,4,5)] == 5);
}
{
std::unordered_set<qua<int>> s;
s.insert(qua(1,2,3,4));
REQUIRE(s.count(qua(1,2,3,4)) > 0);
REQUIRE_FALSE(s.count(qua(1,1,1,1)) > 0);
CHECK(s.count(qua(1,2,3,4)) > 0);
CHECK_FALSE(s.count(qua(1,1,1,1)) > 0);
}
{
std::unordered_map<qua<int>, int> s;
s.emplace(qua(1,2,3,4),3);
s.emplace(qua(2,3,4,5),5);
REQUIRE(s[qua(1,2,3,4)] == 3);
REQUIRE(s[qua(2,3,4,5)] == 5);
CHECK(s[qua(1,2,3,4)] == 3);
CHECK(s[qua(2,3,4,5)] == 5);
}
}
}
@@ -161,114 +161,114 @@ TEST_CASE("vmath/ext/hash") {
TEST_CASE("vmath/ext/cast") {
SUBCASE("cast_to") {
constexpr auto i = cast_to<int>(1.5f);
STATIC_REQUIRE(i == 1);
STATIC_REQUIRE(std::is_same_v<decltype(i), const int>);
STATIC_CHECK(i == 1);
STATIC_CHECK(std::is_same_v<decltype(i), const int>);
constexpr auto v = cast_to<int>(float2(1.5f));
STATIC_REQUIRE(v == int2(1));
STATIC_REQUIRE(std::is_same_v<decltype(v)::component_type, int>);
STATIC_CHECK(v == int2(1));
STATIC_CHECK(std::is_same_v<decltype(v)::component_type, int>);
constexpr auto m = cast_to<int>(float2x2(1.5f));
STATIC_REQUIRE(m == int2x2(1));
STATIC_REQUIRE(std::is_same_v<decltype(m)::row_type, int2>);
STATIC_CHECK(m == int2x2(1));
STATIC_CHECK(std::is_same_v<decltype(m)::row_type, int2>);
constexpr auto q = cast_to<int>(qfloat(1.5f, 2.2f, 3.6f, 4.5f));
STATIC_REQUIRE(q == qua(1,2,3,4));
STATIC_REQUIRE(std::is_same_v<decltype(q)::component_type, int>);
STATIC_CHECK(q == qua(1,2,3,4));
STATIC_CHECK(std::is_same_v<decltype(q)::component_type, int>);
}
}
TEST_CASE("vmath/ext/access") {
SUBCASE("component") {
STATIC_REQUIRE(component(int2{1,2}, 0) == 1);
STATIC_REQUIRE(component(int2{1,2}, 1) == 2);
STATIC_CHECK(component(int2{1,2}, 0) == 1);
STATIC_CHECK(component(int2{1,2}, 1) == 2);
STATIC_REQUIRE(component(int2{0,0}, 0, 1) == int2{1,0});
STATIC_REQUIRE(component(int2{0,0}, 1, 2) == int2{0,2});
STATIC_CHECK(component(int2{0,0}, 0, 1) == int2{1,0});
STATIC_CHECK(component(int2{0,0}, 1, 2) == int2{0,2});
}
SUBCASE("row") {
STATIC_REQUIRE(row(int2x2(1,2,3,4), 0) == int2(1,2));
STATIC_REQUIRE(row(int2x2(1,2,3,4), 1) == int2(3,4));
STATIC_CHECK(row(int2x2(1,2,3,4), 0) == int2(1,2));
STATIC_CHECK(row(int2x2(1,2,3,4), 1) == int2(3,4));
STATIC_REQUIRE(row(int2x2(), 0, {1,2}) == int2x2(1,2,0,1));
STATIC_REQUIRE(row(int2x2(), 1, {3,4}) == int2x2(1,0,3,4));
STATIC_CHECK(row(int2x2(), 0, {1,2}) == int2x2(1,2,0,1));
STATIC_CHECK(row(int2x2(), 1, {3,4}) == int2x2(1,0,3,4));
}
SUBCASE("column") {
STATIC_REQUIRE(column(int2x2(1,2,3,4), 0) == int2(1,3));
STATIC_REQUIRE(column(int2x2(1,2,3,4), 1) == int2(2,4));
STATIC_CHECK(column(int2x2(1,2,3,4), 0) == int2(1,3));
STATIC_CHECK(column(int2x2(1,2,3,4), 1) == int2(2,4));
STATIC_REQUIRE(column(int2x2(), 0, {2,3}) == int2x2(2,0,3,1));
STATIC_REQUIRE(column(int2x2(), 1, {3,4}) == int2x2(1,3,0,4));
STATIC_CHECK(column(int2x2(), 0, {2,3}) == int2x2(2,0,3,1));
STATIC_CHECK(column(int2x2(), 1, {3,4}) == int2x2(1,3,0,4));
}
SUBCASE("real") {
STATIC_REQUIRE(real(qua{1,2,3,4}) == 4);
STATIC_REQUIRE(real(qua{1,2,3,4}, 5) == qua{1,2,3,5});
STATIC_CHECK(real(qua{1,2,3,4}) == 4);
STATIC_CHECK(real(qua{1,2,3,4}, 5) == qua{1,2,3,5});
}
SUBCASE("imag") {
STATIC_REQUIRE(imag(qua{1,2,3,4}) == vec{1,2,3});
STATIC_REQUIRE(imag(qua{1,2,3,4}, {4,3,2}) == qua{4,3,2,4});
STATIC_CHECK(imag(qua{1,2,3,4}) == vec{1,2,3});
STATIC_CHECK(imag(qua{1,2,3,4}, {4,3,2}) == qua{4,3,2,4});
}
}
TEST_CASE("vmath/ext/matrix_transform") {
SUBCASE("translate") {
STATIC_REQUIRE(float3(2.f,3.f,1.f) * translate(float2{1.f,2.f}) == uapprox3(3.f,5.f,1.f));
STATIC_REQUIRE(float3(2.f,3.f,1.f) * translate(translate(float2{1.f,2.f}), float2{1.f,2.f}) == uapprox3(4.f,7.f,1.f));
STATIC_CHECK(float3(2.f,3.f,1.f) * translate(float2{1.f,2.f}) == uapprox3(3.f,5.f,1.f));
STATIC_CHECK(float3(2.f,3.f,1.f) * translate(translate(float2{1.f,2.f}), float2{1.f,2.f}) == uapprox3(4.f,7.f,1.f));
STATIC_REQUIRE(float4(2.f,3.f,4.f,1.f) * translate(float3{1.f,2.f,3.f}) == uapprox4(3.f,5.f,7.f,1.f));
STATIC_REQUIRE(float4(2.f,3.f,4.f,1.f) * translate(translate(float3{1.f,2.f,3.f}), float3{1.f,2.f,3.f}) == uapprox4(4.f,7.f,10.f,1.f));
STATIC_CHECK(float4(2.f,3.f,4.f,1.f) * translate(float3{1.f,2.f,3.f}) == uapprox4(3.f,5.f,7.f,1.f));
STATIC_CHECK(float4(2.f,3.f,4.f,1.f) * translate(translate(float3{1.f,2.f,3.f}), float3{1.f,2.f,3.f}) == uapprox4(4.f,7.f,10.f,1.f));
}
SUBCASE("rotate") {
REQUIRE(float4(0.f,1.f,0.f,1.f) * rotate_x(pi_2) == uapprox4(0.f,0.f,1.f,1.f));
REQUIRE(float4(0.f,0.f,1.f,1.f) * rotate_y(pi_2) == uapprox4(1.f,0.f,0.f,1.f));
REQUIRE(float4(1.f,0.f,0.f,1.f) * rotate_z(pi_2) == uapprox4(0.f,1.f,0.f,1.f));
CHECK(float4(0.f,1.f,0.f,1.f) * rotate_x(pi_2) == uapprox4(0.f,0.f,1.f,1.f));
CHECK(float4(0.f,0.f,1.f,1.f) * rotate_y(pi_2) == uapprox4(1.f,0.f,0.f,1.f));
CHECK(float4(1.f,0.f,0.f,1.f) * rotate_z(pi_2) == uapprox4(0.f,1.f,0.f,1.f));
REQUIRE(float4(0.f,1.f,0.f,1.f) * rotate_x(rotate_x(pi_4),pi_4) == uapprox4(0.f,0.f,1.f,1.f));
REQUIRE(float4(0.f,0.f,1.f,1.f) * rotate_y(rotate_y(pi_4),pi_4) == uapprox4(1.f,0.f,0.f,1.f));
REQUIRE(float4(1.f,0.f,0.f,1.f) * rotate_z(rotate_z(pi_4),pi_4) == uapprox4(0.f,1.f,0.f,1.f));
CHECK(float4(0.f,1.f,0.f,1.f) * rotate_x(rotate_x(pi_4),pi_4) == uapprox4(0.f,0.f,1.f,1.f));
CHECK(float4(0.f,0.f,1.f,1.f) * rotate_y(rotate_y(pi_4),pi_4) == uapprox4(1.f,0.f,0.f,1.f));
CHECK(float4(1.f,0.f,0.f,1.f) * rotate_z(rotate_z(pi_4),pi_4) == uapprox4(0.f,1.f,0.f,1.f));
REQUIRE(float3(2.f,3.f,1.f) * rotate(pi) == uapprox3(-2.f,-3.f,1.f));
REQUIRE(float4(2.f,3.f,4.f,1.f) * rotate(pi,{0.f,0.f,1.f}) == uapprox4(-2.f,-3.f,4.f,1.f));
REQUIRE(float4(2.f,3.f,4.f,1.f) * rotate(pi,float3{0.f,0.f,1.f}) == uapprox4(-2.f,-3.f,4.f,1.f));
REQUIRE(float4(2.f,3.f,4.f,1.f) * rotate(qrotate(pi,float3{0.f,0.f,1.f})) == uapprox4(-2.f,-3.f,4.f,1.f));
CHECK(float3(2.f,3.f,1.f) * rotate(pi) == uapprox3(-2.f,-3.f,1.f));
CHECK(float4(2.f,3.f,4.f,1.f) * rotate(pi,{0.f,0.f,1.f}) == uapprox4(-2.f,-3.f,4.f,1.f));
CHECK(float4(2.f,3.f,4.f,1.f) * rotate(pi,float3{0.f,0.f,1.f}) == uapprox4(-2.f,-3.f,4.f,1.f));
CHECK(float4(2.f,3.f,4.f,1.f) * rotate(qrotate(pi,float3{0.f,0.f,1.f})) == uapprox4(-2.f,-3.f,4.f,1.f));
REQUIRE(float3(2.f,3.f,1.f) * rotate(rotate(pi_2),pi_2) == uapprox3(-2.f,-3.f,1.f));
REQUIRE(float4(2.f,3.f,4.f,1.f) * rotate(rotate(pi_2,{0.f,0.f,1.f}),pi_2,{0.f,0.f,1.f}) == uapprox4(-2.f,-3.f,4.f,1.f));
REQUIRE(float4(2.f,3.f,4.f,1.f) * rotate(rotate(pi_2,float3{0.f,0.f,1.f}),pi_2,float3{0.f,0.f,1.f}) == uapprox4(-2.f,-3.f,4.f,1.f));
REQUIRE(float4(2.f,3.f,4.f,1.f) * rotate(rotate(qrotate(pi_2,float3{0.f,0.f,1.f})),qrotate(pi_2,float3{0.f,0.f,1.f})) == uapprox4(-2.f,-3.f,4.f,1.f));
CHECK(float3(2.f,3.f,1.f) * rotate(rotate(pi_2),pi_2) == uapprox3(-2.f,-3.f,1.f));
CHECK(float4(2.f,3.f,4.f,1.f) * rotate(rotate(pi_2,{0.f,0.f,1.f}),pi_2,{0.f,0.f,1.f}) == uapprox4(-2.f,-3.f,4.f,1.f));
CHECK(float4(2.f,3.f,4.f,1.f) * rotate(rotate(pi_2,float3{0.f,0.f,1.f}),pi_2,float3{0.f,0.f,1.f}) == uapprox4(-2.f,-3.f,4.f,1.f));
CHECK(float4(2.f,3.f,4.f,1.f) * rotate(rotate(qrotate(pi_2,float3{0.f,0.f,1.f})),qrotate(pi_2,float3{0.f,0.f,1.f})) == uapprox4(-2.f,-3.f,4.f,1.f));
}
SUBCASE("scale") {
STATIC_REQUIRE(float3(2.f,3.f,1.f) * scale(float2{2.f,3.f}) == uapprox3(4.f,9.f,1.f));
STATIC_REQUIRE(float4(2.f,3.f,4.f,1.f) * scale(float3{2.f,3.f,4.f}) == uapprox4(4.f,9.f,16.f,1.f));
STATIC_REQUIRE(float4(2.f,3.f,4.f,1.f) * scale(float3{2.f,3.f,4.f}) == uapprox4(4.f,9.f,16.f,1.f));
STATIC_CHECK(float3(2.f,3.f,1.f) * scale(float2{2.f,3.f}) == uapprox3(4.f,9.f,1.f));
STATIC_CHECK(float4(2.f,3.f,4.f,1.f) * scale(float3{2.f,3.f,4.f}) == uapprox4(4.f,9.f,16.f,1.f));
STATIC_CHECK(float4(2.f,3.f,4.f,1.f) * scale(float3{2.f,3.f,4.f}) == uapprox4(4.f,9.f,16.f,1.f));
STATIC_REQUIRE(float3(2.f,3.f,1.f) * scale(scale(float2{2.f,2.f}), {2.f,3.f}) == uapprox3(8.f,18.f,1.f));
STATIC_REQUIRE(float4(2.f,3.f,4.f,1.f) * scale(scale(float3{2.f,2.f,2.f}), {2.f,3.f,4.f}) == uapprox4(8.f,18.f,32.f,1.f));
STATIC_REQUIRE(float4(2.f,3.f,4.f,1.f) * scale(scale(float3{2.f,2.f,2.f}), float3{2.f,3.f,4.f}) == uapprox4(8.f,18.f,32.f,1.f));
STATIC_CHECK(float3(2.f,3.f,1.f) * scale(scale(float2{2.f,2.f}), {2.f,3.f}) == uapprox3(8.f,18.f,1.f));
STATIC_CHECK(float4(2.f,3.f,4.f,1.f) * scale(scale(float3{2.f,2.f,2.f}), {2.f,3.f,4.f}) == uapprox4(8.f,18.f,32.f,1.f));
STATIC_CHECK(float4(2.f,3.f,4.f,1.f) * scale(scale(float3{2.f,2.f,2.f}), float3{2.f,3.f,4.f}) == uapprox4(8.f,18.f,32.f,1.f));
}
SUBCASE("shear") {
STATIC_REQUIRE(float3(2.f,3.f,1.f) * shear_x(0.f) == uapprox3(2.f,3.f,1.f));
STATIC_REQUIRE(float3(2.f,3.f,1.f) * shear_x(1.f) == uapprox3(5.f,3.f,1.f));
STATIC_REQUIRE(float3(2.f,3.f,1.f) * shear_x(2.f) == uapprox3(8.f,3.f,1.f));
STATIC_REQUIRE(float3(2.f,3.f,1.f) * shear_x(shear_x(1.f),1.f) == uapprox3(8.f,3.f,1.f));
STATIC_CHECK(float3(2.f,3.f,1.f) * shear_x(0.f) == uapprox3(2.f,3.f,1.f));
STATIC_CHECK(float3(2.f,3.f,1.f) * shear_x(1.f) == uapprox3(5.f,3.f,1.f));
STATIC_CHECK(float3(2.f,3.f,1.f) * shear_x(2.f) == uapprox3(8.f,3.f,1.f));
STATIC_CHECK(float3(2.f,3.f,1.f) * shear_x(shear_x(1.f),1.f) == uapprox3(8.f,3.f,1.f));
STATIC_REQUIRE(float3(2.f,3.f,1.f) * shear_y(0.f) == uapprox3(2.f,3.f,1.f));
STATIC_REQUIRE(float3(2.f,3.f,1.f) * shear_y(1.f) == uapprox3(2.f,5.f,1.f));
STATIC_REQUIRE(float3(2.f,3.f,1.f) * shear_y(2.f) == uapprox3(2.f,7.f,1.f));
STATIC_REQUIRE(float3(2.f,3.f,1.f) * shear_y(shear_y(1.f),1.f) == uapprox3(2.f,7.f,1.f));
STATIC_CHECK(float3(2.f,3.f,1.f) * shear_y(0.f) == uapprox3(2.f,3.f,1.f));
STATIC_CHECK(float3(2.f,3.f,1.f) * shear_y(1.f) == uapprox3(2.f,5.f,1.f));
STATIC_CHECK(float3(2.f,3.f,1.f) * shear_y(2.f) == uapprox3(2.f,7.f,1.f));
STATIC_CHECK(float3(2.f,3.f,1.f) * shear_y(shear_y(1.f),1.f) == uapprox3(2.f,7.f,1.f));
STATIC_REQUIRE(float3(2.f,3.f,1.f) * shear(float2(0.f,0.f)) == uapprox3(2.f,3.f,1.f));
STATIC_REQUIRE(float3(2.f,3.f,1.f) * shear(float2(2.f,0.f)) == uapprox3(8.f,3.f,1.f));
STATIC_REQUIRE(float3(2.f,3.f,1.f) * shear(float2(0.f,2.f)) == uapprox3(2.f,7.f,1.f));
STATIC_REQUIRE(float3(2.f,3.f,1.f) * shear(shear(float2(1.f,0.f)),float2(1.f,0.f)) == uapprox3(8.f,3.f,1.f));
STATIC_REQUIRE(float3(2.f,3.f,1.f) * shear(shear(float2(0.f,1.f)),float2(0.f,1.f)) == uapprox3(2.f,7.f,1.f));
STATIC_CHECK(float3(2.f,3.f,1.f) * shear(float2(0.f,0.f)) == uapprox3(2.f,3.f,1.f));
STATIC_CHECK(float3(2.f,3.f,1.f) * shear(float2(2.f,0.f)) == uapprox3(8.f,3.f,1.f));
STATIC_CHECK(float3(2.f,3.f,1.f) * shear(float2(0.f,2.f)) == uapprox3(2.f,7.f,1.f));
STATIC_CHECK(float3(2.f,3.f,1.f) * shear(shear(float2(1.f,0.f)),float2(1.f,0.f)) == uapprox3(8.f,3.f,1.f));
STATIC_CHECK(float3(2.f,3.f,1.f) * shear(shear(float2(0.f,1.f)),float2(0.f,1.f)) == uapprox3(2.f,7.f,1.f));
}
SUBCASE("matrix look_at") {
@@ -279,26 +279,26 @@ TEST_CASE("vmath/ext/matrix_transform") {
TEST_CASE("vmath/ext/matrix_projections") {
SUBCASE("orthographic") {
REQUIRE(all(approx(
CHECK(all(approx(
orthographic_lh(800.f, 600.f, 5.f, 10.f),
scale(1.f,1.f,-1.f) * orthographic_rh(800.f, 600.f, 5.f, 10.f))));
REQUIRE(all(approx(
CHECK(all(approx(
orthographic_lh(100.f, 800.f, 50.f, 640.f, 5.f, 10.f),
scale(1.f,1.f,-1.f) * orthographic_rh(100.f, 800.f, 50.f, 640.f, 5.f, 10.f))));
}
SUBCASE("perspective") {
REQUIRE(all(approx(
CHECK(all(approx(
perspective_lh(800.f, 600.f, 5.f, 10.f),
scale(1.f,1.f,-1.f) * perspective_rh(800.f, 600.f, 5.f, 10.f))));
REQUIRE(all(approx(
CHECK(all(approx(
perspective_fov_lh(1.5f, 1.3f, 0.f, 10.f),
scale(1.f,1.f,-1.f) * perspective_fov_rh(1.5f, 1.3f, 0.f, 10.f))));
REQUIRE(all(approx(
CHECK(all(approx(
perspective_lh(100.f, 800.f, 50.f, 600.f, 5.f, 10.f),
scale(1.f,1.f,-1.f) * perspective_rh(100.f, 800.f, 50.f, 600.f, 5.f, 10.f))));
}
@@ -306,52 +306,52 @@ TEST_CASE("vmath/ext/matrix_projections") {
TEST_CASE("vmath/ext/vector_transform") {
SUBCASE("angle") {
REQUIRE(angle(float2(2.f,0.f), float2(0.f,1.f)) == uapprox(radians(90.f)));
REQUIRE(angle(float2(0.f,3.f), float2(1.f,0.f)) == uapprox(radians(90.f)));
REQUIRE(angle(float2(0.5f,0.f), float2(-1.f,0.f)) == uapprox(radians(180.f)));
REQUIRE(angle(float2(-0.2f,0.f), float2(1.f,0.f)) == uapprox(radians(180.f)));
REQUIRE(angle(float3(0.f,2.f,0.f), float3(0.f,0.f,1.f)) == uapprox(radians(90.f)));
REQUIRE(angle(float3(0.f,0.f,3.f), float3(0.f,1.f,0.f)) == uapprox(radians(90.f)));
CHECK(angle(float2(2.f,0.f), float2(0.f,1.f)) == uapprox(radians(90.f)));
CHECK(angle(float2(0.f,3.f), float2(1.f,0.f)) == uapprox(radians(90.f)));
CHECK(angle(float2(0.5f,0.f), float2(-1.f,0.f)) == uapprox(radians(180.f)));
CHECK(angle(float2(-0.2f,0.f), float2(1.f,0.f)) == uapprox(radians(180.f)));
CHECK(angle(float3(0.f,2.f,0.f), float3(0.f,0.f,1.f)) == uapprox(radians(90.f)));
CHECK(angle(float3(0.f,0.f,3.f), float3(0.f,1.f,0.f)) == uapprox(radians(90.f)));
}
SUBCASE("rotate") {
REQUIRE(rotate(float2(2.f,0.f), radians(90.f)) == uapprox2(0.f,2.f));
REQUIRE(rotate(float2(1.5f,0.f), radians(-90.f)) == uapprox2(0.f,-1.5f));
CHECK(rotate(float2(2.f,0.f), radians(90.f)) == uapprox2(0.f,2.f));
CHECK(rotate(float2(1.5f,0.f), radians(-90.f)) == uapprox2(0.f,-1.5f));
REQUIRE(rotate_x(float3(0.f,1.5f,0.f), radians(90.f)) == uapprox3(0.f,0.f,1.5f));
REQUIRE(rotate_y(float3(0.f,0.f,1.5f), radians(90.f)) == uapprox3(1.5f,0.f,0.f));
REQUIRE(rotate_z(float3(1.5f,0.f,0.f), radians(90.f)) == uapprox3(0.f,1.5f,0.f));
CHECK(rotate_x(float3(0.f,1.5f,0.f), radians(90.f)) == uapprox3(0.f,0.f,1.5f));
CHECK(rotate_y(float3(0.f,0.f,1.5f), radians(90.f)) == uapprox3(1.5f,0.f,0.f));
CHECK(rotate_z(float3(1.5f,0.f,0.f), radians(90.f)) == uapprox3(0.f,1.5f,0.f));
REQUIRE(rotate(float3(1.5f,0.f,0.f), qrotate_z(radians(90.f))) == uapprox3(0.f,1.5f,0.f));
REQUIRE(rotate(float3(1.5f,0.f,0.f), radians(90.f), float3(0,0,1)) == uapprox3(0.f,1.5f,0.f));
CHECK(rotate(float3(1.5f,0.f,0.f), qrotate_z(radians(90.f))) == uapprox3(0.f,1.5f,0.f));
CHECK(rotate(float3(1.5f,0.f,0.f), radians(90.f), float3(0,0,1)) == uapprox3(0.f,1.5f,0.f));
}
SUBCASE("project") {
STATIC_REQUIRE(project(float2(2.f, 2.f), float2(0.f, 1.f)) == uapprox2(0.f, 2.f));
STATIC_REQUIRE(project(float3(2.f, 2.f, 2.f), float3(0.f, 0.f, 1.f)) == uapprox3(0.f, 0.f, 2.f));
STATIC_CHECK(project(float2(2.f, 2.f), float2(0.f, 1.f)) == uapprox2(0.f, 2.f));
STATIC_CHECK(project(float3(2.f, 2.f, 2.f), float3(0.f, 0.f, 1.f)) == uapprox3(0.f, 0.f, 2.f));
}
SUBCASE("perpendicular") {
STATIC_REQUIRE(perpendicular(float2(2.f, 2.f), float2(0.f, 1.f)) == uapprox2(2.f, 0.f));
STATIC_REQUIRE(perpendicular(float3(2.f, 2.f, 2.f), float3(0.f, 0.f, 1.f)) == uapprox3(2.f, 2.f, 0.f));
STATIC_CHECK(perpendicular(float2(2.f, 2.f), float2(0.f, 1.f)) == uapprox2(2.f, 0.f));
STATIC_CHECK(perpendicular(float3(2.f, 2.f, 2.f), float3(0.f, 0.f, 1.f)) == uapprox3(2.f, 2.f, 0.f));
}
}
TEST_CASE("vmath/ext/quaternion_transform") {
SUBCASE("qrotate(m)") {
REQUIRE(all(approx(
CHECK(all(approx(
vec{4.f,3.f,2.f,1.f} * rotate(qrotate(float3x3(rotate(0.f, vec{1.f,2.f,3.f})))),
vec{4.f,3.f,2.f,1.f} * rotate(0.f, vec{1.f,2.f,3.f}), 0.001f)));
REQUIRE(all(approx(
CHECK(all(approx(
vec{4.f,3.f,2.f,1.f} * rotate(qrotate(float3x3(rotate(radians(12.5f), vec{1.f,2.f,3.f})))),
vec{4.f,3.f,2.f,1.f} * rotate(radians(12.5f), vec{1.f,2.f,3.f}), 0.001f)));
REQUIRE(all(approx(
CHECK(all(approx(
vec{4.f,3.f,2.f,1.f} * rotate(qrotate(float3x3(rotate(radians(-190.5f), vec{1.f,2.f,3.f})))),
vec{4.f,3.f,2.f,1.f} * rotate(radians(-190.5f), vec{1.f,2.f,3.f}), 0.001f)));
}
SUBCASE("qrotate(q, m)") {
REQUIRE(all(approx(
CHECK(all(approx(
vec{4.f,3.f,2.f} * qrotate(
qrotate(float3x3(rotate(0.f, vec{1.f,2.f,3.f}))),
float3x3(rotate(0.f, vec{3.f,2.f,1.f}))),
@@ -361,15 +361,15 @@ TEST_CASE("vmath/ext/quaternion_transform") {
}
SUBCASE("qrotate(from, to)") {
REQUIRE(+unit3_x<float> * qrotate(-unit3_x<float>, +unit3_x<float>) == uapprox3(-unit3_x<float>));
REQUIRE(-unit3_y<float> * qrotate(+unit3_y<float>, -unit3_y<float>) == uapprox3(+unit3_y<float>));
REQUIRE(+unit3_z<float> * qrotate(-unit3_z<float>, +unit3_z<float>) == uapprox3(-unit3_z<float>));
REQUIRE(vec{1.f,2.f,3.f} * qrotate(vec{1.f,2.f,3.f}, vec{-2.f,1.f,3.f}) == uapprox3(-2.f,1.f,3.f));
REQUIRE(vec{-2.f,1.f,3.f} * qrotate(vec{-2.f,1.f,3.f}, vec{1.f,2.f,3.f}) == uapprox3(1.f,2.f,3.f));
CHECK(+unit3_x<float> * qrotate(-unit3_x<float>, +unit3_x<float>) == uapprox3(-unit3_x<float>));
CHECK(-unit3_y<float> * qrotate(+unit3_y<float>, -unit3_y<float>) == uapprox3(+unit3_y<float>));
CHECK(+unit3_z<float> * qrotate(-unit3_z<float>, +unit3_z<float>) == uapprox3(-unit3_z<float>));
CHECK(vec{1.f,2.f,3.f} * qrotate(vec{1.f,2.f,3.f}, vec{-2.f,1.f,3.f}) == uapprox3(-2.f,1.f,3.f));
CHECK(vec{-2.f,1.f,3.f} * qrotate(vec{-2.f,1.f,3.f}, vec{1.f,2.f,3.f}) == uapprox3(1.f,2.f,3.f));
}
SUBCASE("qrotate(q, from, to)") {
REQUIRE(vec{1.f,2.f,3.f} *
CHECK(vec{1.f,2.f,3.f} *
inverse(qrotate(float3x3(rotate(radians(12.f), {2.f,2.f,2.f})))) *
qrotate(
qrotate(float3x3(rotate(radians(12.f), {2.f,2.f,2.f}))),
@@ -378,36 +378,36 @@ TEST_CASE("vmath/ext/quaternion_transform") {
}
SUBCASE("qrotate(angle, axis)") {
REQUIRE(all(approx(
CHECK(all(approx(
rotate(12.3f, float3(1.f,2.f,3.f)),
rotate(qrotate(12.3f, float3(1.f,2.f,3.f)) * 2.f))));
REQUIRE(float3(0.f,1.f,0.f) * qrotate_x(pi_2) == uapprox3(0.f,0.f,1.f));
REQUIRE(float3(0.f,0.f,1.f) * qrotate_y(pi_2) == uapprox3(1.f,0.f,0.f));
REQUIRE(float3(1.f,0.f,0.f) * qrotate_z(pi_2) == uapprox3(0.f,1.f,0.f));
CHECK(float3(0.f,1.f,0.f) * qrotate_x(pi_2) == uapprox3(0.f,0.f,1.f));
CHECK(float3(0.f,0.f,1.f) * qrotate_y(pi_2) == uapprox3(1.f,0.f,0.f));
CHECK(float3(1.f,0.f,0.f) * qrotate_z(pi_2) == uapprox3(0.f,1.f,0.f));
REQUIRE(float3(2.f,3.f,4.f) * qrotate(pi,{0.f,0.f,1.f}) == uapprox3(-2.f,-3.f,4.f));
REQUIRE(float3(2.f,3.f,4.f) * qrotate(pi,float3{0.f,0.f,1.f}) == uapprox3(-2.f,-3.f,4.f));
CHECK(float3(2.f,3.f,4.f) * qrotate(pi,{0.f,0.f,1.f}) == uapprox3(-2.f,-3.f,4.f));
CHECK(float3(2.f,3.f,4.f) * qrotate(pi,float3{0.f,0.f,1.f}) == uapprox3(-2.f,-3.f,4.f));
REQUIRE(qrotate_x(12.3f) == qrotate(12.3f, unit3_x<float> * 2.f));
REQUIRE(qrotate_y(12.3f) == qrotate(12.3f, unit3_y<float> * 2.f));
REQUIRE(qrotate_z(12.3f) == qrotate(12.3f, unit3_z<float> * 2.f));
CHECK(qrotate_x(12.3f) == qrotate(12.3f, unit3_x<float> * 2.f));
CHECK(qrotate_y(12.3f) == qrotate(12.3f, unit3_y<float> * 2.f));
CHECK(qrotate_z(12.3f) == qrotate(12.3f, unit3_z<float> * 2.f));
}
SUBCASE("qrotate(q, angle, axis)") {
REQUIRE(float3(0.f,1.f,0.f) * qrotate_x(qrotate_x(pi_4),pi_4) == uapprox3(0.f,0.f,1.f));
REQUIRE(float3(0.f,0.f,1.f) * qrotate_y(qrotate_y(pi_4),pi_4) == uapprox3(1.f,0.f,0.f));
REQUIRE(float3(1.f,0.f,0.f) * qrotate_z(qrotate_z(pi_4),pi_4) == uapprox3(0.f,1.f,0.f));
CHECK(float3(0.f,1.f,0.f) * qrotate_x(qrotate_x(pi_4),pi_4) == uapprox3(0.f,0.f,1.f));
CHECK(float3(0.f,0.f,1.f) * qrotate_y(qrotate_y(pi_4),pi_4) == uapprox3(1.f,0.f,0.f));
CHECK(float3(1.f,0.f,0.f) * qrotate_z(qrotate_z(pi_4),pi_4) == uapprox3(0.f,1.f,0.f));
REQUIRE(float3(2.f,3.f,4.f) * qrotate(qrotate(pi_2,{0.f,0.f,1.f}),pi_2,{0.f,0.f,1.f}) == uapprox3(-2.f,-3.f,4.f));
REQUIRE(float3(2.f,3.f,4.f) * qrotate(qrotate(pi_2,float3{0.f,0.f,1.f}),pi_2,float3{0.f,0.f,1.f}) == uapprox3(-2.f,-3.f,4.f));
CHECK(float3(2.f,3.f,4.f) * qrotate(qrotate(pi_2,{0.f,0.f,1.f}),pi_2,{0.f,0.f,1.f}) == uapprox3(-2.f,-3.f,4.f));
CHECK(float3(2.f,3.f,4.f) * qrotate(qrotate(pi_2,float3{0.f,0.f,1.f}),pi_2,float3{0.f,0.f,1.f}) == uapprox3(-2.f,-3.f,4.f));
}
SUBCASE("qlook_at") {
REQUIRE(all(approx(
CHECK(all(approx(
qlook_at_lh(float3(1.f,2.f,3.f), float3(0,1,0)),
qrotate(float3x3(look_at_lh(float3(), float3(1.f,2.f,3.f), float3(0,1,0)))))));
REQUIRE(all(approx(
CHECK(all(approx(
qlook_at_rh(float3(1.f,2.f,3.f), float3(0,1,0)),
qrotate(float3x3(look_at_rh(float3(), float3(1.f,2.f,3.f), float3(0,1,0)))))));
}

176
untests/vmath_fun_tests.cpp
View File

@@ -14,27 +14,27 @@ namespace
TEST_CASE("vmath/fun") {
SUBCASE("Angle and Trigonometric Functions") {
STATIC_REQUIRE(radians(degrees(12.13f)) == uapprox(12.13f));
STATIC_REQUIRE(degrees(radians(12.13f)) == uapprox(12.13f));
STATIC_CHECK(radians(degrees(12.13f)) == uapprox(12.13f));
STATIC_CHECK(degrees(radians(12.13f)) == uapprox(12.13f));
{
REQUIRE(asin(sin(1.23f)) == uapprox(1.23f));
REQUIRE(acos(cos(1.23f)) == uapprox(1.23f));
REQUIRE(atan(tan(1.23f)) == uapprox(1.23f));
CHECK(asin(sin(1.23f)) == uapprox(1.23f));
CHECK(acos(cos(1.23f)) == uapprox(1.23f));
CHECK(atan(tan(1.23f)) == uapprox(1.23f));
REQUIRE(asinh(sinh(1.23f)) == uapprox(1.23f));
REQUIRE(acosh(cosh(1.23f)) == uapprox(1.23f));
REQUIRE(atanh(tanh(1.23f)) == uapprox(1.23f));
CHECK(asinh(sinh(1.23f)) == uapprox(1.23f));
CHECK(acosh(cosh(1.23f)) == uapprox(1.23f));
CHECK(atanh(tanh(1.23f)) == uapprox(1.23f));
}
{
float out_s{}, out_c{};
sincos(15.f, &out_s, &out_c);
REQUIRE(out_s == uapprox(sin(15.f)));
REQUIRE(out_c == uapprox(cos(15.f)));
CHECK(out_s == uapprox(sin(15.f)));
CHECK(out_c == uapprox(cos(15.f)));
const auto [out_s2, out_c2] = sincos(15.f);
REQUIRE(out_s2 == uapprox(sin(15.f)));
REQUIRE(out_c2 == uapprox(cos(15.f)));
CHECK(out_s2 == uapprox(sin(15.f)));
CHECK(out_c2 == uapprox(cos(15.f)));
}
}
@@ -49,118 +49,118 @@ TEST_CASE("vmath/fun") {
}
SUBCASE("Common Functions") {
STATIC_REQUIRE(vmath_hpp::abs(1) == 1);
STATIC_REQUIRE(vmath_hpp::abs(-1) == 1);
STATIC_REQUIRE(vmath_hpp::abs(1.f) == uapprox(1.f));
STATIC_REQUIRE(vmath_hpp::abs(-1.f) == uapprox(1.f));
STATIC_CHECK(vmath_hpp::abs(1) == 1);
STATIC_CHECK(vmath_hpp::abs(-1) == 1);
STATIC_CHECK(vmath_hpp::abs(1.f) == uapprox(1.f));
STATIC_CHECK(vmath_hpp::abs(-1.f) == uapprox(1.f));
STATIC_REQUIRE(sqr(2) == 4);
STATIC_REQUIRE(sqr(-4.f) == uapprox(16.f));
STATIC_CHECK(sqr(2) == 4);
STATIC_CHECK(sqr(-4.f) == uapprox(16.f));
STATIC_REQUIRE(sign(2) == 1);
STATIC_REQUIRE(sign(-2) == -1);
STATIC_REQUIRE(sign(0) == 0);
STATIC_REQUIRE(sign(2.f) == uapprox(1.f));
STATIC_REQUIRE(sign(-2.f) == uapprox(-1.f));
STATIC_REQUIRE(sign(0.f) == uapprox(0.f));
STATIC_CHECK(sign(2) == 1);
STATIC_CHECK(sign(-2) == -1);
STATIC_CHECK(sign(0) == 0);
STATIC_CHECK(sign(2.f) == uapprox(1.f));
STATIC_CHECK(sign(-2.f) == uapprox(-1.f));
STATIC_CHECK(sign(0.f) == uapprox(0.f));
STATIC_REQUIRE(rcp(2.f) == uapprox(0.5f));
STATIC_REQUIRE(rcp(4.f) == uapprox(0.25f));
STATIC_CHECK(rcp(2.f) == uapprox(0.5f));
STATIC_CHECK(rcp(4.f) == uapprox(0.25f));
REQUIRE(floor(1.7f) == uapprox(1.f));
REQUIRE(trunc(1.7f) == uapprox(1.f));
REQUIRE(round(1.7f) == uapprox(2.f));
REQUIRE(ceil(1.7f) == uapprox(2.f));
CHECK(floor(1.7f) == uapprox(1.f));
CHECK(trunc(1.7f) == uapprox(1.f));
CHECK(round(1.7f) == uapprox(2.f));
CHECK(ceil(1.7f) == uapprox(2.f));
REQUIRE(fract(1.7f) == uapprox(0.7f));
REQUIRE(fract(-2.3f) == uapprox(0.7f));
CHECK(fract(1.7f) == uapprox(0.7f));
CHECK(fract(-2.3f) == uapprox(0.7f));
REQUIRE(fmod(1.7f, 1.2f) == uapprox(0.5f));
CHECK(fmod(1.7f, 1.2f) == uapprox(0.5f));
{
float out_i{};
REQUIRE(modf(1.7f, &out_i) == uapprox(0.7f));
REQUIRE(out_i == uapprox(1.f));
CHECK(modf(1.7f, &out_i) == uapprox(0.7f));
CHECK(out_i == uapprox(1.f));
}
STATIC_REQUIRE(min(0.f, 1.f) == uapprox(0.f));
STATIC_REQUIRE(max(0.f, 1.f) == uapprox(1.f));
STATIC_CHECK(min(0.f, 1.f) == uapprox(0.f));
STATIC_CHECK(max(0.f, 1.f) == uapprox(1.f));
STATIC_REQUIRE(clamp(1.0f, 2.f, 3.f) == uapprox(2.0f));
STATIC_REQUIRE(clamp(2.5f, 2.f, 3.f) == uapprox(2.5f));
STATIC_REQUIRE(clamp(3.5f, 2.f, 3.f) == uapprox(3.0f));
STATIC_CHECK(clamp(1.0f, 2.f, 3.f) == uapprox(2.0f));
STATIC_CHECK(clamp(2.5f, 2.f, 3.f) == uapprox(2.5f));
STATIC_CHECK(clamp(3.5f, 2.f, 3.f) == uapprox(3.0f));
STATIC_REQUIRE(saturate(-0.5f) == uapprox(0.f));
STATIC_REQUIRE(saturate(0.5f) == uapprox(0.5f));
STATIC_REQUIRE(saturate(1.5f) == uapprox(1.f));
STATIC_CHECK(saturate(-0.5f) == uapprox(0.f));
STATIC_CHECK(saturate(0.5f) == uapprox(0.5f));
STATIC_CHECK(saturate(1.5f) == uapprox(1.f));
STATIC_REQUIRE(lerp(2.f, 10.f, 0.f) == uapprox(2.f));
STATIC_REQUIRE(lerp(2.f, 10.f, 0.5f) == uapprox(6.f));
STATIC_REQUIRE(lerp(2.f, 10.f, 1.f) == uapprox(10.f));
STATIC_CHECK(lerp(2.f, 10.f, 0.f) == uapprox(2.f));
STATIC_CHECK(lerp(2.f, 10.f, 0.5f) == uapprox(6.f));
STATIC_CHECK(lerp(2.f, 10.f, 1.f) == uapprox(10.f));
STATIC_REQUIRE(lerp(2.f, 10.f, 0.f, 1.f) == uapprox(10.f));
STATIC_REQUIRE(lerp(2.f, 10.f, 1.f, 0.f) == uapprox(2.f));
STATIC_REQUIRE(lerp(2.f, 10.f, 0.5f, 0.2f) == uapprox(3.f));
STATIC_CHECK(lerp(2.f, 10.f, 0.f, 1.f) == uapprox(10.f));
STATIC_CHECK(lerp(2.f, 10.f, 1.f, 0.f) == uapprox(2.f));
STATIC_CHECK(lerp(2.f, 10.f, 0.5f, 0.2f) == uapprox(3.f));
STATIC_REQUIRE(step(0.5f, 0.4f) == uapprox(0.f));
STATIC_REQUIRE(step(0.5f, 0.6f) == uapprox(1.f));
STATIC_REQUIRE(smoothstep(0.f, 1.f, 0.1f) == uapprox(0.028f));
STATIC_CHECK(step(0.5f, 0.4f) == uapprox(0.f));
STATIC_CHECK(step(0.5f, 0.6f) == uapprox(1.f));
STATIC_CHECK(smoothstep(0.f, 1.f, 0.1f) == uapprox(0.028f));
REQUIRE_FALSE(vmath_hpp::isnan(1.f));
REQUIRE_FALSE(vmath_hpp::isinf(1.f));
REQUIRE(vmath_hpp::isfinite(1.f));
CHECK_FALSE(vmath_hpp::isnan(1.f));
CHECK_FALSE(vmath_hpp::isinf(1.f));
CHECK(vmath_hpp::isfinite(1.f));
REQUIRE(fma(2.f, 3.f, 4.f) == uapprox(10.f));
CHECK(fma(2.f, 3.f, 4.f) == uapprox(10.f));
{
int out_exp{};
REQUIRE(frexp(1.7f, &out_exp) == uapprox(0.85f));
REQUIRE(out_exp == 1);
CHECK(frexp(1.7f, &out_exp) == uapprox(0.85f));
CHECK(out_exp == 1);
}
REQUIRE(ldexp(0.85f, 1) == uapprox(1.7f));
CHECK(ldexp(0.85f, 1) == uapprox(1.7f));
}
SUBCASE("Geometric Functions") {
STATIC_REQUIRE(length(10.f) == uapprox(10.f));
STATIC_REQUIRE(length(-10.f) == uapprox(10.f));
STATIC_CHECK(length(10.f) == uapprox(10.f));
STATIC_CHECK(length(-10.f) == uapprox(10.f));
STATIC_REQUIRE(length2(10.f) == uapprox(100.f));
STATIC_REQUIRE(length2(-10.f) == uapprox(100.f));
STATIC_CHECK(length2(10.f) == uapprox(100.f));
STATIC_CHECK(length2(-10.f) == uapprox(100.f));
STATIC_REQUIRE(distance(5.f, 10.f) == uapprox(5.f));
STATIC_REQUIRE(distance(-5.f, -10.f) == uapprox(5.f));
STATIC_CHECK(distance(5.f, 10.f) == uapprox(5.f));
STATIC_CHECK(distance(-5.f, -10.f) == uapprox(5.f));
STATIC_REQUIRE(distance2(5.f, 10.f) == uapprox(25.f));
STATIC_REQUIRE(distance2(-5.f, -10.f) == uapprox(25.f));
STATIC_CHECK(distance2(5.f, 10.f) == uapprox(25.f));
STATIC_CHECK(distance2(-5.f, -10.f) == uapprox(25.f));
STATIC_REQUIRE(dot(2.f, 5.f) == uapprox(10.f));
REQUIRE(normalize(0.5f) == uapprox(1.f));
STATIC_CHECK(dot(2.f, 5.f) == uapprox(10.f));
CHECK(normalize(0.5f) == uapprox(1.f));
STATIC_REQUIRE(faceforward(1.f, 2.f, 3.f) == uapprox(-1.f));
STATIC_REQUIRE(reflect(1.f, 2.f) == uapprox(-7.f));
REQUIRE(refract(1.f, 2.f, 1.f) == uapprox(-7.f));
STATIC_CHECK(faceforward(1.f, 2.f, 3.f) == uapprox(-1.f));
STATIC_CHECK(reflect(1.f, 2.f) == uapprox(-7.f));
CHECK(refract(1.f, 2.f, 1.f) == uapprox(-7.f));
}
SUBCASE("Relational Functions") {
STATIC_REQUIRE_FALSE(any(false));
STATIC_REQUIRE_FALSE(any(0));
STATIC_REQUIRE(any(true));
STATIC_REQUIRE(any(1));
STATIC_CHECK_FALSE(any(false));
STATIC_CHECK_FALSE(any(0));
STATIC_CHECK(any(true));
STATIC_CHECK(any(1));
STATIC_REQUIRE_FALSE(all(false));
STATIC_REQUIRE_FALSE(all(0));
STATIC_REQUIRE(all(true));
STATIC_REQUIRE(all(1));
STATIC_CHECK_FALSE(all(false));
STATIC_CHECK_FALSE(all(0));
STATIC_CHECK(all(true));
STATIC_CHECK(all(1));
STATIC_REQUIRE(approx(1, 1));
STATIC_REQUIRE_FALSE(approx(0, 1));
STATIC_REQUIRE_FALSE(approx(0, 1, 0));
STATIC_REQUIRE(approx(0, 1, 1));
STATIC_CHECK(approx(1, 1));
STATIC_CHECK_FALSE(approx(0, 1));
STATIC_CHECK_FALSE(approx(0, 1, 0));
STATIC_CHECK(approx(0, 1, 1));
STATIC_REQUIRE(approx(1.f, 1.f + std::numeric_limits<float>::epsilon() * 0.5f));
STATIC_REQUIRE_FALSE(approx(1.f, 1.f + std::numeric_limits<float>::epsilon() * 1.5f));
STATIC_REQUIRE(approx(100.f, 100.f + std::numeric_limits<float>::epsilon() * 90.f));
STATIC_REQUIRE_FALSE(approx(100.f, 100.f + std::numeric_limits<float>::epsilon() * 110.f));
STATIC_CHECK(approx(1.f, 1.f + std::numeric_limits<float>::epsilon() * 0.5f));
STATIC_CHECK_FALSE(approx(1.f, 1.f + std::numeric_limits<float>::epsilon() * 1.5f));
STATIC_CHECK(approx(100.f, 100.f + std::numeric_limits<float>::epsilon() * 90.f));
STATIC_CHECK_FALSE(approx(100.f, 100.f + std::numeric_limits<float>::epsilon() * 110.f));
}
}

236
untests/vmath_mat_fun_tests.cpp
View File

@@ -31,175 +31,175 @@ namespace
TEST_CASE("vmath/mat_fun") {
SUBCASE("detail") {
STATIC_REQUIRE(map_join([](const int2& x){
STATIC_CHECK(map_join([](const int2& x){
return x * 2;
}, int2x2{}) == int2x2(2,0,0,2));
STATIC_REQUIRE(map_join([](const int2& x, const int2& y){
STATIC_CHECK(map_join([](const int2& x, const int2& y){
return x + y;
}, int2x2{}, int2x2{}) == int2x2(2,0,0,2));
STATIC_REQUIRE(map_join([](const int2& x, const int2& y, const int2& z){
STATIC_CHECK(map_join([](const int2& x, const int2& y, const int2& z){
return x + y + z;
}, int2x2{}, int2x2{}, int2x2{}) == int2x2(3,0,0,3));
STATIC_REQUIRE(fold_join([](int acc, const int2& x){
STATIC_CHECK(fold_join([](int acc, const int2& x){
return acc + x.x;
}, 0, int2x2{}) == 1);
STATIC_REQUIRE(fold_join([](int acc, const int2& x, const int2& y){
STATIC_CHECK(fold_join([](int acc, const int2& x, const int2& y){
return acc + x.x + y.x;
}, 0, int2x2{}, int2x2{}) == 2);
STATIC_REQUIRE(fold1_join([](const int2& acc, const int2& x){
STATIC_CHECK(fold1_join([](const int2& acc, const int2& x){
return acc + x;
}, int2x2{}) == int2(1,1));
}
SUBCASE("operators") {
STATIC_REQUIRE(+int2x2(1,-2,3,-4) == int2x2(1,-2,3,-4));
STATIC_REQUIRE(-int2x2(1,-2,3,-4) == int2x2(-1,2,-3,4));
STATIC_REQUIRE(~uint2x2(0xF0F0F0F0,0x0F0F0F0F,0xF0F0F0F0,0x0F0F0F0F) == uint2x2(0x0F0F0F0F,0xF0F0F0F0,0x0F0F0F0F,0xF0F0F0F0));
STATIC_REQUIRE(!int2x2(-1,0,1,2) == bool2x2(false,true,false,false));
STATIC_CHECK(+int2x2(1,-2,3,-4) == int2x2(1,-2,3,-4));
STATIC_CHECK(-int2x2(1,-2,3,-4) == int2x2(-1,2,-3,4));
STATIC_CHECK(~uint2x2(0xF0F0F0F0,0x0F0F0F0F,0xF0F0F0F0,0x0F0F0F0F) == uint2x2(0x0F0F0F0F,0xF0F0F0F0,0x0F0F0F0F,0xF0F0F0F0));
STATIC_CHECK(!int2x2(-1,0,1,2) == bool2x2(false,true,false,false));
STATIC_REQUIRE(int2x2(1,2,3,4) + 2 == int2x2(3,4,5,6));
STATIC_REQUIRE(int2x2(1,2,3,4) - 2 == int2x2(-1,0,1,2));
STATIC_REQUIRE(int2x2(1,2,3,4) * 2 == int2x2(2,4,6,8));
STATIC_REQUIRE(int2x2(1,2,3,4) / 2 == int2x2(0,1,1,2));
STATIC_REQUIRE((int2x2(11,12,11,12) & 6) == int2x2(2,4,2,4));
STATIC_REQUIRE((int2x2(11,12,11,12) | 6) == int2x2(15,14,15,14));
STATIC_REQUIRE((int2x2(11,12,11,12) ^ 6) == int2x2(13,10,13,10));
STATIC_REQUIRE((int2x2(1,0,1,0) && 1) == bool2x2(1,0,1,0));
STATIC_REQUIRE((int2x2(1,0,1,0) || 1) == bool2x2(1,1,1,1));
STATIC_CHECK(int2x2(1,2,3,4) + 2 == int2x2(3,4,5,6));
STATIC_CHECK(int2x2(1,2,3,4) - 2 == int2x2(-1,0,1,2));
STATIC_CHECK(int2x2(1,2,3,4) * 2 == int2x2(2,4,6,8));
STATIC_CHECK(int2x2(1,2,3,4) / 2 == int2x2(0,1,1,2));
STATIC_CHECK((int2x2(11,12,11,12) & 6) == int2x2(2,4,2,4));
STATIC_CHECK((int2x2(11,12,11,12) | 6) == int2x2(15,14,15,14));
STATIC_CHECK((int2x2(11,12,11,12) ^ 6) == int2x2(13,10,13,10));
STATIC_CHECK((int2x2(1,0,1,0) && 1) == bool2x2(1,0,1,0));
STATIC_CHECK((int2x2(1,0,1,0) || 1) == bool2x2(1,1,1,1));
STATIC_REQUIRE(4 + int2x2(1,2,3,4) == int2x2(5,6,7,8));
STATIC_REQUIRE(4 - int2x2(1,2,3,4) == int2x2(3,2,1,0));
STATIC_REQUIRE(4 * int2x2(1,2,3,4) == int2x2(4,8,12,16));
STATIC_REQUIRE(4 / int2x2(1,2,3,4) == int2x2(4,2,1,1));
STATIC_REQUIRE((6 &int2x2(11,12,11,12)) == int2x2(2,4,2,4));
STATIC_REQUIRE((6 |int2x2(11,12,11,12)) == int2x2(15,14,15,14));
STATIC_REQUIRE((6 ^ int2x2(11,12,11,12)) == int2x2(13,10,13,10));
STATIC_REQUIRE((1 && int2x2(1,0,1,0)) == bool2x2(1,0,1,0));
STATIC_REQUIRE((1 || int2x2(1,0,1,0)) == bool2x2(1,1,1,1));
STATIC_CHECK(4 + int2x2(1,2,3,4) == int2x2(5,6,7,8));
STATIC_CHECK(4 - int2x2(1,2,3,4) == int2x2(3,2,1,0));
STATIC_CHECK(4 * int2x2(1,2,3,4) == int2x2(4,8,12,16));
STATIC_CHECK(4 / int2x2(1,2,3,4) == int2x2(4,2,1,1));
STATIC_CHECK((6 &int2x2(11,12,11,12)) == int2x2(2,4,2,4));
STATIC_CHECK((6 |int2x2(11,12,11,12)) == int2x2(15,14,15,14));
STATIC_CHECK((6 ^ int2x2(11,12,11,12)) == int2x2(13,10,13,10));
STATIC_CHECK((1 && int2x2(1,0,1,0)) == bool2x2(1,0,1,0));
STATIC_CHECK((1 || int2x2(1,0,1,0)) == bool2x2(1,1,1,1));
STATIC_REQUIRE(int2x2(1,2,3,4) + int2x2(5,6,7,8) == int2x2(6,8,10,12));
STATIC_REQUIRE(int2x2(1,2,3,4) - int2x2(5,6,7,8) == int2x2(-4,-4,-4,-4));
STATIC_CHECK(int2x2(1,2,3,4) + int2x2(5,6,7,8) == int2x2(6,8,10,12));
STATIC_CHECK(int2x2(1,2,3,4) - int2x2(5,6,7,8) == int2x2(-4,-4,-4,-4));
STATIC_REQUIRE(int2x2() * int2x2() == int2x2());
STATIC_REQUIRE(int3x3() * int3x3() == int3x3());
STATIC_CHECK(int2x2() * int2x2() == int2x2());
STATIC_CHECK(int3x3() * int3x3() == int3x3());
STATIC_REQUIRE(int2(1,2) * int2x2() == int2(1,2));
STATIC_REQUIRE(int3(1,2,3) * int3x3() == int3(1,2,3));
STATIC_REQUIRE(int4(1,2,3,4) * int4x4() == int4(1,2,3,4));
STATIC_CHECK(int2(1,2) * int2x2() == int2(1,2));
STATIC_CHECK(int3(1,2,3) * int3x3() == int3(1,2,3));
STATIC_CHECK(int4(1,2,3,4) * int4x4() == int4(1,2,3,4));
STATIC_REQUIRE((int2x2(6,7,6,7) & int2x2(11,12,11,12)) == int2x2(2,4,2,4));
STATIC_REQUIRE((int2x2(6,7,6,7) | int2x2(11,12,11,12)) == int2x2(15,15,15,15));
STATIC_REQUIRE((int2x2(6,7,6,7) ^ int2x2(11,12,11,12)) == int2x2(13,11,13,11));
STATIC_REQUIRE((int2x2(0,1,0,1) && int2x2(1,0,1,0)) == bool2x2(0,0,0,0));
STATIC_REQUIRE((int2x2(0,1,0,1) || int2x2(1,0,1,0)) == bool2x2(1,1,1,1));
STATIC_CHECK((int2x2(6,7,6,7) & int2x2(11,12,11,12)) == int2x2(2,4,2,4));
STATIC_CHECK((int2x2(6,7,6,7) | int2x2(11,12,11,12)) == int2x2(15,15,15,15));
STATIC_CHECK((int2x2(6,7,6,7) ^ int2x2(11,12,11,12)) == int2x2(13,11,13,11));
STATIC_CHECK((int2x2(0,1,0,1) && int2x2(1,0,1,0)) == bool2x2(0,0,0,0));
STATIC_CHECK((int2x2(0,1,0,1) || int2x2(1,0,1,0)) == bool2x2(1,1,1,1));
{
int2x2 v{1,2,3,4};
REQUIRE(&v == &(v += 3));
REQUIRE(v == int2x2{4,5,6,7});
REQUIRE(&v == &(v += int2x2{1,2,3,4}));
REQUIRE(v == int2x2{5,7,9,11});
CHECK(&v == &(v += 3));
CHECK(v == int2x2{4,5,6,7});
CHECK(&v == &(v += int2x2{1,2,3,4}));
CHECK(v == int2x2{5,7,9,11});
}
{
int2x2 v{4,5,6,7};
REQUIRE(&v == &(v -= 3));
REQUIRE(v == int2x2{1,2,3,4});
REQUIRE(&v == &(v -= int2x2{2,4,6,8}));
REQUIRE(v == int2x2{-1,-2,-3,-4});
CHECK(&v == &(v -= 3));
CHECK(v == int2x2{1,2,3,4});
CHECK(&v == &(v -= int2x2{2,4,6,8}));
CHECK(v == int2x2{-1,-2,-3,-4});
}
{
int2x2 v{1,2,3,4};
REQUIRE(&v == &(v *= 3));
REQUIRE(v == int2x2{3,6,9,12});
CHECK(&v == &(v *= 3));
CHECK(v == int2x2{3,6,9,12});
}
{
int4 v{0, 0, 0, 1};
REQUIRE(&v == &(v *= translate(int3{1,2,3})));
REQUIRE(v == uapprox4(1,2,3,1));
CHECK(&v == &(v *= translate(int3{1,2,3})));
CHECK(v == uapprox4(1,2,3,1));
}
{
int3 v{1, 2, 3};
REQUIRE(&v == &(v *= int3x3(scale(int3{2,3,4}))));
REQUIRE(v == int3(2,6,12));
CHECK(&v == &(v *= int3x3(scale(int3{2,3,4}))));
CHECK(v == int3(2,6,12));
}
{
int4x4 v = translate(int3{1, 2, 3});
REQUIRE(&v == &(v *= translate(int3{1,2,3})));
REQUIRE(v == translate(int3{2,4,6}));
CHECK(&v == &(v *= translate(int3{1,2,3})));
CHECK(v == translate(int3{2,4,6}));
}
{
int3x3 v = int3x3(scale(int3{1, 2, 3}));
REQUIRE(&v == &(v *= int3x3(scale(int3{2,3,4}))));
REQUIRE(v == int3x3(scale(int3{2,6,12})));
CHECK(&v == &(v *= int3x3(scale(int3{2,3,4}))));
CHECK(v == int3x3(scale(int3{2,6,12})));
}
{
int2x2 v1{11,12,11,12};
REQUIRE(&v1 == &(v1 &= 6));
REQUIRE(v1 == int2x2(2,4,2,4));
CHECK(&v1 == &(v1 &= 6));
CHECK(v1 == int2x2(2,4,2,4));
int2x2 v2{6,7,6,7};
REQUIRE(&v2 == &(v2 &= int2x2(11,12,11,12)));
REQUIRE(v2 == int2x2(2,4,2,4));
CHECK(&v2 == &(v2 &= int2x2(11,12,11,12)));
CHECK(v2 == int2x2(2,4,2,4));
}
{
int2x2 v1{11,12,11,12};
REQUIRE(&v1 == &(v1 |= 6));
REQUIRE(v1 == int2x2(15,14,15,14));
CHECK(&v1 == &(v1 |= 6));
CHECK(v1 == int2x2(15,14,15,14));
int2x2 v2{6,7,6,7};
REQUIRE(&v2 == &(v2 |= int2x2(11,12,11,12)));
REQUIRE(v2 == int2x2(15,15,15,15));
CHECK(&v2 == &(v2 |= int2x2(11,12,11,12)));
CHECK(v2 == int2x2(15,15,15,15));
}
{
int2x2 v1{11,12,11,12};
REQUIRE(&v1 == &(v1 ^= 6));
REQUIRE(v1 == int2x2(13,10,13,10));
CHECK(&v1 == &(v1 ^= 6));
CHECK(v1 == int2x2(13,10,13,10));
int2x2 v2{6,7,6,7};
REQUIRE(&v2 == &(v2 ^= int2x2(11,12,11,12)));
REQUIRE(v2 == int2x2(13,11,13,11));
CHECK(&v2 == &(v2 ^= int2x2(11,12,11,12)));
CHECK(v2 == int2x2(13,11,13,11));
}
}
SUBCASE("relational functions") {
STATIC_REQUIRE_FALSE(any(bool2x2(false, false, false, false)));
STATIC_REQUIRE(any(bool2x2(true, false, true, false)));
STATIC_REQUIRE(any(bool2x2(false, true, false, true)));
STATIC_REQUIRE(any(bool2x2(true, true, true, true)));
STATIC_CHECK_FALSE(any(bool2x2(false, false, false, false)));
STATIC_CHECK(any(bool2x2(true, false, true, false)));
STATIC_CHECK(any(bool2x2(false, true, false, true)));
STATIC_CHECK(any(bool2x2(true, true, true, true)));
STATIC_REQUIRE_FALSE(any(int2x2(0, 0, 0, 0)));
STATIC_REQUIRE(any(int2x2(1, 0, 1, 0)));
STATIC_REQUIRE(any(int2x2(0, 1, 0, 1)));
STATIC_REQUIRE(any(int2x2(1, 1, 1, 1)));
STATIC_CHECK_FALSE(any(int2x2(0, 0, 0, 0)));
STATIC_CHECK(any(int2x2(1, 0, 1, 0)));
STATIC_CHECK(any(int2x2(0, 1, 0, 1)));
STATIC_CHECK(any(int2x2(1, 1, 1, 1)));
STATIC_REQUIRE_FALSE(all(bool2x2(false, false, false, false)));
STATIC_REQUIRE_FALSE(all(bool2x2(true, false, true, false)));
STATIC_REQUIRE_FALSE(all(bool2x2(false, true, false, true)));
STATIC_REQUIRE(all(bool2x2(true, true, true, true)));
STATIC_CHECK_FALSE(all(bool2x2(false, false, false, false)));
STATIC_CHECK_FALSE(all(bool2x2(true, false, true, false)));
STATIC_CHECK_FALSE(all(bool2x2(false, true, false, true)));
STATIC_CHECK(all(bool2x2(true, true, true, true)));
STATIC_REQUIRE_FALSE(all(int2x2(0, 0, 0, 0)));
STATIC_REQUIRE_FALSE(all(int2x2(1, 0, 1, 0)));
STATIC_REQUIRE_FALSE(all(int2x2(0, 1, 0, 1)));
STATIC_REQUIRE(all(int2x2(1, 1, 1, 1)));
STATIC_CHECK_FALSE(all(int2x2(0, 0, 0, 0)));
STATIC_CHECK_FALSE(all(int2x2(1, 0, 1, 0)));
STATIC_CHECK_FALSE(all(int2x2(0, 1, 0, 1)));
STATIC_CHECK(all(int2x2(1, 1, 1, 1)));
STATIC_REQUIRE(approx(int2x2(1,1,1,1), int2x2(0,1,2,3)) == bool2x2(false, true, false, false));
STATIC_REQUIRE(approx(int2x2(1,1,1,1), int2x2(0,1,2,3), 0) == bool2x2(false, true, false, false));
STATIC_REQUIRE(approx(int2x2(1,1,1,1), int2x2(0,1,2,3), 1) == bool2x2(true, true, true, false));
STATIC_REQUIRE(approx(int2x2(1,1,1,1), int2x2(0,1,2,3), 2) == bool2x2(true, true, true, true));
STATIC_CHECK(approx(int2x2(1,1,1,1), int2x2(0,1,2,3)) == bool2x2(false, true, false, false));
STATIC_CHECK(approx(int2x2(1,1,1,1), int2x2(0,1,2,3), 0) == bool2x2(false, true, false, false));
STATIC_CHECK(approx(int2x2(1,1,1,1), int2x2(0,1,2,3), 1) == bool2x2(true, true, true, false));
STATIC_CHECK(approx(int2x2(1,1,1,1), int2x2(0,1,2,3), 2) == bool2x2(true, true, true, true));
STATIC_REQUIRE(less(int2x2(1,1,1,1), int2x2(0,1,2,3)) == bool2x2(false, false, true, true));
STATIC_REQUIRE(less_equal(int2x2(1,1,1,1), int2x2(0,1,2,3)) == bool2x2(false, true, true, true));
STATIC_REQUIRE(greater(int2x2(1,1,1,1), int2x2(0,1,2,3)) == bool2x2(true, false, false, false));
STATIC_REQUIRE(greater_equal(int2x2(1,1,1,1), int2x2(0,1,2,3)) == bool2x2(true, true, false, false));
STATIC_CHECK(less(int2x2(1,1,1,1), int2x2(0,1,2,3)) == bool2x2(false, false, true, true));
STATIC_CHECK(less_equal(int2x2(1,1,1,1), int2x2(0,1,2,3)) == bool2x2(false, true, true, true));
STATIC_CHECK(greater(int2x2(1,1,1,1), int2x2(0,1,2,3)) == bool2x2(true, false, false, false));
STATIC_CHECK(greater_equal(int2x2(1,1,1,1), int2x2(0,1,2,3)) == bool2x2(true, true, false, false));
STATIC_REQUIRE(equal_to(int2x2(1,1,1,1), int2x2(0,1,2,3)) == bool2x2(false, true, false, false));
STATIC_REQUIRE(not_equal_to(int2x2(1,1,1,1), int2x2(0,1,2,3)) == bool2x2(true, false, true, true));
STATIC_CHECK(equal_to(int2x2(1,1,1,1), int2x2(0,1,2,3)) == bool2x2(false, true, false, false));
STATIC_CHECK(not_equal_to(int2x2(1,1,1,1), int2x2(0,1,2,3)) == bool2x2(true, false, true, true));
}
SUBCASE("transpose") {
STATIC_REQUIRE(transpose(int2x2(
STATIC_CHECK(transpose(int2x2(
1, 2,
3, 4
)) == int2x2(
@@ -207,7 +207,7 @@ TEST_CASE("vmath/mat_fun") {
2, 4
));
STATIC_REQUIRE(transpose(int3x3(
STATIC_CHECK(transpose(int3x3(
1, 2, 3,
4, 5, 6,
7, 8, 9
@@ -217,7 +217,7 @@ TEST_CASE("vmath/mat_fun") {
3, 6, 9
));
STATIC_REQUIRE(transpose(int4x4(
STATIC_CHECK(transpose(int4x4(
1, 2, 3, 4,
5, 6, 7, 8,
9, 10, 11, 12,
@@ -234,32 +234,32 @@ TEST_CASE("vmath/mat_fun") {
constexpr int2x2 m2{1,2,3,4};
constexpr int3x3 m3{1,2,3,4,5,6,7,8,9};
constexpr int4x4 m4{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
STATIC_REQUIRE(determinant(m2) == determinant(transpose(m2)));
STATIC_REQUIRE(determinant(m3) == determinant(transpose(m3)));
STATIC_REQUIRE(determinant(m4) == determinant(transpose(m4)));
STATIC_CHECK(determinant(m2) == determinant(transpose(m2)));
STATIC_CHECK(determinant(m3) == determinant(transpose(m3)));
STATIC_CHECK(determinant(m4) == determinant(transpose(m4)));
STATIC_REQUIRE(determinant(generate_frank_matrix<int, 2>()) == 1);
STATIC_REQUIRE(determinant(generate_frank_matrix<int, 3>()) == 1);
STATIC_REQUIRE(determinant(generate_frank_matrix<int, 4>()) == 1);
STATIC_CHECK(determinant(generate_frank_matrix<int, 2>()) == 1);
STATIC_CHECK(determinant(generate_frank_matrix<int, 3>()) == 1);
STATIC_CHECK(determinant(generate_frank_matrix<int, 4>()) == 1);
STATIC_REQUIRE(determinant(transpose(generate_frank_matrix<int, 2>())) == 1);
STATIC_REQUIRE(determinant(transpose(generate_frank_matrix<int, 3>())) == 1);
STATIC_REQUIRE(determinant(transpose(generate_frank_matrix<int, 4>())) == 1);
STATIC_CHECK(determinant(transpose(generate_frank_matrix<int, 2>())) == 1);
STATIC_CHECK(determinant(transpose(generate_frank_matrix<int, 3>())) == 1);
STATIC_CHECK(determinant(transpose(generate_frank_matrix<int, 4>())) == 1);
}
SUBCASE("inverse") {
STATIC_REQUIRE(inverse(float2x2()) == float2x2());
STATIC_REQUIRE(inverse(float3x3()) == float3x3());
STATIC_REQUIRE(inverse(float4x4()) == float4x4());
STATIC_CHECK(inverse(float2x2()) == float2x2());
STATIC_CHECK(inverse(float3x3()) == float3x3());
STATIC_CHECK(inverse(float4x4()) == float4x4());
STATIC_REQUIRE(inverse(float2x2(0.5)) == float2x2(2.f));
STATIC_REQUIRE(inverse(float3x3(0.5)) == float3x3(2.f));
STATIC_REQUIRE(inverse(float4x4(0.5)) == float4x4(2.f));
STATIC_CHECK(inverse(float2x2(0.5)) == float2x2(2.f));
STATIC_CHECK(inverse(float3x3(0.5)) == float3x3(2.f));
STATIC_CHECK(inverse(float4x4(0.5)) == float4x4(2.f));
{
constexpr float4x4 m1 = translate(float3(1.f, 2.f, 3.f));
constexpr float4x4 rm1 = inverse(m1);
STATIC_REQUIRE(all(approx(
STATIC_CHECK(all(approx(
unit4_z<float> * m1 * rm1,
unit4_z<float>)));
}
@@ -268,7 +268,7 @@ TEST_CASE("vmath/mat_fun") {
const float3 axis2 = normalize(float3(1.f, 2.f, 3.f));
const float4x4 m2 = rotate(0.5f,axis2);
const float4x4 rm2 = inverse(m2);
REQUIRE(all(approx(
CHECK(all(approx(
unit4_z<float> * m2 * rm2,
unit4_z<float>)));
}
@@ -277,7 +277,7 @@ TEST_CASE("vmath/mat_fun") {
const float3 axis3 = normalize(float3(1.f, 2.f, 3.f));
const float3x3 m3 = float3x3(rotate(0.5f,axis3));
const float3x3 rm3 = inverse(m3);
REQUIRE(all(approx(
CHECK(all(approx(
unit3_z<float> * m3 * rm3,
unit3_z<float>)));
}
@@ -286,7 +286,7 @@ TEST_CASE("vmath/mat_fun") {
const float3 axis4 = normalize(float3(0.f, 0.f, 3.f));
const float2x2 m4 = float2x2(rotate(0.5f,axis4));
const float2x2 rm4 = inverse(m4);
REQUIRE(all(approx(
CHECK(all(approx(
unit2_y<float> * m4 * rm4,
unit2_y<float>)));
}

280
untests/vmath_mat_tests.cpp
View File

@@ -14,81 +14,81 @@ namespace
TEST_CASE("vmath/mat") {
SUBCASE("size/sizeof") {
STATIC_REQUIRE(int2x2{}.size == 2);
STATIC_REQUIRE(int3x3{}.size == 3);
STATIC_REQUIRE(int4x4{}.size == 4);
STATIC_CHECK(int2x2{}.size == 2);
STATIC_CHECK(int3x3{}.size == 3);
STATIC_CHECK(int4x4{}.size == 4);
STATIC_REQUIRE(sizeof(int2x2{}) == sizeof(int) * 2 * 2);
STATIC_REQUIRE(sizeof(int3x3{}) == sizeof(int) * 3 * 3);
STATIC_REQUIRE(sizeof(int4x4{}) == sizeof(int) * 4 * 4);
STATIC_CHECK(sizeof(int2x2{}) == sizeof(int) * 2 * 2);
STATIC_CHECK(sizeof(int3x3{}) == sizeof(int) * 3 * 3);
STATIC_CHECK(sizeof(int4x4{}) == sizeof(int) * 4 * 4);
}
SUBCASE("guides") {
STATIC_REQUIRE(mat{1,2,3,4}.size == 2);
STATIC_REQUIRE(mat{{1,2},{3,4}}.size == 2);
STATIC_REQUIRE(mat{vec{1,2},vec{3,4}}.size == 2);
STATIC_CHECK(mat{1,2,3,4}.size == 2);
STATIC_CHECK(mat{{1,2},{3,4}}.size == 2);
STATIC_CHECK(mat{vec{1,2},vec{3,4}}.size == 2);
STATIC_REQUIRE(mat{1,2,3,4,5,6,7,8,9}.size == 3);
STATIC_REQUIRE(mat{{1,2,3},{4,5,6},{7,8,9}}.size == 3);
STATIC_REQUIRE(mat{vec{1,2,3},vec{4,5,6},vec{7,8,9}}.size == 3);
STATIC_REQUIRE(mat{mat{1,2,3,4},vec{5,6}}.size == 3);
STATIC_CHECK(mat{1,2,3,4,5,6,7,8,9}.size == 3);
STATIC_CHECK(mat{{1,2,3},{4,5,6},{7,8,9}}.size == 3);
STATIC_CHECK(mat{vec{1,2,3},vec{4,5,6},vec{7,8,9}}.size == 3);
STATIC_CHECK(mat{mat{1,2,3,4},vec{5,6}}.size == 3);
STATIC_REQUIRE(mat{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}.size == 4);
STATIC_REQUIRE(mat{{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}}.size == 4);
STATIC_REQUIRE(mat{vec{1,2,3,4},vec{5,6,7,8},vec{9,10,11,12},vec{13,14,15,16}}.size == 4);
STATIC_REQUIRE(mat{mat{1,2,3,4,5,6,7,8,9},vec{5,6,7}}.size == 4);
STATIC_CHECK(mat{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}.size == 4);
STATIC_CHECK(mat{{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}}.size == 4);
STATIC_CHECK(mat{vec{1,2,3,4},vec{5,6,7,8},vec{9,10,11,12},vec{13,14,15,16}}.size == 4);
STATIC_CHECK(mat{mat{1,2,3,4,5,6,7,8,9},vec{5,6,7}}.size == 4);
}
SUBCASE("ctors") {
{
STATIC_REQUIRE(int2x2()[0] == int2(1,0));
STATIC_REQUIRE(int2x2()[1] == int2(0,1));
STATIC_CHECK(int2x2()[0] == int2(1,0));
STATIC_CHECK(int2x2()[1] == int2(0,1));
STATIC_REQUIRE(int2x2(1,2,3,4)[0] == int2(1,2));
STATIC_REQUIRE(int2x2(1,2,3,4)[1] == int2(3,4));
STATIC_CHECK(int2x2(1,2,3,4)[0] == int2(1,2));
STATIC_CHECK(int2x2(1,2,3,4)[1] == int2(3,4));
STATIC_REQUIRE(int2x2({1,2},{3,4})[0] == int2(1,2));
STATIC_REQUIRE(int2x2({1,2},{3,4})[1] == int2(3,4));
STATIC_CHECK(int2x2({1,2},{3,4})[0] == int2(1,2));
STATIC_CHECK(int2x2({1,2},{3,4})[1] == int2(3,4));
}
{
constexpr int2x2 v(1,2,3,4);
constexpr int2x2 v2 = v;
STATIC_REQUIRE(v2 == int2x2(1,2,3,4));
STATIC_CHECK(v2 == int2x2(1,2,3,4));
}
{
constexpr int2x2 v(1,2,3,4);
constexpr int2x2 v2 = std::move(v);
STATIC_REQUIRE(v2 == int2x2(1,2,3,4));
STATIC_CHECK(v2 == int2x2(1,2,3,4));
}
{
STATIC_REQUIRE(int2x2() == int2x2(1,0,0,1));
STATIC_REQUIRE(int2x2(2) == int2x2(2,0,0,2));
STATIC_REQUIRE(int2x2(int2{2,3}) == int2x2(2,0,0,3));
STATIC_REQUIRE(int2x2(1,2,3,4) == int2x2(1,2,3,4));
STATIC_REQUIRE(int2x2({1,2},{3,4}) == int2x2(1,2,3,4));
STATIC_REQUIRE(int2x2(int2x2({1,2},{3,4})) == int2x2(1,2,3,4));
STATIC_REQUIRE(int2x2(int3x3({1,2,3},{4,5,6},{7,8,9})) == int2x2(1,2,4,5));
STATIC_REQUIRE(int2x2(int4x4({1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16})) == int2x2(1,2,5,6));
STATIC_CHECK(int2x2() == int2x2(1,0,0,1));
STATIC_CHECK(int2x2(2) == int2x2(2,0,0,2));
STATIC_CHECK(int2x2(int2{2,3}) == int2x2(2,0,0,3));
STATIC_CHECK(int2x2(1,2,3,4) == int2x2(1,2,3,4));
STATIC_CHECK(int2x2({1,2},{3,4}) == int2x2(1,2,3,4));
STATIC_CHECK(int2x2(int2x2({1,2},{3,4})) == int2x2(1,2,3,4));
STATIC_CHECK(int2x2(int3x3({1,2,3},{4,5,6},{7,8,9})) == int2x2(1,2,4,5));
STATIC_CHECK(int2x2(int4x4({1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16})) == int2x2(1,2,5,6));
STATIC_REQUIRE(int3x3() == int3x3(1,0,0,0,1,0,0,0,1));
STATIC_REQUIRE(int3x3(2) == int3x3(2,0,0,0,2,0,0,0,2));
STATIC_REQUIRE(int3x3(int3{2,3,4}) == int3x3(2,0,0,0,3,0,0,0,4));
STATIC_REQUIRE(int3x3(1,2,3,4,5,6,7,8,9) == int3x3(1,2,3,4,5,6,7,8,9));
STATIC_REQUIRE(int3x3({1,2,3},{4,5,6},{7,8,9}) == int3x3(1,2,3,4,5,6,7,8,9));
STATIC_REQUIRE(int3x3(int2x2({1,2},{3,4}),int2{5,6}) == int3x3(1,2,0,3,4,0,5,6,1));
STATIC_REQUIRE(int3x3(int3x3({1,2,3},{4,5,6},{7,8,9})) == int3x3(1,2,3,4,5,6,7,8,9));
STATIC_REQUIRE(int3x3(int2x2({1,2},{3,4})) == int3x3(1,2,0,3,4,0,0,0,1));
STATIC_REQUIRE(int3x3(int4x4({1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16})) == int3x3(1,2,3,5,6,7,9,10,11));
STATIC_CHECK(int3x3() == int3x3(1,0,0,0,1,0,0,0,1));
STATIC_CHECK(int3x3(2) == int3x3(2,0,0,0,2,0,0,0,2));
STATIC_CHECK(int3x3(int3{2,3,4}) == int3x3(2,0,0,0,3,0,0,0,4));
STATIC_CHECK(int3x3(1,2,3,4,5,6,7,8,9) == int3x3(1,2,3,4,5,6,7,8,9));
STATIC_CHECK(int3x3({1,2,3},{4,5,6},{7,8,9}) == int3x3(1,2,3,4,5,6,7,8,9));
STATIC_CHECK(int3x3(int2x2({1,2},{3,4}),int2{5,6}) == int3x3(1,2,0,3,4,0,5,6,1));
STATIC_CHECK(int3x3(int3x3({1,2,3},{4,5,6},{7,8,9})) == int3x3(1,2,3,4,5,6,7,8,9));
STATIC_CHECK(int3x3(int2x2({1,2},{3,4})) == int3x3(1,2,0,3,4,0,0,0,1));
STATIC_CHECK(int3x3(int4x4({1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16})) == int3x3(1,2,3,5,6,7,9,10,11));
STATIC_REQUIRE(int4x4() == int4x4(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1));
STATIC_REQUIRE(int4x4(2) == int4x4(2,0,0,0,0,2,0,0,0,0,2,0,0,0,0,2));
STATIC_REQUIRE(int4x4(int4{2,3,4,5}) == int4x4(2,0,0,0,0,3,0,0,0,0,4,0,0,0,0,5));
STATIC_REQUIRE(int4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16) == int4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16));
STATIC_REQUIRE(int4x4({1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}) == int4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16));
STATIC_REQUIRE(int4x4(int3x3({1,2,3},{4,5,6},{7,8,9}),int3{10,11,12}) == int4x4(1,2,3,0,4,5,6,0,7,8,9,0,10,11,12,1));
STATIC_REQUIRE(int4x4(int4x4({1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16})) == int4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16));
STATIC_REQUIRE(int4x4(int2x2({1,2},{3,4})) == int4x4(1,2,0,0,3,4,0,0,0,0,1,0,0,0,0,1));
STATIC_REQUIRE(int4x4(int3x3({1,2,3},{4,5,6},{7,8,9})) == int4x4(1,2,3,0,4,5,6,0,7,8,9,0,0,0,0,1));
STATIC_CHECK(int4x4() == int4x4(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1));
STATIC_CHECK(int4x4(2) == int4x4(2,0,0,0,0,2,0,0,0,0,2,0,0,0,0,2));
STATIC_CHECK(int4x4(int4{2,3,4,5}) == int4x4(2,0,0,0,0,3,0,0,0,0,4,0,0,0,0,5));
STATIC_CHECK(int4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16) == int4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16));
STATIC_CHECK(int4x4({1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}) == int4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16));
STATIC_CHECK(int4x4(int3x3({1,2,3},{4,5,6},{7,8,9}),int3{10,11,12}) == int4x4(1,2,3,0,4,5,6,0,7,8,9,0,10,11,12,1));
STATIC_CHECK(int4x4(int4x4({1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16})) == int4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16));
STATIC_CHECK(int4x4(int2x2({1,2},{3,4})) == int4x4(1,2,0,0,3,4,0,0,0,0,1,0,0,0,0,1));
STATIC_CHECK(int4x4(int3x3({1,2,3},{4,5,6},{7,8,9})) == int4x4(1,2,3,0,4,5,6,0,7,8,9,0,0,0,0,1));
}
}
@@ -97,13 +97,13 @@ TEST_CASE("vmath/mat") {
int2x2 v(1,2,3,4);
int2x2 v2;
v2 = v;
REQUIRE(v2 == int2x2(1,2,3,4));
CHECK(v2 == int2x2(1,2,3,4));
}
{
int2x2 v(1,2,3,4);
int2x2 v2;
v2 = std::move(v);
REQUIRE(v2 == int2x2(1,2,3,4));
CHECK(v2 == int2x2(1,2,3,4));
}
}
@@ -112,15 +112,15 @@ TEST_CASE("vmath/mat") {
int2x2 v1(1,2,3,4);
int2x2 v2(4,5,6,7);
v1.swap(v2);
REQUIRE(v1 == int2x2(4,5,6,7));
REQUIRE(v2 == int2x2(1,2,3,4));
CHECK(v1 == int2x2(4,5,6,7));
CHECK(v2 == int2x2(1,2,3,4));
}
{
int2x2 v1(1,2,3,4);
int2x2 v2(4,5,6,7);
swap(v1, v2);
REQUIRE(v1 == int2x2(4,5,6,7));
REQUIRE(v2 == int2x2(1,2,3,4));
CHECK(v1 == int2x2(4,5,6,7));
CHECK(v2 == int2x2(1,2,3,4));
}
}
@@ -128,121 +128,121 @@ TEST_CASE("vmath/mat") {
{
int2x2 m{1,2,3,4};
REQUIRE(*m.begin() == vec{1,2});
REQUIRE(*(m.begin() + 1) == vec{3,4});
REQUIRE(*(m.end() - 1) == vec{3,4});
REQUIRE(*(m.end() - 2) == vec{1,2});
REQUIRE(m.begin() + 2 == m.end());
REQUIRE(m.end() - 2 == m.begin());
CHECK(*m.begin() == vec{1,2});
CHECK(*(m.begin() + 1) == vec{3,4});
CHECK(*(m.end() - 1) == vec{3,4});
CHECK(*(m.end() - 2) == vec{1,2});
CHECK(m.begin() + 2 == m.end());
CHECK(m.end() - 2 == m.begin());
REQUIRE(*m.cbegin() == vec{1,2});
REQUIRE(*(m.cbegin() + 1) == vec{3,4});
REQUIRE(*(m.cend() - 1) == vec{3,4});
REQUIRE(*(m.cend() - 2) == vec{1,2});
REQUIRE(m.cbegin() + 2 == m.cend());
REQUIRE(m.cend() - 2 == m.cbegin());
CHECK(*m.cbegin() == vec{1,2});
CHECK(*(m.cbegin() + 1) == vec{3,4});
CHECK(*(m.cend() - 1) == vec{3,4});
CHECK(*(m.cend() - 2) == vec{1,2});
CHECK(m.cbegin() + 2 == m.cend());
CHECK(m.cend() - 2 == m.cbegin());
REQUIRE(*m.rbegin() == vec{3,4});
REQUIRE(*(m.rbegin() + 1) == vec{1,2});
REQUIRE(*(m.rend() - 1) == vec{1,2});
REQUIRE(*(m.rend() - 2) == vec{3,4});
REQUIRE(m.rbegin() + 2 == m.rend());
REQUIRE(m.rend() - 2 == m.rbegin());
CHECK(*m.rbegin() == vec{3,4});
CHECK(*(m.rbegin() + 1) == vec{1,2});
CHECK(*(m.rend() - 1) == vec{1,2});
CHECK(*(m.rend() - 2) == vec{3,4});
CHECK(m.rbegin() + 2 == m.rend());
CHECK(m.rend() - 2 == m.rbegin());
REQUIRE(*m.crbegin() == vec{3,4});
REQUIRE(*(m.crbegin() + 1) == vec{1,2});
REQUIRE(*(m.crend() - 1) == vec{1,2});
REQUIRE(*(m.crend() - 2) == vec{3,4});
REQUIRE(m.crbegin() + 2 == m.crend());
REQUIRE(m.crend() - 2 == m.crbegin());
CHECK(*m.crbegin() == vec{3,4});
CHECK(*(m.crbegin() + 1) == vec{1,2});
CHECK(*(m.crend() - 1) == vec{1,2});
CHECK(*(m.crend() - 2) == vec{3,4});
CHECK(m.crbegin() + 2 == m.crend());
CHECK(m.crend() - 2 == m.crbegin());
*m.begin() = {5,6};
REQUIRE(m == int2x2{5,6,3,4});
CHECK(m == int2x2{5,6,3,4});
*m.rbegin() = {7,8};
REQUIRE(m == int2x2{5,6,7,8});
CHECK(m == int2x2{5,6,7,8});
}
{
const int2x2 m{1,2,3,4};
REQUIRE(*m.begin() == vec{1,2});
REQUIRE(*(m.begin() + 1) == vec{3,4});
REQUIRE(*(m.end() - 1) == vec{3,4});
REQUIRE(*(m.end() - 2) == vec{1,2});
REQUIRE(m.begin() + 2 == m.end());
REQUIRE(m.end() - 2 == m.begin());
CHECK(*m.begin() == vec{1,2});
CHECK(*(m.begin() + 1) == vec{3,4});
CHECK(*(m.end() - 1) == vec{3,4});
CHECK(*(m.end() - 2) == vec{1,2});
CHECK(m.begin() + 2 == m.end());
CHECK(m.end() - 2 == m.begin());
REQUIRE(*m.cbegin() == vec{1,2});
REQUIRE(*(m.cbegin() + 1) == vec{3,4});
REQUIRE(*(m.cend() - 1) == vec{3,4});
REQUIRE(*(m.cend() - 2) == vec{1,2});
REQUIRE(m.cbegin() + 2 == m.cend());
REQUIRE(m.cend() - 2 == m.cbegin());
CHECK(*m.cbegin() == vec{1,2});
CHECK(*(m.cbegin() + 1) == vec{3,4});
CHECK(*(m.cend() - 1) == vec{3,4});
CHECK(*(m.cend() - 2) == vec{1,2});
CHECK(m.cbegin() + 2 == m.cend());
CHECK(m.cend() - 2 == m.cbegin());
REQUIRE(*m.rbegin() == vec{3,4});
REQUIRE(*(m.rbegin() + 1) == vec{1,2});
REQUIRE(*(m.rend() - 1) == vec{1,2});
REQUIRE(*(m.rend() - 2) == vec{3,4});
REQUIRE(m.rbegin() + 2 == m.rend());
REQUIRE(m.rend() - 2 == m.rbegin());
CHECK(*m.rbegin() == vec{3,4});
CHECK(*(m.rbegin() + 1) == vec{1,2});
CHECK(*(m.rend() - 1) == vec{1,2});
CHECK(*(m.rend() - 2) == vec{3,4});
CHECK(m.rbegin() + 2 == m.rend());
CHECK(m.rend() - 2 == m.rbegin());
REQUIRE(*m.crbegin() == vec{3,4});
REQUIRE(*(m.crbegin() + 1) == vec{1,2});
REQUIRE(*(m.crend() - 1) == vec{1,2});
REQUIRE(*(m.crend() - 2) == vec{3,4});
REQUIRE(m.crbegin() + 2 == m.crend());
REQUIRE(m.crend() - 2 == m.crbegin());
CHECK(*m.crbegin() == vec{3,4});
CHECK(*(m.crbegin() + 1) == vec{1,2});
CHECK(*(m.crend() - 1) == vec{1,2});
CHECK(*(m.crend() - 2) == vec{3,4});
CHECK(m.crbegin() + 2 == m.crend());
CHECK(m.crend() - 2 == m.crbegin());
}
}
SUBCASE("data") {
{
int2x2 m2;
REQUIRE(m2.data() == &m2[0]);
CHECK(m2.data() == &m2[0]);
int3x3 m3;
REQUIRE(m3.data() == &m3[0]);
CHECK(m3.data() == &m3[0]);
int4x4 m4;
REQUIRE(m4.data() == &m4[0]);
CHECK(m4.data() == &m4[0]);
}
{
const int2x2 m2;
REQUIRE(m2.data() == &m2[0]);
CHECK(m2.data() == &m2[0]);
const int3x3 m3;
REQUIRE(m3.data() == &m3[0]);
CHECK(m3.data() == &m3[0]);
const int4x4 m4;
REQUIRE(m4.data() == &m4[0]);
CHECK(m4.data() == &m4[0]);
}
}
SUBCASE("operator[]") {
{
STATIC_REQUIRE(int2x2()[0] == int2(1,0));
STATIC_REQUIRE(int2x2()[1] == int2(0,1));
STATIC_CHECK(int2x2()[0] == int2(1,0));
STATIC_CHECK(int2x2()[1] == int2(0,1));
STATIC_REQUIRE(int3x3()[0] == int3(1,0,0));
STATIC_REQUIRE(int3x3()[1] == int3(0,1,0));
STATIC_REQUIRE(int3x3()[2] == int3(0,0,1));
STATIC_CHECK(int3x3()[0] == int3(1,0,0));
STATIC_CHECK(int3x3()[1] == int3(0,1,0));
STATIC_CHECK(int3x3()[2] == int3(0,0,1));
STATIC_REQUIRE(int4x4()[0] == int4(1,0,0,0));
STATIC_REQUIRE(int4x4()[1] == int4(0,1,0,0));
STATIC_REQUIRE(int4x4()[2] == int4(0,0,1,0));
STATIC_REQUIRE(int4x4()[3] == int4(0,0,0,1));
STATIC_CHECK(int4x4()[0] == int4(1,0,0,0));
STATIC_CHECK(int4x4()[1] == int4(0,1,0,0));
STATIC_CHECK(int4x4()[2] == int4(0,0,1,0));
STATIC_CHECK(int4x4()[3] == int4(0,0,0,1));
}
{
int2x2 v;
v[0] = int2(1,2);
v[1] = int2(3,4);
REQUIRE(v == int2x2(1,2,3,4));
CHECK(v == int2x2(1,2,3,4));
}
{
int3x3 v;
v[0] = int3(1,2,3);
v[1] = int3(4,5,6);
v[2] = int3(7,8,9);
REQUIRE(v == int3x3(1,2,3,4,5,6,7,8,9));
CHECK(v == int3x3(1,2,3,4,5,6,7,8,9));
}
{
int4x4 v;
@@ -250,33 +250,35 @@ TEST_CASE("vmath/mat") {
v[1] = int4(5,6,7,8);
v[2] = int4(9,10,11,12);
v[3] = int4(13,14,15,16);
REQUIRE(v == int4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16));
CHECK(v == int4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16));
}
}
SUBCASE("at") {
STATIC_REQUIRE(int2x2(1,2,3,4).at(0) == int2(1,2));
STATIC_REQUIRE(int2x2(1,2,3,4).at(1) == int2(3,4));
REQUIRE_THROWS_AS((void)int2x2(1,2,3,4).at(2), std::out_of_range);
STATIC_CHECK(int2x2(1,2,3,4).at(0) == int2(1,2));
STATIC_CHECK(int2x2(1,2,3,4).at(1) == int2(3,4));
#ifndef VMATH_HPP_NO_EXCEPTIONS
CHECK_THROWS_AS((void)int2x2(1,2,3,4).at(2), std::out_of_range);
#endif
}
SUBCASE("operator==/operator!=") {
STATIC_REQUIRE(int2x2(1,2,3,4) == int2x2(1,2,3,4));
STATIC_REQUIRE_FALSE(int2x2(1,2,3,4) == int2x2(2,2,3,4));
STATIC_REQUIRE_FALSE(int2x2(1,2,3,4) == int2x2(1,3,3,4));
STATIC_CHECK(int2x2(1,2,3,4) == int2x2(1,2,3,4));
STATIC_CHECK_FALSE(int2x2(1,2,3,4) == int2x2(2,2,3,4));
STATIC_CHECK_FALSE(int2x2(1,2,3,4) == int2x2(1,3,3,4));
STATIC_REQUIRE_FALSE(int2x2(1,2,3,4) != int2x2(1,2,3,4));
STATIC_REQUIRE(int2x2(1,2,3,4) != int2x2(2,2,3,4));
STATIC_REQUIRE(int2x2(1,2,3,4) != int2x2(1,3,3,4));
STATIC_CHECK_FALSE(int2x2(1,2,3,4) != int2x2(1,2,3,4));
STATIC_CHECK(int2x2(1,2,3,4) != int2x2(2,2,3,4));
STATIC_CHECK(int2x2(1,2,3,4) != int2x2(1,3,3,4));
}
SUBCASE("operator<") {
STATIC_REQUIRE_FALSE(int2x2(1,2,3,4) < int2x2(1,2,3,4));
STATIC_CHECK_FALSE(int2x2(1,2,3,4) < int2x2(1,2,3,4));
STATIC_REQUIRE(int2x2(1,1,3,4) < int2x2(1,2,3,4));
STATIC_REQUIRE_FALSE(int2x2(1,2,3,4) < int2x2(1,1,3,4));
STATIC_CHECK(int2x2(1,1,3,4) < int2x2(1,2,3,4));
STATIC_CHECK_FALSE(int2x2(1,2,3,4) < int2x2(1,1,3,4));
STATIC_REQUIRE(int2x2(0,3,3,4) < int2x2(1,2,3,4));
STATIC_REQUIRE_FALSE(int2x2(1,2,3,4) < int2x2(0,3,3,4));
STATIC_CHECK(int2x2(0,3,3,4) < int2x2(1,2,3,4));
STATIC_CHECK_FALSE(int2x2(1,2,3,4) < int2x2(0,3,3,4));
}
}

138
untests/vmath_qua_fun_tests.cpp
View File

@@ -14,168 +14,168 @@ namespace
TEST_CASE("vmath/qua_fun") {
SUBCASE("Operators") {
STATIC_REQUIRE(+qua(1,-2,3,-4) == qua(1,-2,3,-4));
STATIC_REQUIRE(-qua(1,-2,3,-4) == qua(-1,2,-3,4));
STATIC_CHECK(+qua(1,-2,3,-4) == qua(1,-2,3,-4));
STATIC_CHECK(-qua(1,-2,3,-4) == qua(-1,2,-3,4));
STATIC_REQUIRE(qua(1,2,3,4) + qua(3,4,5,6) == qua(4,6,8,10));
STATIC_REQUIRE(qua(1,2,3,4) - qua(3,5,7,9) == qua(-2,-3,-4,-5));
STATIC_CHECK(qua(1,2,3,4) + qua(3,4,5,6) == qua(4,6,8,10));
STATIC_CHECK(qua(1,2,3,4) - qua(3,5,7,9) == qua(-2,-3,-4,-5));
{
qua v{1,2,3,4};
REQUIRE(&v == &(v += qua{3,4,5,6}));
REQUIRE(v == qua{4,6,8,10});
CHECK(&v == &(v += qua{3,4,5,6}));
CHECK(v == qua{4,6,8,10});
}
{
qua v{1,2,3,4};
REQUIRE(&v == &(v -= qua{3,4,5,6}));
REQUIRE(v == qua{-2,-2,-2,-2});
CHECK(&v == &(v -= qua{3,4,5,6}));
CHECK(v == qua{-2,-2,-2,-2});
}
STATIC_REQUIRE(qua(1,2,3,4) * 2 == qua(2,4,6,8));
STATIC_REQUIRE(qua(2,4,6,8) / 2 == qua(1,2,3,4));
STATIC_CHECK(qua(1,2,3,4) * 2 == qua(2,4,6,8));
STATIC_CHECK(qua(2,4,6,8) / 2 == qua(1,2,3,4));
STATIC_REQUIRE(2 * qua(1,2,3,4) == qua(2,4,6,8));
STATIC_REQUIRE(8 / qua(1,2,4,8) == qua(8,4,2,1));
STATIC_CHECK(2 * qua(1,2,3,4) == qua(2,4,6,8));
STATIC_CHECK(8 / qua(1,2,4,8) == qua(8,4,2,1));
{
qua v{1,2,3,4};
REQUIRE(&v == &(v *= 2));
REQUIRE(v == qua{2,4,6,8});
REQUIRE(&v == &(v *= qua<int>{}));
REQUIRE(v == qua{2,4,6,8});
CHECK(&v == &(v *= 2));
CHECK(v == qua{2,4,6,8});
CHECK(&v == &(v *= qua<int>{}));
CHECK(v == qua{2,4,6,8});
}
{
qua v{2,4,6,8};
REQUIRE(&v == &(v /= 2));
REQUIRE(v == qua{1,2,3,4});
CHECK(&v == &(v /= 2));
CHECK(v == qua{1,2,3,4});
}
{
float3 v{1,0,0};
REQUIRE(&v == &(v *= qfloat{0,0,0.7071067812f,0.7071067812f}));
REQUIRE(v == uapprox3(0.f,1.f,0.f));
CHECK(&v == &(v *= qfloat{0,0,0.7071067812f,0.7071067812f}));
CHECK(v == uapprox3(0.f,1.f,0.f));
}
STATIC_REQUIRE(qfloat{} * qfloat{} == qfloat{});
STATIC_REQUIRE(float3{1,2,3} * qfloat{} == uapprox3(1.f,2.f,3.f));
STATIC_REQUIRE(float3{1,0,0} * qfloat{0,0,0.7071067812f,0.7071067812f} == uapprox3(0.f,1.f,0.f));
STATIC_CHECK(qfloat{} * qfloat{} == qfloat{});
STATIC_CHECK(float3{1,2,3} * qfloat{} == uapprox3(1.f,2.f,3.f));
STATIC_CHECK(float3{1,0,0} * qfloat{0,0,0.7071067812f,0.7071067812f} == uapprox3(0.f,1.f,0.f));
}
SUBCASE("Common Functions") {
{
REQUIRE(all(approx(
CHECK(all(approx(
qrotate_z(radians(5.f)),
nlerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 0.f),
0.00001f)));
REQUIRE(all(approx(
CHECK(all(approx(
qrotate_z(radians(6.f)),
nlerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 0.1f),
0.00001f)));
REQUIRE(all(approx(
CHECK(all(approx(
qrotate_z(radians(10.f)),
nlerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 0.5f),
0.00001f)));
REQUIRE(all(approx(
CHECK(all(approx(
qrotate_z(radians(15.f)),
nlerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 1.f),
0.00001f)));
REQUIRE(all(approx(
CHECK(all(approx(
qrotate_z(radians(315.f)),
nlerp(qrotate_z(radians(270.f)), qrotate_z(radians(0.f)), 0.5f))));
REQUIRE(all(approx(
CHECK(all(approx(
qrotate_z(radians(290.f)),
nlerp(qrotate_z(radians(220.f)), qrotate_z(radians(0.f)), 0.5f))));
}
{
REQUIRE(all(approx(
CHECK(all(approx(
qrotate_z(radians(5.f)),
slerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 0.f),
0.00001f)));
REQUIRE(all(approx(
CHECK(all(approx(
qrotate_z(radians(6.f)),
slerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 0.1f),
0.00001f)));
REQUIRE(all(approx(
CHECK(all(approx(
qrotate_z(radians(10.f)),
slerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 0.5f),
0.00001f)));
REQUIRE(all(approx(
CHECK(all(approx(
qrotate_z(radians(15.f)),
slerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 1.f),
0.00001f)));
REQUIRE(all(approx(
CHECK(all(approx(
qrotate_z(radians(0.f)),
slerp(qrotate_z(radians(0.f)), qrotate_z(radians(0.f)), 0.5f))));
REQUIRE(all(approx(
CHECK(all(approx(
qrotate_z(radians(0.25f)),
slerp(qrotate_z(radians(0.f)), qrotate_z(radians(0.5f)), 0.5f))));
REQUIRE(all(approx(
CHECK(all(approx(
qrotate_z(radians(-45.f)),
slerp(qrotate_z(radians(0.f)), qrotate_z(radians(270.f)), 0.5f))));
REQUIRE(all(approx(
CHECK(all(approx(
qrotate_z(radians(-70.f)),
slerp(qrotate_z(radians(0.f)), qrotate_z(radians(220.f)), 0.5f))));
REQUIRE(all(approx(
CHECK(all(approx(
qrotate_z(radians(315.f)),
slerp(qrotate_z(radians(270.f)), qrotate_z(radians(0.f)), 0.5f))));
REQUIRE(all(approx(
CHECK(all(approx(
qrotate_z(radians(290.f)),
slerp(qrotate_z(radians(220.f)), qrotate_z(radians(0.f)), 0.5f))));
}
{
REQUIRE_FALSE(any(isnan(qfloat(1,1,1,1))));
REQUIRE_FALSE(any(isinf(qfloat(1,1,1,1))));
REQUIRE(all(isfinite(qfloat(1,1,1,1))));
CHECK_FALSE(any(isnan(qfloat(1,1,1,1))));
CHECK_FALSE(any(isinf(qfloat(1,1,1,1))));
CHECK(all(isfinite(qfloat(1,1,1,1))));
}
}
SUBCASE("Geometric Functions") {
STATIC_REQUIRE(dot(qua(1,2,3,4),qua(3,4,5,6)) == 50);
STATIC_CHECK(dot(qua(1,2,3,4),qua(3,4,5,6)) == 50);
REQUIRE(length(qfloat(10.f,0.f,0.f,0.f)) == uapprox(10.f));
REQUIRE(length(qfloat(-10.f,0.f,0.f,0.f)) == uapprox(10.f));
CHECK(length(qfloat(10.f,0.f,0.f,0.f)) == uapprox(10.f));
CHECK(length(qfloat(-10.f,0.f,0.f,0.f)) == uapprox(10.f));
STATIC_REQUIRE(length2(qfloat(10.f,0.f,0.f,0.f)) == uapprox(100.f));
STATIC_REQUIRE(length2(qfloat(-10.f,0.f,0.f,0.f)) == uapprox(100.f));
STATIC_CHECK(length2(qfloat(10.f,0.f,0.f,0.f)) == uapprox(100.f));
STATIC_CHECK(length2(qfloat(-10.f,0.f,0.f,0.f)) == uapprox(100.f));
REQUIRE(distance(qrotate_z(radians(0.f)) * 2.f, qrotate_z(radians(0.f)) * 1.5f) == uapprox(radians(0.f)));
REQUIRE(distance(qrotate_z(radians(0.f)) * 3.f, qrotate_z(radians(360.f)) * 2.5f) == uapprox(radians(0.f)));
REQUIRE(distance(qrotate_z(radians(0.f)) * 4.f, qrotate_z(radians(180.f)) * 3.5f) == uapprox(radians(180.f)));
REQUIRE(distance(qrotate_z(radians(180.f)) * 5.f, qrotate_z(radians(0.f)) * 4.5f) == uapprox(radians(180.f)));
REQUIRE(distance(qrotate_z(radians(15.f)) * 6.f, qrotate_z(radians(350.f)) * 5.5f) == uapprox(radians(25.f)));
REQUIRE(distance(qrotate_z(radians(350.f)) * 7.f, qrotate_z(radians(15.f)) * 6.5f) == uapprox(radians(25.f)));
CHECK(distance(qrotate_z(radians(0.f)) * 2.f, qrotate_z(radians(0.f)) * 1.5f) == uapprox(radians(0.f)));
CHECK(distance(qrotate_z(radians(0.f)) * 3.f, qrotate_z(radians(360.f)) * 2.5f) == uapprox(radians(0.f)));
CHECK(distance(qrotate_z(radians(0.f)) * 4.f, qrotate_z(radians(180.f)) * 3.5f) == uapprox(radians(180.f)));
CHECK(distance(qrotate_z(radians(180.f)) * 5.f, qrotate_z(radians(0.f)) * 4.5f) == uapprox(radians(180.f)));
CHECK(distance(qrotate_z(radians(15.f)) * 6.f, qrotate_z(radians(350.f)) * 5.5f) == uapprox(radians(25.f)));
CHECK(distance(qrotate_z(radians(350.f)) * 7.f, qrotate_z(radians(15.f)) * 6.5f) == uapprox(radians(25.f)));
REQUIRE(normalize(qfloat(0.5f,0.f,0.f,0.f)).v == uapprox3(1.f,0.f,0.f));
CHECK(normalize(qfloat(0.5f,0.f,0.f,0.f)).v == uapprox3(1.f,0.f,0.f));
}
SUBCASE("Relational Functions") {
STATIC_REQUIRE(approx(qua(1,1,1,1), qua(0,1,2,3)) == bool4(false, true, false, false));
STATIC_REQUIRE(approx(qua(1,1,1,1), qua(0,1,2,3), 0) == bool4(false, true, false, false));
STATIC_REQUIRE(approx(qua(1,1,1,1), qua(0,1,2,3), 1) == bool4(true, true, true, false));
STATIC_REQUIRE(approx(qua(1,1,1,1), qua(0,1,2,3), 2) == bool4(true, true, true, true));
STATIC_CHECK(approx(qua(1,1,1,1), qua(0,1,2,3)) == bool4(false, true, false, false));
STATIC_CHECK(approx(qua(1,1,1,1), qua(0,1,2,3), 0) == bool4(false, true, false, false));
STATIC_CHECK(approx(qua(1,1,1,1), qua(0,1,2,3), 1) == bool4(true, true, true, false));
STATIC_CHECK(approx(qua(1,1,1,1), qua(0,1,2,3), 2) == bool4(true, true, true, true));
STATIC_REQUIRE(less(qua(1,1,1,1), qua(0,1,2,3)) == bool4(false, false, true, true));
STATIC_REQUIRE(less_equal(qua(1,1,1,1), qua(0,1,2,3)) == bool4(false, true, true, true));
STATIC_REQUIRE(greater(qua(1,1,1,1), qua(0,1,2,3)) == bool4(true, false, false, false));
STATIC_REQUIRE(greater_equal(qua(1,1,1,1), qua(0,1,2,3)) == bool4(true, true, false, false));
STATIC_CHECK(less(qua(1,1,1,1), qua(0,1,2,3)) == bool4(false, false, true, true));
STATIC_CHECK(less_equal(qua(1,1,1,1), qua(0,1,2,3)) == bool4(false, true, true, true));
STATIC_CHECK(greater(qua(1,1,1,1), qua(0,1,2,3)) == bool4(true, false, false, false));
STATIC_CHECK(greater_equal(qua(1,1,1,1), qua(0,1,2,3)) == bool4(true, true, false, false));
STATIC_REQUIRE(equal_to(qua(1,1,1,1), qua(0,1,2,3)) == bool4(false, true, false, false));
STATIC_REQUIRE(not_equal_to(qua(1,1,1,1), qua(0,1,2,3)) == bool4(true, false, true, true));
STATIC_CHECK(equal_to(qua(1,1,1,1), qua(0,1,2,3)) == bool4(false, true, false, false));
STATIC_CHECK(not_equal_to(qua(1,1,1,1), qua(0,1,2,3)) == bool4(true, false, true, true));
}
SUBCASE("Quaternion Functions") {
STATIC_REQUIRE(conjugate(qua(1,2,3,4)) == qua(-1,-2,-3,4));
STATIC_REQUIRE(inverse(qua(0.f,0.f,0.7071067812f,0.7071067812f)).v == uapprox3(0.f,0.f,-0.7071067812f));
STATIC_REQUIRE(inverse(qua(0.f,0.f,0.7071067812f,0.7071067812f)).s == uapprox(0.7071067812f));
STATIC_CHECK(conjugate(qua(1,2,3,4)) == qua(-1,-2,-3,4));
STATIC_CHECK(inverse(qua(0.f,0.f,0.7071067812f,0.7071067812f)).v == uapprox3(0.f,0.f,-0.7071067812f));
STATIC_CHECK(inverse(qua(0.f,0.f,0.7071067812f,0.7071067812f)).s == uapprox(0.7071067812f));
REQUIRE(inverse(qrotate_x(10.f)) == qrotate_x(-10.f));
REQUIRE(all(approx(inverse(qrotate_x(10.f) * qrotate_y(15.f)), qrotate_y(-15.f) * qrotate_x(-10.f))));
CHECK(inverse(qrotate_x(10.f)) == qrotate_x(-10.f));
CHECK(all(approx(inverse(qrotate_x(10.f) * qrotate_y(15.f)), qrotate_y(-15.f) * qrotate_x(-10.f))));
}
}

220
untests/vmath_qua_tests.cpp
View File

@@ -14,49 +14,49 @@ namespace
TEST_CASE("vmath/qua") {
SUBCASE("size/sizeof") {
STATIC_REQUIRE(qfloat{}.size == 4);
STATIC_REQUIRE(qdouble{}.size == 4);
STATIC_CHECK(qfloat{}.size == 4);
STATIC_CHECK(qdouble{}.size == 4);
STATIC_REQUIRE(sizeof(qfloat{}) == sizeof(float) * 4);
STATIC_REQUIRE(sizeof(qdouble{}) == sizeof(double) * 4);
STATIC_CHECK(sizeof(qfloat{}) == sizeof(float) * 4);
STATIC_CHECK(sizeof(qdouble{}) == sizeof(double) * 4);
}
SUBCASE("guides") {
STATIC_REQUIRE(qua{1,2,3,4}.size == 4);
STATIC_REQUIRE(qua{{1,2,3},4}.size == 4);
STATIC_REQUIRE(qua{vec{1,2,3},4}.size == 4);
STATIC_REQUIRE(qua{{1,2,3,4}}.size == 4);
STATIC_REQUIRE(qua(vec{1,2,3,4}).size == 4);
STATIC_CHECK(qua{1,2,3,4}.size == 4);
STATIC_CHECK(qua{{1,2,3},4}.size == 4);
STATIC_CHECK(qua{vec{1,2,3},4}.size == 4);
STATIC_CHECK(qua{{1,2,3,4}}.size == 4);
STATIC_CHECK(qua(vec{1,2,3,4}).size == 4);
}
SUBCASE("ctors") {
{
STATIC_REQUIRE(qfloat{}.v == uapprox3(0.f));
STATIC_REQUIRE(qfloat{}.s == uapprox(1.f));
STATIC_CHECK(qfloat{}.v == uapprox3(0.f));
STATIC_CHECK(qfloat{}.s == uapprox(1.f));
STATIC_REQUIRE(qfloat{1,2,3,4}.v == uapprox3(1.f,2.f,3.f));
STATIC_REQUIRE(qfloat{1,2,3,4}.s == uapprox(4.f));
STATIC_CHECK(qfloat{1,2,3,4}.v == uapprox3(1.f,2.f,3.f));
STATIC_CHECK(qfloat{1,2,3,4}.s == uapprox(4.f));
STATIC_REQUIRE(qfloat{{1,2,3},4}.v == uapprox3(1.f,2.f,3.f));
STATIC_REQUIRE(qfloat{{1,2,3},4}.s == uapprox(4.f));
STATIC_CHECK(qfloat{{1,2,3},4}.v == uapprox3(1.f,2.f,3.f));
STATIC_CHECK(qfloat{{1,2,3},4}.s == uapprox(4.f));
STATIC_REQUIRE(qfloat{{1,2,3,4}}.v == uapprox3(1.f,2.f,3.f));
STATIC_REQUIRE(qfloat{{1,2,3,4}}.s == uapprox(4.f));
STATIC_CHECK(qfloat{{1,2,3,4}}.v == uapprox3(1.f,2.f,3.f));
STATIC_CHECK(qfloat{{1,2,3,4}}.s == uapprox(4.f));
}
{
constexpr qfloat q(1,2,3,4);
constexpr qfloat q2 = q;
STATIC_REQUIRE(q2 == qfloat(1,2,3,4));
STATIC_CHECK(q2 == qfloat(1,2,3,4));
}
{
constexpr qfloat q(1,2,3,4);
constexpr qfloat q2 = std::move(q);
STATIC_REQUIRE(q2 == qfloat(1,2,3,4));
STATIC_CHECK(q2 == qfloat(1,2,3,4));
}
{
STATIC_REQUIRE(qfloat(1,2,3,4) == qfloat(1,2,3,4));
STATIC_REQUIRE(qfloat(float3(1,2,3),4) == qfloat(1,2,3,4));
STATIC_REQUIRE(qfloat(float4(1,2,3,4)) == qfloat(1,2,3,4));
STATIC_CHECK(qfloat(1,2,3,4) == qfloat(1,2,3,4));
STATIC_CHECK(qfloat(float3(1,2,3),4) == qfloat(1,2,3,4));
STATIC_CHECK(qfloat(float4(1,2,3,4)) == qfloat(1,2,3,4));
}
}
@@ -65,13 +65,13 @@ TEST_CASE("vmath/qua") {
qfloat v(1,2,3,4);
qfloat v2;
v2 = v;
REQUIRE(v2 == qfloat(1,2,3,4));
CHECK(v2 == qfloat(1,2,3,4));
}
{
qfloat v(1,2,3,4);
qfloat v2;
v2 = std::move(v);
REQUIRE(v2 == qfloat(1,2,3,4));
CHECK(v2 == qfloat(1,2,3,4));
}
}
@@ -80,15 +80,15 @@ TEST_CASE("vmath/qua") {
qfloat v1(1,2,3,4);
qfloat v2(4,5,6,7);
v1.swap(v2);
REQUIRE(v1 == qfloat(4,5,6,7));
REQUIRE(v2 == qfloat(1,2,3,4));
CHECK(v1 == qfloat(4,5,6,7));
CHECK(v2 == qfloat(1,2,3,4));
}
{
qfloat v1(1,2,3,4);
qfloat v2(4,5,6,7);
swap(v1, v2);
REQUIRE(v1 == qfloat(4,5,6,7));
REQUIRE(v2 == qfloat(1,2,3,4));
CHECK(v1 == qfloat(4,5,6,7));
CHECK(v2 == qfloat(1,2,3,4));
}
}
@@ -96,134 +96,136 @@ TEST_CASE("vmath/qua") {
{
qfloat v{1,2,3,4};
REQUIRE(*v.begin() == 1);
REQUIRE(*(v.begin() + 1) == 2);
REQUIRE(*(v.end() - 1) == 4);
REQUIRE(*(v.end() - 2) == 3);
REQUIRE(v.begin() + 4 == v.end());
REQUIRE(v.end() - 4 == v.begin());
CHECK(*v.begin() == 1);
CHECK(*(v.begin() + 1) == 2);
CHECK(*(v.end() - 1) == 4);
CHECK(*(v.end() - 2) == 3);
CHECK(v.begin() + 4 == v.end());
CHECK(v.end() - 4 == v.begin());
REQUIRE(*v.cbegin() == 1);
REQUIRE(*(v.cbegin() + 1) == 2);
REQUIRE(*(v.cend() - 1) == 4);
REQUIRE(*(v.cend() - 2) == 3);
REQUIRE(v.cbegin() + 4 == v.cend());
REQUIRE(v.cend() - 4 == v.cbegin());
CHECK(*v.cbegin() == 1);
CHECK(*(v.cbegin() + 1) == 2);
CHECK(*(v.cend() - 1) == 4);
CHECK(*(v.cend() - 2) == 3);
CHECK(v.cbegin() + 4 == v.cend());
CHECK(v.cend() - 4 == v.cbegin());
REQUIRE(*v.rbegin() == 4);
REQUIRE(*(v.rbegin() + 1) == 3);
REQUIRE(*(v.rend() - 1) == 1);
REQUIRE(*(v.rend() - 2) == 2);
REQUIRE(v.rbegin() + 4 == v.rend());
REQUIRE(v.rend() - 4 == v.rbegin());
CHECK(*v.rbegin() == 4);
CHECK(*(v.rbegin() + 1) == 3);
CHECK(*(v.rend() - 1) == 1);
CHECK(*(v.rend() - 2) == 2);
CHECK(v.rbegin() + 4 == v.rend());
CHECK(v.rend() - 4 == v.rbegin());
REQUIRE(*v.crbegin() == 4);
REQUIRE(*(v.crbegin() + 1) == 3);
REQUIRE(*(v.crend() - 1) == 1);
REQUIRE(*(v.crend() - 2) == 2);
REQUIRE(v.crbegin() + 4 == v.crend());
REQUIRE(v.crend() - 4 == v.crbegin());
CHECK(*v.crbegin() == 4);
CHECK(*(v.crbegin() + 1) == 3);
CHECK(*(v.crend() - 1) == 1);
CHECK(*(v.crend() - 2) == 2);
CHECK(v.crbegin() + 4 == v.crend());
CHECK(v.crend() - 4 == v.crbegin());
*v.begin() = 3;
REQUIRE(v == qfloat{3,2,3,4});
CHECK(v == qfloat{3,2,3,4});
*v.rbegin() = 5;
REQUIRE(v == qfloat{3,2,3,5});
CHECK(v == qfloat{3,2,3,5});
}
{
const qfloat v{1,2,3,4};
REQUIRE(*v.begin() == 1);
REQUIRE(*(v.begin() + 1) == 2);
REQUIRE(*(v.end() - 1) == 4);
REQUIRE(*(v.end() - 2) == 3);
REQUIRE(v.begin() + 4 == v.end());
REQUIRE(v.end() - 4 == v.begin());
CHECK(*v.begin() == 1);
CHECK(*(v.begin() + 1) == 2);
CHECK(*(v.end() - 1) == 4);
CHECK(*(v.end() - 2) == 3);
CHECK(v.begin() + 4 == v.end());
CHECK(v.end() - 4 == v.begin());
REQUIRE(*v.cbegin() == 1);
REQUIRE(*(v.cbegin() + 1) == 2);
REQUIRE(*(v.cend() - 1) == 4);
REQUIRE(*(v.cend() - 2) == 3);
REQUIRE(v.cbegin() + 4 == v.cend());
REQUIRE(v.cend() - 4 == v.cbegin());
CHECK(*v.cbegin() == 1);
CHECK(*(v.cbegin() + 1) == 2);
CHECK(*(v.cend() - 1) == 4);
CHECK(*(v.cend() - 2) == 3);
CHECK(v.cbegin() + 4 == v.cend());
CHECK(v.cend() - 4 == v.cbegin());
REQUIRE(*v.rbegin() == 4);
REQUIRE(*(v.rbegin() + 1) == 3);
REQUIRE(*(v.rend() - 1) == 1);
REQUIRE(*(v.rend() - 2) == 2);
REQUIRE(v.rbegin() + 4 == v.rend());
REQUIRE(v.rend() - 4 == v.rbegin());
CHECK(*v.rbegin() == 4);
CHECK(*(v.rbegin() + 1) == 3);
CHECK(*(v.rend() - 1) == 1);
CHECK(*(v.rend() - 2) == 2);
CHECK(v.rbegin() + 4 == v.rend());
CHECK(v.rend() - 4 == v.rbegin());
REQUIRE(*v.crbegin() == 4);
REQUIRE(*(v.crbegin() + 1) == 3);
REQUIRE(*(v.crend() - 1) == 1);
REQUIRE(*(v.crend() - 2) == 2);
REQUIRE(v.crbegin() + 4 == v.crend());
REQUIRE(v.crend() - 4 == v.crbegin());
CHECK(*v.crbegin() == 4);
CHECK(*(v.crbegin() + 1) == 3);
CHECK(*(v.crend() - 1) == 1);
CHECK(*(v.crend() - 2) == 2);
CHECK(v.crbegin() + 4 == v.crend());
CHECK(v.crend() - 4 == v.crbegin());
}
}
SUBCASE("data") {
{
qfloat i2;
REQUIRE(i2.data() == &i2[0]);
CHECK(i2.data() == &i2[0]);
}
{
const qfloat i2;
REQUIRE(i2.data() == &i2[0]);
CHECK(i2.data() == &i2[0]);
}
}
SUBCASE("operator[]") {
{
STATIC_REQUIRE(qua(1,2,3,4).v == vec(1,2,3));
STATIC_REQUIRE(qua(1,2,3,4).s == 4);
STATIC_CHECK(qua(1,2,3,4).v == vec(1,2,3));
STATIC_CHECK(qua(1,2,3,4).s == 4);
}
{
STATIC_REQUIRE(qua(1,2,3,4)[0] == 1);
STATIC_REQUIRE(qua(1,2,3,4)[1] == 2);
STATIC_REQUIRE(qua(1,2,3,4)[2] == 3);
STATIC_REQUIRE(qua(1,2,3,4)[3] == 4);
STATIC_CHECK(qua(1,2,3,4)[0] == 1);
STATIC_CHECK(qua(1,2,3,4)[1] == 2);
STATIC_CHECK(qua(1,2,3,4)[2] == 3);
STATIC_CHECK(qua(1,2,3,4)[3] == 4);
}
{
qua<int> v;
v.v = vec(1,2,3);
v.s = 4;
REQUIRE(v == qua(1,2,3,4));
CHECK(v == qua(1,2,3,4));
}
}
SUBCASE("at") {
STATIC_REQUIRE(qfloat(1,2,3,4).at(0) == 1);
STATIC_REQUIRE(qfloat(1,2,3,4).at(1) == 2);
STATIC_REQUIRE(qfloat(1,2,3,4).at(2) == 3);
STATIC_REQUIRE(qfloat(1,2,3,4).at(3) == 4);
REQUIRE_THROWS_AS((void)qfloat(1,2,3,4).at(4), std::out_of_range);
STATIC_CHECK(qfloat(1,2,3,4).at(0) == 1);
STATIC_CHECK(qfloat(1,2,3,4).at(1) == 2);
STATIC_CHECK(qfloat(1,2,3,4).at(2) == 3);
STATIC_CHECK(qfloat(1,2,3,4).at(3) == 4);
#ifndef VMATH_HPP_NO_EXCEPTIONS
CHECK_THROWS_AS((void)qfloat(1,2,3,4).at(4), std::out_of_range);
#endif
}
SUBCASE("operator==/operator!=") {
STATIC_REQUIRE(qfloat(1,2,3,4) == qfloat(1,2,3,4));
STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) == qfloat(2,2,3,4));
STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) == qfloat(1,3,3,4));
STATIC_CHECK(qfloat(1,2,3,4) == qfloat(1,2,3,4));
STATIC_CHECK_FALSE(qfloat(1,2,3,4) == qfloat(2,2,3,4));
STATIC_CHECK_FALSE(qfloat(1,2,3,4) == qfloat(1,3,3,4));
STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) != qfloat(1,2,3,4));
STATIC_REQUIRE(qfloat(1,2,3,4) != qfloat(2,2,3,4));
STATIC_REQUIRE(qfloat(1,2,3,4) != qfloat(1,3,3,4));
STATIC_CHECK_FALSE(qfloat(1,2,3,4) != qfloat(1,2,3,4));
STATIC_CHECK(qfloat(1,2,3,4) != qfloat(2,2,3,4));
STATIC_CHECK(qfloat(1,2,3,4) != qfloat(1,3,3,4));
}
SUBCASE("operator<") {
STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) < qfloat(1,2,3,4));
STATIC_CHECK_FALSE(qfloat(1,2,3,4) < qfloat(1,2,3,4));
STATIC_REQUIRE(qfloat(0,2,3,4) < qfloat(1,2,3,4));
STATIC_REQUIRE(qfloat(1,1,3,4) < qfloat(1,2,3,4));
STATIC_REQUIRE(qfloat(1,2,2,4) < qfloat(1,2,3,4));
STATIC_REQUIRE(qfloat(1,2,3,3) < qfloat(1,2,3,4));
STATIC_CHECK(qfloat(0,2,3,4) < qfloat(1,2,3,4));
STATIC_CHECK(qfloat(1,1,3,4) < qfloat(1,2,3,4));
STATIC_CHECK(qfloat(1,2,2,4) < qfloat(1,2,3,4));
STATIC_CHECK(qfloat(1,2,3,3) < qfloat(1,2,3,4));
STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) < qfloat(0,2,3,4));
STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) < qfloat(1,1,3,4));
STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) < qfloat(1,2,2,4));
STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) < qfloat(1,2,3,3));
STATIC_CHECK_FALSE(qfloat(1,2,3,4) < qfloat(0,2,3,4));
STATIC_CHECK_FALSE(qfloat(1,2,3,4) < qfloat(1,1,3,4));
STATIC_CHECK_FALSE(qfloat(1,2,3,4) < qfloat(1,2,2,4));
STATIC_CHECK_FALSE(qfloat(1,2,3,4) < qfloat(1,2,3,3));
STATIC_REQUIRE(qfloat(0,3,3,4) < qfloat(1,2,3,4));
STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) < qfloat(0,3,3,4));
STATIC_CHECK(qfloat(0,3,3,4) < qfloat(1,2,3,4));
STATIC_CHECK_FALSE(qfloat(1,2,3,4) < qfloat(0,3,3,4));
}
}

318
untests/vmath_vec_fun_tests.cpp
View File

@@ -14,124 +14,124 @@ namespace
TEST_CASE("vmath/vec_fun") {
SUBCASE("Detail") {
STATIC_REQUIRE(map_join([](const int& x){
STATIC_CHECK(map_join([](const int& x){
return x * 2;
}, int2{1}) == int2{2});
STATIC_REQUIRE(map_join([](const int& x, const int& y){
STATIC_CHECK(map_join([](const int& x, const int& y){
return x + y;
}, int2{1}, int2{1}) == int2{2});
STATIC_REQUIRE(map_join([](const int& x, const int& y, const int& z){
STATIC_CHECK(map_join([](const int& x, const int& y, const int& z){
return x + y + z;
}, int2{1}, int2{1}, int2{1}) == int2(3));
STATIC_REQUIRE(fold_join([](int acc, const int& x){
STATIC_CHECK(fold_join([](int acc, const int& x){
return acc + x;
}, 0, int2{1}) == 2);
STATIC_REQUIRE(fold_join([](int acc, const int& x, const int& y){
STATIC_CHECK(fold_join([](int acc, const int& x, const int& y){
return acc + x + y;
}, 0, int2{1}, int2{1}) == 4);
STATIC_REQUIRE(fold1_join([](const int& acc, const int& x){
STATIC_CHECK(fold1_join([](const int& acc, const int& x){
return acc + x;
}, int2{1}) == 2);
}
SUBCASE("Operators") {
STATIC_REQUIRE(+int2(1,-2) == int2(1,-2));
STATIC_REQUIRE(-int2(1,-2) == int2(-1,2));
STATIC_REQUIRE(~uint2(0xF0F0F0F0,0x0F0F0F0F) == uint2(0x0F0F0F0F,0xF0F0F0F0));
STATIC_REQUIRE(!int3(-1,0,1) == bool3(false, true, false));
STATIC_CHECK(+int2(1,-2) == int2(1,-2));
STATIC_CHECK(-int2(1,-2) == int2(-1,2));
STATIC_CHECK(~uint2(0xF0F0F0F0,0x0F0F0F0F) == uint2(0x0F0F0F0F,0xF0F0F0F0));
STATIC_CHECK(!int3(-1,0,1) == bool3(false, true, false));
STATIC_REQUIRE(int2(1,2) + 3 == int2(4,5));
STATIC_REQUIRE(int2(1,2) - 3 == int2(-2,-1));
STATIC_REQUIRE(int2(1,2) * 3 == int2(3,6));
STATIC_REQUIRE(int2(2,4) / 2 == int2(1,2));
STATIC_REQUIRE((int2(11,12) & 6) == int2(2,4));
STATIC_REQUIRE((int2(11,12) | 6) == int2(15,14));
STATIC_REQUIRE((int2(11,12) ^ 6) == int2(13,10));
STATIC_REQUIRE((int2(1,0) && 1) == bool2(1,0));
STATIC_REQUIRE((int2(1,0) || 1) == bool2(1,1));
STATIC_CHECK(int2(1,2) + 3 == int2(4,5));
STATIC_CHECK(int2(1,2) - 3 == int2(-2,-1));
STATIC_CHECK(int2(1,2) * 3 == int2(3,6));
STATIC_CHECK(int2(2,4) / 2 == int2(1,2));
STATIC_CHECK((int2(11,12) & 6) == int2(2,4));
STATIC_CHECK((int2(11,12) | 6) == int2(15,14));
STATIC_CHECK((int2(11,12) ^ 6) == int2(13,10));
STATIC_CHECK((int2(1,0) && 1) == bool2(1,0));
STATIC_CHECK((int2(1,0) || 1) == bool2(1,1));
STATIC_REQUIRE(3 + int2(1,2) == int2(4,5));
STATIC_REQUIRE(3 - int2(1,2) == int2(2,1));
STATIC_REQUIRE(3 * int2(1,2) == int2(3,6));
STATIC_REQUIRE(4 / int2(2,4) == int2(2,1));
STATIC_REQUIRE((6 & int2(11,12)) == int2(2,4));
STATIC_REQUIRE((6 | int2(11,12)) == int2(15,14));
STATIC_REQUIRE((6 ^ int2(11,12)) == int2(13,10));
STATIC_REQUIRE((1 && int2(1,0)) == bool2(1,0));
STATIC_REQUIRE((1 || int2(1,0)) == bool2(1,1));
STATIC_CHECK(3 + int2(1,2) == int2(4,5));
STATIC_CHECK(3 - int2(1,2) == int2(2,1));
STATIC_CHECK(3 * int2(1,2) == int2(3,6));
STATIC_CHECK(4 / int2(2,4) == int2(2,1));
STATIC_CHECK((6 & int2(11,12)) == int2(2,4));
STATIC_CHECK((6 | int2(11,12)) == int2(15,14));
STATIC_CHECK((6 ^ int2(11,12)) == int2(13,10));
STATIC_CHECK((1 && int2(1,0)) == bool2(1,0));
STATIC_CHECK((1 || int2(1,0)) == bool2(1,1));
STATIC_REQUIRE(int2(1,2) + int2(3,4) == int2(4,6));
STATIC_REQUIRE(int2(1,2) - int2(3,4) == int2(-2,-2));
STATIC_REQUIRE(int2(1,2) * int2(3,4) == int2(3,8));
STATIC_REQUIRE(int2(3,4) / int2(1,2) == int2(3,2));
STATIC_REQUIRE((int2(6,7) & int2(11,12)) == int2(2,4));
STATIC_REQUIRE((int2(6,7) | int2(11,12)) == int2(15,15));
STATIC_REQUIRE((int2(6,7) ^ int2(11,12)) == int2(13,11));
STATIC_REQUIRE((int2(0,1) && int2(1,0)) == bool2(0,0));
STATIC_REQUIRE((int2(0,1) || int2(1,0)) == bool2(1,1));
STATIC_CHECK(int2(1,2) + int2(3,4) == int2(4,6));
STATIC_CHECK(int2(1,2) - int2(3,4) == int2(-2,-2));
STATIC_CHECK(int2(1,2) * int2(3,4) == int2(3,8));
STATIC_CHECK(int2(3,4) / int2(1,2) == int2(3,2));
STATIC_CHECK((int2(6,7) & int2(11,12)) == int2(2,4));
STATIC_CHECK((int2(6,7) | int2(11,12)) == int2(15,15));
STATIC_CHECK((int2(6,7) ^ int2(11,12)) == int2(13,11));
STATIC_CHECK((int2(0,1) && int2(1,0)) == bool2(0,0));
STATIC_CHECK((int2(0,1) || int2(1,0)) == bool2(1,1));
{
int2 v{1,2};
REQUIRE(&v == &(v += 3));
REQUIRE(v == int2{4,5});
REQUIRE(&v == &(v += int2{1,2}));
REQUIRE(v == int2{5,7});
CHECK(&v == &(v += 3));
CHECK(v == int2{4,5});
CHECK(&v == &(v += int2{1,2}));
CHECK(v == int2{5,7});
}
{
int2 v{4,5};
REQUIRE(&v == &(v -= 3));
REQUIRE(v == int2{1,2});
REQUIRE(&v == &(v -= int2{2,4}));
REQUIRE(v == int2{-1,-2});
CHECK(&v == &(v -= 3));
CHECK(v == int2{1,2});
CHECK(&v == &(v -= int2{2,4}));
CHECK(v == int2{-1,-2});
}
{
int2 v{1,2};
REQUIRE(&v == &(v *= 3));
REQUIRE(v == int2{3,6});
REQUIRE(&v == &(v *= int2{2,3}));
REQUIRE(v == int2{6,18});
CHECK(&v == &(v *= 3));
CHECK(v == int2{3,6});
CHECK(&v == &(v *= int2{2,3}));
CHECK(v == int2{6,18});
}
{
int2 v{6,18};
REQUIRE(&v == &(v /= 2));
REQUIRE(v == int2{3,9});
REQUIRE(&v == &(v /= int2{3,4}));
REQUIRE(v == int2{1,2});
CHECK(&v == &(v /= 2));
CHECK(v == int2{3,9});
CHECK(&v == &(v /= int2{3,4}));
CHECK(v == int2{1,2});
}
{
int2 v1{11,12};
REQUIRE(&v1 == &(v1 &= 6));
REQUIRE(v1 == int2(2,4));
CHECK(&v1 == &(v1 &= 6));
CHECK(v1 == int2(2,4));
int2 v2{6,7};
REQUIRE(&v2 == &(v2 &= int2(11,12)));
REQUIRE(v2 == int2(2,4));
CHECK(&v2 == &(v2 &= int2(11,12)));
CHECK(v2 == int2(2,4));
}
{
int2 v1{11,12};
REQUIRE(&v1 == &(v1 |= 6));
REQUIRE(v1 == int2(15,14));
CHECK(&v1 == &(v1 |= 6));
CHECK(v1 == int2(15,14));
int2 v2{6,7};
REQUIRE(&v2 == &(v2 |= int2(11,12)));
REQUIRE(v2 == int2(15,15));
CHECK(&v2 == &(v2 |= int2(11,12)));
CHECK(v2 == int2(15,15));
}
{
int2 v1{11,12};
REQUIRE(&v1 == &(v1 ^= 6));
REQUIRE(v1 == int2(13,10));
CHECK(&v1 == &(v1 ^= 6));
CHECK(v1 == int2(13,10));
int2 v2{6,7};
REQUIRE(&v2 == &(v2 ^= int2(11,12)));
REQUIRE(v2 == int2(13,11));
CHECK(&v2 == &(v2 ^= int2(11,12)));
CHECK(v2 == int2(13,11));
}
}
SUBCASE("Angle and Trigonometric Functions") {
STATIC_REQUIRE(radians(degrees(float2(12.13f))) == uapprox2(12.13f));
STATIC_REQUIRE(degrees(radians(float2(12.13f))) == uapprox2(12.13f));
STATIC_CHECK(radians(degrees(float2(12.13f))) == uapprox2(12.13f));
STATIC_CHECK(degrees(radians(float2(12.13f))) == uapprox2(12.13f));
(void)sin(float2(1.f));
(void)cos(float2(1.f));
@@ -153,11 +153,11 @@ TEST_CASE("vmath/vec_fun") {
{
float2 out_ss{}, out_cs{};
sincos(float2(10.f,15.f), &out_ss, &out_cs);
REQUIRE(out_ss == uapprox2(sin(10.f), sin(15.f)));
REQUIRE(out_cs == uapprox2(cos(10.f), cos(15.f)));
CHECK(out_ss == uapprox2(sin(10.f), sin(15.f)));
CHECK(out_cs == uapprox2(cos(10.f), cos(15.f)));
const auto [out_ss2, out_cs2] = sincos(float2(10.f,15.f));
REQUIRE(out_ss2 == uapprox2(sin(10.f), sin(15.f)));
REQUIRE(out_cs2 == uapprox2(cos(10.f), cos(15.f)));
CHECK(out_ss2 == uapprox2(sin(10.f), sin(15.f)));
CHECK(out_cs2 == uapprox2(cos(10.f), cos(15.f)));
}
}
@@ -172,22 +172,22 @@ TEST_CASE("vmath/vec_fun") {
}
SUBCASE("Common Functions") {
STATIC_REQUIRE(abs(float2(1.f, -1.f)) == uapprox2(1.f,1.f));
STATIC_REQUIRE(sqr(float2(2.f, -3.f)) == uapprox2(4.f,9.f));
STATIC_REQUIRE(sign(float3(1.f, -1.f, 0.f)) == uapprox3(1.f,-1.f,0.f));
STATIC_REQUIRE(rcp(float2(2.f, 4.f)) == uapprox2(0.5f,0.25f));
STATIC_CHECK(abs(float2(1.f, -1.f)) == uapprox2(1.f,1.f));
STATIC_CHECK(sqr(float2(2.f, -3.f)) == uapprox2(4.f,9.f));
STATIC_CHECK(sign(float3(1.f, -1.f, 0.f)) == uapprox3(1.f,-1.f,0.f));
STATIC_CHECK(rcp(float2(2.f, 4.f)) == uapprox2(0.5f,0.25f));
REQUIRE(copysign(
CHECK(copysign(
float4(2.f, -4.f, 2.f, -4.f),
5.f)
== uapprox4(2.f, 4.f, 2.f, 4.f));
REQUIRE(copysign(
CHECK(copysign(
float4(2.f, -4.f, 2.f, -4.f),
-5.f)
== uapprox4(-2.f, -4.f, -2.f, -4.f));
REQUIRE(copysign(
CHECK(copysign(
float4(2.f, -4.f, 2.f, -4.f),
float4(10.f, 5.f, -4.f, -0.4))
== uapprox4(2.f, 4.f, -2.f, -4.f));
@@ -198,124 +198,124 @@ TEST_CASE("vmath/vec_fun") {
(void)ceil(float2(1.f, -1.f));
(void)fract(float2(1.f, -1.f));
REQUIRE(fmod(float2(1.7f), 1.2f) == uapprox2(0.5f));
REQUIRE(fmod(float2(1.7f), float2(1.2f)) == uapprox2(0.5f));
CHECK(fmod(float2(1.7f), 1.2f) == uapprox2(0.5f));
CHECK(fmod(float2(1.7f), float2(1.2f)) == uapprox2(0.5f));
{
float2 out_i{};
REQUIRE(modf(float2(1.7f), &out_i) == uapprox2(0.7f));
REQUIRE(out_i.x == uapprox(1.f));
CHECK(modf(float2(1.7f), &out_i) == uapprox2(0.7f));
CHECK(out_i.x == uapprox(1.f));
}
STATIC_REQUIRE(min(int2(1,2)) == 1);
STATIC_REQUIRE(min(int2(1,2), 1) == int2(1,1));
STATIC_REQUIRE(min(1, int2(1,2)) == int2(1,1));
STATIC_REQUIRE(min(int2(1,1), int2(0,2)) == int2(0,1));
STATIC_CHECK(min(int2(1,2)) == 1);
STATIC_CHECK(min(int2(1,2), 1) == int2(1,1));
STATIC_CHECK(min(1, int2(1,2)) == int2(1,1));
STATIC_CHECK(min(int2(1,1), int2(0,2)) == int2(0,1));
STATIC_REQUIRE(max(int2(1,2)) == 2);
STATIC_REQUIRE(max(int2(1,2), 1) == int2(1,2));
STATIC_REQUIRE(max(1, int2(1,2)) == int2(1,2));
STATIC_REQUIRE(max(int2(1,1), int2(0,2)) == int2(1,2));
STATIC_CHECK(max(int2(1,2)) == 2);
STATIC_CHECK(max(int2(1,2), 1) == int2(1,2));
STATIC_CHECK(max(1, int2(1,2)) == int2(1,2));
STATIC_CHECK(max(int2(1,1), int2(0,2)) == int2(1,2));
STATIC_REQUIRE(clamp(int2(1,2), 0, 1) == int2(1,1));
STATIC_REQUIRE(clamp(int2(1,2), int2(0), int2(1)) == int2(1,1));
STATIC_CHECK(clamp(int2(1,2), 0, 1) == int2(1,1));
STATIC_CHECK(clamp(int2(1,2), int2(0), int2(1)) == int2(1,1));
STATIC_REQUIRE(saturate(float3(-1.f,0.5,1.5f)) == uapprox3(0.f,0.5f,1.f));
STATIC_CHECK(saturate(float3(-1.f,0.5,1.5f)) == uapprox3(0.f,0.5f,1.f));
STATIC_REQUIRE(lerp(float2(2.f), float2(10.f), 0.f) == uapprox2(2.f));
STATIC_REQUIRE(lerp(float2(2.f), float2(10.f), 0.5f) == uapprox2(6.f));
STATIC_REQUIRE(lerp(float2(2.f), float2(10.f), 1.f) == uapprox2(10.f));
STATIC_CHECK(lerp(float2(2.f), float2(10.f), 0.f) == uapprox2(2.f));
STATIC_CHECK(lerp(float2(2.f), float2(10.f), 0.5f) == uapprox2(6.f));
STATIC_CHECK(lerp(float2(2.f), float2(10.f), 1.f) == uapprox2(10.f));
STATIC_REQUIRE(lerp(float2(2.f), float2(10.f), 0.f, 1.f) == uapprox2(10.f));
STATIC_REQUIRE(lerp(float2(2.f), float2(10.f), 1.f, 0.f) == uapprox2(2.f));
STATIC_REQUIRE(lerp(float2(2.f), float2(10.f), 0.5f, 0.2f) == uapprox2(3.f));
STATIC_CHECK(lerp(float2(2.f), float2(10.f), 0.f, 1.f) == uapprox2(10.f));
STATIC_CHECK(lerp(float2(2.f), float2(10.f), 1.f, 0.f) == uapprox2(2.f));
STATIC_CHECK(lerp(float2(2.f), float2(10.f), 0.5f, 0.2f) == uapprox2(3.f));
STATIC_REQUIRE(lerp(float2(2.f), float2(10.f), float2(0.f)) == uapprox2(2.f));
STATIC_REQUIRE(lerp(float2(2.f), float2(10.f), float2(0.5f)) == uapprox2(6.f));
STATIC_REQUIRE(lerp(float2(2.f), float2(10.f), float2(1.f)) == uapprox2(10.f));
STATIC_CHECK(lerp(float2(2.f), float2(10.f), float2(0.f)) == uapprox2(2.f));
STATIC_CHECK(lerp(float2(2.f), float2(10.f), float2(0.5f)) == uapprox2(6.f));
STATIC_CHECK(lerp(float2(2.f), float2(10.f), float2(1.f)) == uapprox2(10.f));
STATIC_REQUIRE(lerp(float2(2.f), float2(10.f), float2(0.f), float2(1.f)) == uapprox2(10.f));
STATIC_REQUIRE(lerp(float2(2.f), float2(10.f), float2(1.f), float2(0.f)) == uapprox2(2.f));
STATIC_REQUIRE(lerp(float2(2.f), float2(10.f), float2(0.5f), float2(0.2f)) == uapprox2(3.f));
STATIC_CHECK(lerp(float2(2.f), float2(10.f), float2(0.f), float2(1.f)) == uapprox2(10.f));
STATIC_CHECK(lerp(float2(2.f), float2(10.f), float2(1.f), float2(0.f)) == uapprox2(2.f));
STATIC_CHECK(lerp(float2(2.f), float2(10.f), float2(0.5f), float2(0.2f)) == uapprox2(3.f));
STATIC_REQUIRE(step(0.5f, float2(0.4f)) == uapprox2(0.f));
STATIC_REQUIRE(step(0.5f, float2(0.6f)) == uapprox2(1.f));
STATIC_REQUIRE(step(float2(0.5f), float2(0.4f)) == uapprox2(0.f));
STATIC_REQUIRE(step(float2(0.5f), float2(0.6f)) == uapprox2(1.f));
STATIC_CHECK(step(0.5f, float2(0.4f)) == uapprox2(0.f));
STATIC_CHECK(step(0.5f, float2(0.6f)) == uapprox2(1.f));
STATIC_CHECK(step(float2(0.5f), float2(0.4f)) == uapprox2(0.f));
STATIC_CHECK(step(float2(0.5f), float2(0.6f)) == uapprox2(1.f));
STATIC_REQUIRE(smoothstep(0.f, 1.f, float2(0.1f)) == uapprox2(0.028f));
STATIC_REQUIRE(smoothstep(float2(0.f), float2(1.f), float2(0.1f)) == uapprox2(0.028f));
STATIC_CHECK(smoothstep(0.f, 1.f, float2(0.1f)) == uapprox2(0.028f));
STATIC_CHECK(smoothstep(float2(0.f), float2(1.f), float2(0.1f)) == uapprox2(0.028f));
REQUIRE_FALSE(isnan(float2(1.f)).x);
REQUIRE_FALSE(isinf(float2(1.f)).x);
REQUIRE(isfinite(float2(1.f)).x);
CHECK_FALSE(isnan(float2(1.f)).x);
CHECK_FALSE(isinf(float2(1.f)).x);
CHECK(isfinite(float2(1.f)).x);
REQUIRE_FALSE(fma(float2(2.f), float2(3.f), float2(4.f)).x == uapprox(12.f));
CHECK_FALSE(fma(float2(2.f), float2(3.f), float2(4.f)).x == uapprox(12.f));
{
int2 out_exp{};
REQUIRE(frexp(float2(1.7f), &out_exp).x == uapprox(0.85f));
REQUIRE(out_exp == int2(1));
CHECK(frexp(float2(1.7f), &out_exp).x == uapprox(0.85f));
CHECK(out_exp == int2(1));
}
REQUIRE(ldexp(float2(0.85f), int2(1)).x == uapprox(1.7f));
CHECK(ldexp(float2(0.85f), int2(1)).x == uapprox(1.7f));
}
SUBCASE("Geometric Functions") {
REQUIRE(length(float2(10.f,0.f)) == uapprox(10.f));
REQUIRE(length(float2(-10.f,0.f)) == uapprox(10.f));
CHECK(length(float2(10.f,0.f)) == uapprox(10.f));
CHECK(length(float2(-10.f,0.f)) == uapprox(10.f));
STATIC_REQUIRE(length2(float2(10.f,0.f)) == uapprox(100.f));
STATIC_REQUIRE(length2(float2(-10.f,0.f)) == uapprox(100.f));
STATIC_CHECK(length2(float2(10.f,0.f)) == uapprox(100.f));
STATIC_CHECK(length2(float2(-10.f,0.f)) == uapprox(100.f));
REQUIRE(distance(float2(5.f,0.f), float2(10.f,0.f)) == uapprox(5.f));
REQUIRE(distance(float2(-5.f,0.f), float2(-10.f,0.f)) == uapprox(5.f));
CHECK(distance(float2(5.f,0.f), float2(10.f,0.f)) == uapprox(5.f));
CHECK(distance(float2(-5.f,0.f), float2(-10.f,0.f)) == uapprox(5.f));
STATIC_REQUIRE(distance2(float2(5.f,0.f), float2(10.f,0.f)) == uapprox(25.f));
STATIC_REQUIRE(distance2(float2(-5.f,0.f), float2(-10.f,0.f)) == uapprox(25.f));
STATIC_CHECK(distance2(float2(5.f,0.f), float2(10.f,0.f)) == uapprox(25.f));
STATIC_CHECK(distance2(float2(-5.f,0.f), float2(-10.f,0.f)) == uapprox(25.f));
STATIC_REQUIRE(dot(int2(1,2),int2(3,4)) == 11);
STATIC_REQUIRE(cross(int2(1,0),int2(0,1)) == 1);
STATIC_REQUIRE(cross(int3(1,0,0),int3(0,1,0)) == int3(0,0,1));
REQUIRE(normalize(float2(0.5f,0.f)).x == uapprox(1.f));
STATIC_CHECK(dot(int2(1,2),int2(3,4)) == 11);
STATIC_CHECK(cross(int2(1,0),int2(0,1)) == 1);
STATIC_CHECK(cross(int3(1,0,0),int3(0,1,0)) == int3(0,0,1));
CHECK(normalize(float2(0.5f,0.f)).x == uapprox(1.f));
STATIC_REQUIRE(faceforward(float2(1.f), float2(2.f), float2(3.f)).x == uapprox(-1.f));
STATIC_REQUIRE(reflect(float2(1.f), float2(2.f)).x == uapprox(-15.f));
REQUIRE(refract(float2(1.f), float2(2.f), 1.f).x == uapprox(-15.f));
STATIC_CHECK(faceforward(float2(1.f), float2(2.f), float2(3.f)).x == uapprox(-1.f));
STATIC_CHECK(reflect(float2(1.f), float2(2.f)).x == uapprox(-15.f));
CHECK(refract(float2(1.f), float2(2.f), 1.f).x == uapprox(-15.f));
}
SUBCASE("Relational Functions") {
STATIC_REQUIRE_FALSE(any(bool2(false, false)));
STATIC_REQUIRE(any(bool2(true, false)));
STATIC_REQUIRE(any(bool2(false, true)));
STATIC_REQUIRE(any(bool2(true, true)));
STATIC_CHECK_FALSE(any(bool2(false, false)));
STATIC_CHECK(any(bool2(true, false)));
STATIC_CHECK(any(bool2(false, true)));
STATIC_CHECK(any(bool2(true, true)));
STATIC_REQUIRE_FALSE(any(int2(0, 0)));
STATIC_REQUIRE(any(int2(1, 0)));
STATIC_REQUIRE(any(int2(0, 1)));
STATIC_REQUIRE(any(int2(1, 1)));
STATIC_CHECK_FALSE(any(int2(0, 0)));
STATIC_CHECK(any(int2(1, 0)));
STATIC_CHECK(any(int2(0, 1)));
STATIC_CHECK(any(int2(1, 1)));
STATIC_REQUIRE_FALSE(all(bool2(false, false)));
STATIC_REQUIRE_FALSE(all(bool2(true, false)));
STATIC_REQUIRE_FALSE(all(bool2(false, true)));
STATIC_REQUIRE(all(bool2(true, true)));
STATIC_CHECK_FALSE(all(bool2(false, false)));
STATIC_CHECK_FALSE(all(bool2(true, false)));
STATIC_CHECK_FALSE(all(bool2(false, true)));
STATIC_CHECK(all(bool2(true, true)));
STATIC_REQUIRE_FALSE(all(int2(0, 0)));
STATIC_REQUIRE_FALSE(all(int2(1, 0)));
STATIC_REQUIRE_FALSE(all(int2(0, 1)));
STATIC_REQUIRE(all(int2(1, 1)));
STATIC_CHECK_FALSE(all(int2(0, 0)));
STATIC_CHECK_FALSE(all(int2(1, 0)));
STATIC_CHECK_FALSE(all(int2(0, 1)));
STATIC_CHECK(all(int2(1, 1)));
STATIC_REQUIRE(approx(int3(1,1,1), int3(0,1,2)) == bool3(false, true, false));
STATIC_REQUIRE(approx(int4(1,1,1,1), int4(0,1,2,3), 0) == bool4(false, true, false, false));
STATIC_REQUIRE(approx(int4(1,1,1,1), int4(0,1,2,3), 1) == bool4(true, true, true, false));
STATIC_REQUIRE(approx(int4(1,1,1,1), int4(0,1,2,3), 2) == bool4(true, true, true, true));
STATIC_CHECK(approx(int3(1,1,1), int3(0,1,2)) == bool3(false, true, false));
STATIC_CHECK(approx(int4(1,1,1,1), int4(0,1,2,3), 0) == bool4(false, true, false, false));
STATIC_CHECK(approx(int4(1,1,1,1), int4(0,1,2,3), 1) == bool4(true, true, true, false));
STATIC_CHECK(approx(int4(1,1,1,1), int4(0,1,2,3), 2) == bool4(true, true, true, true));
STATIC_REQUIRE(less(int3(1,1,1), int3(0,1,2)) == bool3(false, false, true));
STATIC_REQUIRE(less_equal(int3(1,1,1), int3(0,1,2)) == bool3(false, true, true));
STATIC_REQUIRE(greater(int3(1,1,1), int3(0,1,2)) == bool3(true, false, false));
STATIC_REQUIRE(greater_equal(int3(1,1,1), int3(0,1,2)) == bool3(true, true, false));
STATIC_CHECK(less(int3(1,1,1), int3(0,1,2)) == bool3(false, false, true));
STATIC_CHECK(less_equal(int3(1,1,1), int3(0,1,2)) == bool3(false, true, true));
STATIC_CHECK(greater(int3(1,1,1), int3(0,1,2)) == bool3(true, false, false));
STATIC_CHECK(greater_equal(int3(1,1,1), int3(0,1,2)) == bool3(true, true, false));
STATIC_REQUIRE(equal_to(int3(1,1,1), int3(0,1,2)) == bool3(false, true, false));
STATIC_REQUIRE(not_equal_to(int3(1,1,1), int3(0,1,2)) == bool3(true, false, true));
STATIC_CHECK(equal_to(int3(1,1,1), int3(0,1,2)) == bool3(false, true, false));
STATIC_CHECK(not_equal_to(int3(1,1,1), int3(0,1,2)) == bool3(true, false, true));
}
}

270
untests/vmath_vec_tests.cpp
View File

@@ -14,74 +14,74 @@ namespace
TEST_CASE("vmath/vec") {
SUBCASE("size/sizeof") {
STATIC_REQUIRE(int2{}.size == 2);
STATIC_REQUIRE(int3{}.size == 3);
STATIC_REQUIRE(int4{}.size == 4);
STATIC_CHECK(int2{}.size == 2);
STATIC_CHECK(int3{}.size == 3);
STATIC_CHECK(int4{}.size == 4);
STATIC_REQUIRE(sizeof(int2{}) == sizeof(int) * 2);
STATIC_REQUIRE(sizeof(int3{}) == sizeof(int) * 3);
STATIC_REQUIRE(sizeof(int4{}) == sizeof(int) * 4);
STATIC_CHECK(sizeof(int2{}) == sizeof(int) * 2);
STATIC_CHECK(sizeof(int3{}) == sizeof(int) * 3);
STATIC_CHECK(sizeof(int4{}) == sizeof(int) * 4);
}
SUBCASE("guides") {
STATIC_REQUIRE(vec{1,2}.size == 2);
STATIC_CHECK(vec{1,2}.size == 2);
STATIC_REQUIRE(vec{1,2,3}.size == 3);
STATIC_REQUIRE(vec{{1,2},3}.size == 3);
STATIC_REQUIRE(vec{1,{2,3}}.size == 3);
STATIC_CHECK(vec{1,2,3}.size == 3);
STATIC_CHECK(vec{{1,2},3}.size == 3);
STATIC_CHECK(vec{1,{2,3}}.size == 3);
STATIC_REQUIRE(vec{1,2,3,4}.size == 4);
STATIC_REQUIRE(vec{vec{1,2},3,4}.size == 4);
STATIC_REQUIRE(vec{1,vec{2,3},4}.size == 4);
STATIC_REQUIRE(vec{1,2,vec{3,4}}.size == 4);
STATIC_REQUIRE(vec{vec{1,2},vec{3,4}}.size == 4);
STATIC_REQUIRE(vec{vec{1,2,3},4}.size == 4);
STATIC_REQUIRE(vec{1,vec{2,3,4}}.size == 4);
STATIC_CHECK(vec{1,2,3,4}.size == 4);
STATIC_CHECK(vec{vec{1,2},3,4}.size == 4);
STATIC_CHECK(vec{1,vec{2,3},4}.size == 4);
STATIC_CHECK(vec{1,2,vec{3,4}}.size == 4);
STATIC_CHECK(vec{vec{1,2},vec{3,4}}.size == 4);
STATIC_CHECK(vec{vec{1,2,3},4}.size == 4);
STATIC_CHECK(vec{1,vec{2,3,4}}.size == 4);
}
SUBCASE("ctors") {
{
STATIC_REQUIRE(int2().x == 0);
STATIC_REQUIRE(int2().y == 0);
STATIC_CHECK(int2().x == 0);
STATIC_CHECK(int2().y == 0);
STATIC_REQUIRE(int2(1).x == 1);
STATIC_REQUIRE(int2(1).y == 1);
STATIC_CHECK(int2(1).x == 1);
STATIC_CHECK(int2(1).y == 1);
STATIC_REQUIRE(int2(1,2).x == 1);
STATIC_REQUIRE(int2(1,2).y == 2);
STATIC_CHECK(int2(1,2).x == 1);
STATIC_CHECK(int2(1,2).y == 2);
}
{
constexpr int2 v(1,2);
constexpr int2 v2 = v;
STATIC_REQUIRE(v2 == int2(1,2));
STATIC_CHECK(v2 == int2(1,2));
}
{
constexpr int2 v(1,2);
constexpr int2 v2 = std::move(v);
STATIC_REQUIRE(v2 == int2(1,2));
STATIC_CHECK(v2 == int2(1,2));
}
{
STATIC_REQUIRE(int2(1) == int2(1,1));
STATIC_REQUIRE(int2(1,2) == int2(1,2));
STATIC_REQUIRE(int2(int2(1,2)) == int2(1,2));
STATIC_REQUIRE(int2(int3(1,2,3)) == int2(1,2));
STATIC_REQUIRE(int2(int4(1,2,3,4)) == int2(1,2));
STATIC_CHECK(int2(1) == int2(1,1));
STATIC_CHECK(int2(1,2) == int2(1,2));
STATIC_CHECK(int2(int2(1,2)) == int2(1,2));
STATIC_CHECK(int2(int3(1,2,3)) == int2(1,2));
STATIC_CHECK(int2(int4(1,2,3,4)) == int2(1,2));
STATIC_REQUIRE(int3(1) == int3(1,1,1));
STATIC_REQUIRE(int3(1,2,3) == int3(1,2,3));
STATIC_REQUIRE(int3(int2(1,2),3) == int3(1,2,3));
STATIC_REQUIRE(int3(1,int2(2,3)) == int3(1,2,3));
STATIC_REQUIRE(int3(int3(1,2,3)) == int3(1,2,3));
STATIC_REQUIRE(int3(int4(1,2,3,4)) == int3(1,2,3));
STATIC_CHECK(int3(1) == int3(1,1,1));
STATIC_CHECK(int3(1,2,3) == int3(1,2,3));
STATIC_CHECK(int3(int2(1,2),3) == int3(1,2,3));
STATIC_CHECK(int3(1,int2(2,3)) == int3(1,2,3));
STATIC_CHECK(int3(int3(1,2,3)) == int3(1,2,3));
STATIC_CHECK(int3(int4(1,2,3,4)) == int3(1,2,3));
STATIC_REQUIRE(int4(1) == int4(1,1,1,1));
STATIC_REQUIRE(int4(1,2,3,4) == int4(1,2,3,4));
STATIC_REQUIRE(int4(int2(1,2),3,4) == int4(1,2,3,4));
STATIC_REQUIRE(int4(1,int2(2,3),4) == int4(1,2,3,4));
STATIC_REQUIRE(int4(1,2,int2(3,4)) == int4(1,2,3,4));
STATIC_REQUIRE(int4(int2(1,2),int2(3,4)) == int4(1,2,3,4));
STATIC_REQUIRE(int4(int3(1,2,3),4) == int4(1,2,3,4));
STATIC_REQUIRE(int4(1,int3(2,3,4)) == int4(1,2,3,4));
STATIC_CHECK(int4(1) == int4(1,1,1,1));
STATIC_CHECK(int4(1,2,3,4) == int4(1,2,3,4));
STATIC_CHECK(int4(int2(1,2),3,4) == int4(1,2,3,4));
STATIC_CHECK(int4(1,int2(2,3),4) == int4(1,2,3,4));
STATIC_CHECK(int4(1,2,int2(3,4)) == int4(1,2,3,4));
STATIC_CHECK(int4(int2(1,2),int2(3,4)) == int4(1,2,3,4));
STATIC_CHECK(int4(int3(1,2,3),4) == int4(1,2,3,4));
STATIC_CHECK(int4(1,int3(2,3,4)) == int4(1,2,3,4));
}
}
@@ -90,13 +90,13 @@ TEST_CASE("vmath/vec") {
int2 v(1,2);
int2 v2;
v2 = v;
REQUIRE(v2 == int2(1,2));
CHECK(v2 == int2(1,2));
}
{
int2 v(1,2);
int2 v2;
v2 = std::move(v);
REQUIRE(v2 == int2(1,2));
CHECK(v2 == int2(1,2));
}
}
@@ -105,15 +105,15 @@ TEST_CASE("vmath/vec") {
int2 v1(1,2);
int2 v2(4,5);
v1.swap(v2);
REQUIRE(v1 == int2(4,5));
REQUIRE(v2 == int2(1,2));
CHECK(v1 == int2(4,5));
CHECK(v2 == int2(1,2));
}
{
int2 v1(1,2);
int2 v2(4,5);
swap(v1, v2);
REQUIRE(v1 == int2(4,5));
REQUIRE(v2 == int2(1,2));
CHECK(v1 == int2(4,5));
CHECK(v2 == int2(1,2));
}
}
@@ -121,125 +121,125 @@ TEST_CASE("vmath/vec") {
{
int2 v{1,2};
REQUIRE(*v.begin() == 1);
REQUIRE(*(v.begin() + 1) == 2);
REQUIRE(*(v.end() - 1) == 2);
REQUIRE(*(v.end() - 2) == 1);
REQUIRE(v.begin() + 2 == v.end());
REQUIRE(v.end() - 2 == v.begin());
CHECK(*v.begin() == 1);
CHECK(*(v.begin() + 1) == 2);
CHECK(*(v.end() - 1) == 2);
CHECK(*(v.end() - 2) == 1);
CHECK(v.begin() + 2 == v.end());
CHECK(v.end() - 2 == v.begin());
REQUIRE(*v.cbegin() == 1);
REQUIRE(*(v.cbegin() + 1) == 2);
REQUIRE(*(v.cend() - 1) == 2);
REQUIRE(*(v.cend() - 2) == 1);
REQUIRE(v.cbegin() + 2 == v.cend());
REQUIRE(v.cend() - 2 == v.cbegin());
CHECK(*v.cbegin() == 1);
CHECK(*(v.cbegin() + 1) == 2);
CHECK(*(v.cend() - 1) == 2);
CHECK(*(v.cend() - 2) == 1);
CHECK(v.cbegin() + 2 == v.cend());
CHECK(v.cend() - 2 == v.cbegin());
REQUIRE(*v.rbegin() == 2);
REQUIRE(*(v.rbegin() + 1) == 1);
REQUIRE(*(v.rend() - 1) == 1);
REQUIRE(*(v.rend() - 2) == 2);
REQUIRE(v.rbegin() + 2 == v.rend());
REQUIRE(v.rend() - 2 == v.rbegin());
CHECK(*v.rbegin() == 2);
CHECK(*(v.rbegin() + 1) == 1);
CHECK(*(v.rend() - 1) == 1);
CHECK(*(v.rend() - 2) == 2);
CHECK(v.rbegin() + 2 == v.rend());
CHECK(v.rend() - 2 == v.rbegin());
REQUIRE(*v.crbegin() == 2);
REQUIRE(*(v.crbegin() + 1) == 1);
REQUIRE(*(v.crend() - 1) == 1);
REQUIRE(*(v.crend() - 2) == 2);
REQUIRE(v.crbegin() + 2 == v.crend());
REQUIRE(v.crend() - 2 == v.crbegin());
CHECK(*v.crbegin() == 2);
CHECK(*(v.crbegin() + 1) == 1);
CHECK(*(v.crend() - 1) == 1);
CHECK(*(v.crend() - 2) == 2);
CHECK(v.crbegin() + 2 == v.crend());
CHECK(v.crend() - 2 == v.crbegin());
*v.begin() = 3;
REQUIRE(v == int2{3,2});
CHECK(v == int2{3,2});
*v.rbegin() = 4;
REQUIRE(v == int2{3,4});
CHECK(v == int2{3,4});
}
{
const int2 v{1,2};
REQUIRE(*v.begin() == 1);
REQUIRE(*(v.begin() + 1) == 2);
REQUIRE(*(v.end() - 1) == 2);
REQUIRE(*(v.end() - 2) == 1);
REQUIRE(v.begin() + 2 == v.end());
REQUIRE(v.end() - 2 == v.begin());
CHECK(*v.begin() == 1);
CHECK(*(v.begin() + 1) == 2);
CHECK(*(v.end() - 1) == 2);
CHECK(*(v.end() - 2) == 1);
CHECK(v.begin() + 2 == v.end());
CHECK(v.end() - 2 == v.begin());
REQUIRE(*v.cbegin() == 1);
REQUIRE(*(v.cbegin() + 1) == 2);
REQUIRE(*(v.cend() - 1) == 2);
REQUIRE(*(v.cend() - 2) == 1);
REQUIRE(v.cbegin() + 2 == v.cend());
REQUIRE(v.cend() - 2 == v.cbegin());
CHECK(*v.cbegin() == 1);
CHECK(*(v.cbegin() + 1) == 2);
CHECK(*(v.cend() - 1) == 2);
CHECK(*(v.cend() - 2) == 1);
CHECK(v.cbegin() + 2 == v.cend());
CHECK(v.cend() - 2 == v.cbegin());
REQUIRE(*v.rbegin() == 2);
REQUIRE(*(v.rbegin() + 1) == 1);
REQUIRE(*(v.rend() - 1) == 1);
REQUIRE(*(v.rend() - 2) == 2);
REQUIRE(v.rbegin() + 2 == v.rend());
REQUIRE(v.rend() - 2 == v.rbegin());
CHECK(*v.rbegin() == 2);
CHECK(*(v.rbegin() + 1) == 1);
CHECK(*(v.rend() - 1) == 1);
CHECK(*(v.rend() - 2) == 2);
CHECK(v.rbegin() + 2 == v.rend());
CHECK(v.rend() - 2 == v.rbegin());
REQUIRE(*v.crbegin() == 2);
REQUIRE(*(v.crbegin() + 1) == 1);
REQUIRE(*(v.crend() - 1) == 1);
REQUIRE(*(v.crend() - 2) == 2);
REQUIRE(v.crbegin() + 2 == v.crend());
REQUIRE(v.crend() - 2 == v.crbegin());
CHECK(*v.crbegin() == 2);
CHECK(*(v.crbegin() + 1) == 1);
CHECK(*(v.crend() - 1) == 1);
CHECK(*(v.crend() - 2) == 2);
CHECK(v.crbegin() + 2 == v.crend());
CHECK(v.crend() - 2 == v.crbegin());
}
}
SUBCASE("data") {
{
int2 i2;
REQUIRE(i2.data() == &i2[0]);
CHECK(i2.data() == &i2[0]);
int3 i3;
REQUIRE(i3.data() == &i3[0]);
CHECK(i3.data() == &i3[0]);
int4 i4;
REQUIRE(i4.data() == &i4[0]);
CHECK(i4.data() == &i4[0]);
}
{
const int2 i2;
REQUIRE(i2.data() == &i2[0]);
CHECK(i2.data() == &i2[0]);
const int3 i3;
REQUIRE(i3.data() == &i3[0]);
CHECK(i3.data() == &i3[0]);
const int4 i4;
REQUIRE(i4.data() == &i4[0]);
CHECK(i4.data() == &i4[0]);
}
}
SUBCASE("operator[]") {
{
STATIC_REQUIRE(int2(1,2).x == 1);
STATIC_REQUIRE(int2(1,2).y == 2);
STATIC_CHECK(int2(1,2).x == 1);
STATIC_CHECK(int2(1,2).y == 2);
STATIC_REQUIRE(int3(1,2,3).x == 1);
STATIC_REQUIRE(int3(1,2,3).y == 2);
STATIC_REQUIRE(int3(1,2,3).z == 3);
STATIC_CHECK(int3(1,2,3).x == 1);
STATIC_CHECK(int3(1,2,3).y == 2);
STATIC_CHECK(int3(1,2,3).z == 3);
STATIC_REQUIRE(int4(1,2,3,4).x == 1);
STATIC_REQUIRE(int4(1,2,3,4).y == 2);
STATIC_REQUIRE(int4(1,2,3,4).z == 3);
STATIC_REQUIRE(int4(1,2,3,4).w == 4);
STATIC_CHECK(int4(1,2,3,4).x == 1);
STATIC_CHECK(int4(1,2,3,4).y == 2);
STATIC_CHECK(int4(1,2,3,4).z == 3);
STATIC_CHECK(int4(1,2,3,4).w == 4);
}
{
STATIC_REQUIRE(int2(1,2)[0] == 1);
STATIC_REQUIRE(int2(1,2)[1] == 2);
STATIC_CHECK(int2(1,2)[0] == 1);
STATIC_CHECK(int2(1,2)[1] == 2);
}
{
int2 v;
v.x = 1;
v.y = 2;
REQUIRE(v == int2(1,2));
CHECK(v == int2(1,2));
}
{
int3 v;
v.x = 1;
v.y = 2;
v.z = 3;
REQUIRE(v == int3(1,2,3));
CHECK(v == int3(1,2,3));
}
{
int4 v;
@@ -247,33 +247,35 @@ TEST_CASE("vmath/vec") {
v.y = 2;
v.z = 3;
v.w = 4;
REQUIRE(v == int4(1,2,3,4));
CHECK(v == int4(1,2,3,4));
}
}
SUBCASE("at") {
STATIC_REQUIRE(int2(1,2).at(0) == 1);
STATIC_REQUIRE(int2(1,2).at(1) == 2);
REQUIRE_THROWS_AS((void)int2(1,2).at(2), std::out_of_range);
STATIC_CHECK(int2(1,2).at(0) == 1);
STATIC_CHECK(int2(1,2).at(1) == 2);
#ifndef VMATH_HPP_NO_EXCEPTIONS
CHECK_THROWS_AS((void)int2(1,2).at(2), std::out_of_range);
#endif
}
SUBCASE("operator==/operator!=") {
STATIC_REQUIRE(int2(1,2) == int2(1,2));
STATIC_REQUIRE_FALSE(int2(1,2) == int2(2,2));
STATIC_REQUIRE_FALSE(int2(1,2) == int2(1,3));
STATIC_CHECK(int2(1,2) == int2(1,2));
STATIC_CHECK_FALSE(int2(1,2) == int2(2,2));
STATIC_CHECK_FALSE(int2(1,2) == int2(1,3));
STATIC_REQUIRE_FALSE(int2(1,2) != int2(1,2));
STATIC_REQUIRE(int2(1,2) != int2(2,2));
STATIC_REQUIRE(int2(1,2) != int2(1,3));
STATIC_CHECK_FALSE(int2(1,2) != int2(1,2));
STATIC_CHECK(int2(1,2) != int2(2,2));
STATIC_CHECK(int2(1,2) != int2(1,3));
}
SUBCASE("operator<") {
STATIC_REQUIRE_FALSE(int2(1,2) < int2(1,2));
STATIC_CHECK_FALSE(int2(1,2) < int2(1,2));
STATIC_REQUIRE(int2(1,1) < int2(1,2));
STATIC_REQUIRE_FALSE(int2(1,2) < int2(1,1));
STATIC_CHECK(int2(1,1) < int2(1,2));
STATIC_CHECK_FALSE(int2(1,2) < int2(1,1));
STATIC_REQUIRE(int2(0,3) < int2(1,2));
STATIC_REQUIRE_FALSE(int2(1,2) < int2(0,3));
STATIC_CHECK(int2(0,3) < int2(1,2));
STATIC_CHECK_FALSE(int2(1,2) < int2(0,3));
}
}