BlackMATov/vmath.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/vmath.hpp.git synced 2025-12-16 22:19:51 +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

14
headers/vmath.hpp/vmath_fwd.hpp
View File

@@ -8,6 +8,7 @@
#include <cmath> #include <cmath>
#include <cstddef> #include <cstddef>
#include <cstdlib>
#include <initializer_list> #include <initializer_list>
#include <iterator> #include <iterator>
@@ -24,6 +25,19 @@
# define VMATH_HPP_FORCE_INLINE inline # define VMATH_HPP_FORCE_INLINE inline
#endif #endif
#if !defined(__cpp_exceptions) && !defined(__EXCEPTIONS) && !defined(_CPPUNWIND)
# define VMATH_HPP_NO_EXCEPTIONS
#endif
#ifdef VMATH_HPP_NO_EXCEPTIONS
# define VMATH_HPP_THROW(...) std::abort()
#else
# define VMATH_HPP_THROW(...) throw __VA_ARGS__
#endif
#define VMATH_HPP_THROW_IF(pred, ...)\
( (pred) ? VMATH_HPP_THROW(__VA_ARGS__) : (void)0 )
namespace vmath_hpp namespace vmath_hpp
{ {
template < typename T, std::size_t Size > template < typename T, std::size_t Size >

8
headers/vmath.hpp/vmath_mat.hpp
View File

@@ -262,16 +262,12 @@ namespace vmath_hpp
} }
[[nodiscard]] constexpr reference at(std::size_t index) { [[nodiscard]] constexpr reference at(std::size_t index) {
if ( index >= Size ) { VMATH_HPP_THROW_IF(index >= size, std::out_of_range("mat::at"));
throw std::out_of_range("mat::at");
}
return rows[index]; return rows[index];
} }
[[nodiscard]] constexpr const_reference at(std::size_t index) const { [[nodiscard]] constexpr const_reference at(std::size_t index) const {
if ( index >= Size ) { VMATH_HPP_THROW_IF(index >= size, std::out_of_range("mat::at"));
throw std::out_of_range("mat::at");
}
return rows[index]; return rows[index];
} }
}; };

8
headers/vmath.hpp/vmath_qua.hpp
View File

@@ -106,16 +106,12 @@ namespace vmath_hpp
} }
[[nodiscard]] constexpr reference at(std::size_t index) { [[nodiscard]] constexpr reference at(std::size_t index) {
if ( index >= size ) { VMATH_HPP_THROW_IF(index >= size, std::out_of_range("qua::at"));
throw std::out_of_range("qua::at");
}
return (*this)[index]; return (*this)[index];
} }
[[nodiscard]] constexpr const_reference at(std::size_t index) const { [[nodiscard]] constexpr const_reference at(std::size_t index) const {
if ( index >= size ) { VMATH_HPP_THROW_IF(index >= size, std::out_of_range("qua::at"));
throw std::out_of_range("qua::at");
}
return (*this)[index]; return (*this)[index];
} }
}; };

8
headers/vmath.hpp/vmath_vec.hpp
View File

@@ -204,16 +204,12 @@ namespace vmath_hpp
} }
[[nodiscard]] constexpr reference at(std::size_t index) { [[nodiscard]] constexpr reference at(std::size_t index) {
if ( index >= Size ) { VMATH_HPP_THROW_IF(index >= size, std::out_of_range("vec::at"));
throw std::out_of_range("vec::at");
}
return (*this)[index]; return (*this)[index];
} }
[[nodiscard]] constexpr const_reference at(std::size_t index) const { [[nodiscard]] constexpr const_reference at(std::size_t index) const {
if ( index >= Size ) { VMATH_HPP_THROW_IF(index >= size, std::out_of_range("vec::at"));
throw std::out_of_range("vec::at");
}
return (*this)[index]; return (*this)[index];
} }
}; };

8
untests/doctest/doctest.hpp
View File

@@ -2,10 +2,10 @@
#include "doctest.h" #include "doctest.h"
#define STATIC_REQUIRE(...)\ #define STATIC_CHECK(...)\
static_assert(__VA_ARGS__, #__VA_ARGS__);\ 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__ ")");\ 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") { TEST_CASE("vmath/ext/units") {
STATIC_REQUIRE(zero2<int> == int2(0,0)); STATIC_CHECK(zero2<int> == int2(0,0));
STATIC_REQUIRE(zero3<int> == int3(0,0,0)); STATIC_CHECK(zero3<int> == int3(0,0,0));
STATIC_REQUIRE(zero4<int> == int4(0,0,0,0)); STATIC_CHECK(zero4<int> == int4(0,0,0,0));
STATIC_REQUIRE(unit2<int> == int2(1,1)); STATIC_CHECK(unit2<int> == int2(1,1));
STATIC_REQUIRE(unit2_x<int> == int2(1,0)); STATIC_CHECK(unit2_x<int> == int2(1,0));
STATIC_REQUIRE(unit2_y<int> == int2(0,1)); STATIC_CHECK(unit2_y<int> == int2(0,1));
STATIC_REQUIRE(unit3<int> == int3(1,1,1)); STATIC_CHECK(unit3<int> == int3(1,1,1));
STATIC_REQUIRE(unit3_x<int> == int3(1,0,0)); STATIC_CHECK(unit3_x<int> == int3(1,0,0));
STATIC_REQUIRE(unit3_y<int> == int3(0,1,0)); STATIC_CHECK(unit3_y<int> == int3(0,1,0));
STATIC_REQUIRE(unit3_z<int> == int3(0,0,1)); STATIC_CHECK(unit3_z<int> == int3(0,0,1));
STATIC_REQUIRE(unit4<int> == int4(1,1,1,1)); STATIC_CHECK(unit4<int> == int4(1,1,1,1));
STATIC_REQUIRE(unit4_x<int> == int4(1,0,0,0)); STATIC_CHECK(unit4_x<int> == int4(1,0,0,0));
STATIC_REQUIRE(unit4_y<int> == int4(0,1,0,0)); STATIC_CHECK(unit4_y<int> == int4(0,1,0,0));
STATIC_REQUIRE(unit4_z<int> == int4(0,0,1,0)); STATIC_CHECK(unit4_z<int> == int4(0,0,1,0));
STATIC_REQUIRE(unit4_w<int> == int4(0,0,0,1)); STATIC_CHECK(unit4_w<int> == int4(0,0,0,1));
STATIC_REQUIRE(zero2x2<int> == int2x2(0,0,0,0)); STATIC_CHECK(zero2x2<int> == int2x2(0,0,0,0));
STATIC_REQUIRE(zero3x3<int> == int3x3(0,0,0,0,0,0,0,0,0)); STATIC_CHECK(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(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_CHECK(unit2x2<int> == int2x2(1,1,1,1));
STATIC_REQUIRE(unit3x3<int> == int3x3(1,1,1,1,1,1,1,1,1)); STATIC_CHECK(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(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_CHECK(identity2x2<int> == int2x2());
STATIC_REQUIRE(identity3x3<int> == int3x3()); STATIC_CHECK(identity3x3<int> == int3x3());
STATIC_REQUIRE(identity4x4<int> == int4x4()); STATIC_CHECK(identity4x4<int> == int4x4());
} }
TEST_CASE("vmath/ext/hash") { TEST_CASE("vmath/ext/hash") {
SUBCASE("vector") { SUBCASE("vector") {
REQUIRE(std::hash<int2>{}({1,2}) == std::hash<int2>{}({1,2})); CHECK(std::hash<int2>{}({1,2}) == std::hash<int2>{}({1,2}));
REQUIRE_FALSE(std::hash<int2>{}({1,2}) == std::hash<int2>{}({2,1})); 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})); CHECK(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_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})); CHECK(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_FALSE(std::hash<int4>{}({1,2,3,4}) == std::hash<int4>{}({3,2,1,4}));
{ {
std::set<int2> s; std::set<int2> s;
s.insert(int2(1,2)); s.insert(int2(1,2));
REQUIRE(s.count(int2(1,2)) > 0); CHECK(s.count(int2(1,2)) > 0);
REQUIRE_FALSE(s.count(int2(1,1)) > 0); CHECK_FALSE(s.count(int2(1,1)) > 0);
} }
{ {
std::map<int2, int> s; std::map<int2, int> s;
s.emplace(int2(1,2),3); s.emplace(int2(1,2),3);
s.emplace(int2(2,3),5); s.emplace(int2(2,3),5);
REQUIRE(s[int2(1,2)] == 3); CHECK(s[int2(1,2)] == 3);
REQUIRE(s[int2(2,3)] == 5); CHECK(s[int2(2,3)] == 5);
} }
{ {
std::unordered_set<int2> s; std::unordered_set<int2> s;
s.insert(int2(1,2)); s.insert(int2(1,2));
REQUIRE(s.count(int2(1,2)) > 0); CHECK(s.count(int2(1,2)) > 0);
REQUIRE_FALSE(s.count(int2(1,1)) > 0); CHECK_FALSE(s.count(int2(1,1)) > 0);
} }
{ {
std::unordered_map<int2, int> s; std::unordered_map<int2, int> s;
s.emplace(int2(1,2),3); s.emplace(int2(1,2),3);
s.emplace(int2(2,3),5); s.emplace(int2(2,3),5);
REQUIRE(s[int2(1,2)] == 3); CHECK(s[int2(1,2)] == 3);
REQUIRE(s[int2(2,3)] == 5); CHECK(s[int2(2,3)] == 5);
} }
} }
SUBCASE("matrix") { SUBCASE("matrix") {
REQUIRE(std::hash<int2x2>{}({1,2,3,4}) == std::hash<int2x2>{}({1,2,3,4})); CHECK(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_FALSE(std::hash<int2x2>{}({1,2,3,4}) == std::hash<int2x2>{}({1,2,4,3}));
{ {
std::set<int2x2> s; std::set<int2x2> s;
s.insert(int2x2(1,2,3,4)); s.insert(int2x2(1,2,3,4));
REQUIRE(s.count(int2x2(1,2,3,4)) > 0); CHECK(s.count(int2x2(1,2,3,4)) > 0);
REQUIRE_FALSE(s.count(int2x2(1,1,1,1)) > 0); CHECK_FALSE(s.count(int2x2(1,1,1,1)) > 0);
} }
{ {
std::map<int2x2, int> s; std::map<int2x2, int> s;
s.emplace(int2x2(1,2,3,4),3); s.emplace(int2x2(1,2,3,4),3);
s.emplace(int2x2(2,3,4,5),5); s.emplace(int2x2(2,3,4,5),5);
REQUIRE(s[int2x2(1,2,3,4)] == 3); CHECK(s[int2x2(1,2,3,4)] == 3);
REQUIRE(s[int2x2(2,3,4,5)] == 5); CHECK(s[int2x2(2,3,4,5)] == 5);
} }
{ {
std::unordered_set<int2x2> s; std::unordered_set<int2x2> s;
s.insert(int2x2(1,2,3,4)); s.insert(int2x2(1,2,3,4));
REQUIRE(s.count(int2x2(1,2,3,4)) > 0); CHECK(s.count(int2x2(1,2,3,4)) > 0);
REQUIRE_FALSE(s.count(int2x2(1,1,1,1)) > 0); CHECK_FALSE(s.count(int2x2(1,1,1,1)) > 0);
} }
{ {
std::unordered_map<int2x2, int> s; std::unordered_map<int2x2, int> s;
s.emplace(int2x2(1,2,3,4),3); s.emplace(int2x2(1,2,3,4),3);
s.emplace(int2x2(2,3,4,5),5); s.emplace(int2x2(2,3,4,5),5);
REQUIRE(s[int2x2(1,2,3,4)] == 3); CHECK(s[int2x2(1,2,3,4)] == 3);
REQUIRE(s[int2x2(2,3,4,5)] == 5); CHECK(s[int2x2(2,3,4,5)] == 5);
} }
} }
SUBCASE("quaternion") { SUBCASE("quaternion") {
REQUIRE(std::hash<qfloat>{}({1,2,3,4}) == std::hash<qfloat>{}({1,2,3,4})); CHECK(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_FALSE(std::hash<qfloat>{}({1,2,3,4}) == std::hash<qfloat>{}({3,2,1,4}));
{ {
std::set<qua<int>> s; std::set<qua<int>> s;
s.insert(qua(1,2,3,4)); s.insert(qua(1,2,3,4));
REQUIRE(s.count(qua(1,2,3,4)) > 0); CHECK(s.count(qua(1,2,3,4)) > 0);
REQUIRE_FALSE(s.count(qua(1,1,1,1)) > 0); CHECK_FALSE(s.count(qua(1,1,1,1)) > 0);
} }
{ {
std::map<qua<int>, int> s; std::map<qua<int>, int> s;
s.emplace(qua(1,2,3,4),3); s.emplace(qua(1,2,3,4),3);
s.emplace(qua(2,3,4,5),5); s.emplace(qua(2,3,4,5),5);
REQUIRE(s[qua(1,2,3,4)] == 3); CHECK(s[qua(1,2,3,4)] == 3);
REQUIRE(s[qua(2,3,4,5)] == 5); CHECK(s[qua(2,3,4,5)] == 5);
} }
{ {
std::unordered_set<qua<int>> s; std::unordered_set<qua<int>> s;
s.insert(qua(1,2,3,4)); s.insert(qua(1,2,3,4));
REQUIRE(s.count(qua(1,2,3,4)) > 0); CHECK(s.count(qua(1,2,3,4)) > 0);
REQUIRE_FALSE(s.count(qua(1,1,1,1)) > 0); CHECK_FALSE(s.count(qua(1,1,1,1)) > 0);
} }
{ {
std::unordered_map<qua<int>, int> s; std::unordered_map<qua<int>, int> s;
s.emplace(qua(1,2,3,4),3); s.emplace(qua(1,2,3,4),3);
s.emplace(qua(2,3,4,5),5); s.emplace(qua(2,3,4,5),5);
REQUIRE(s[qua(1,2,3,4)] == 3); CHECK(s[qua(1,2,3,4)] == 3);
REQUIRE(s[qua(2,3,4,5)] == 5); CHECK(s[qua(2,3,4,5)] == 5);
} }
} }
} }
@@ -161,114 +161,114 @@ TEST_CASE("vmath/ext/hash") {
TEST_CASE("vmath/ext/cast") { TEST_CASE("vmath/ext/cast") {
SUBCASE("cast_to") { SUBCASE("cast_to") {
constexpr auto i = cast_to<int>(1.5f); constexpr auto i = cast_to<int>(1.5f);
STATIC_REQUIRE(i == 1); STATIC_CHECK(i == 1);
STATIC_REQUIRE(std::is_same_v<decltype(i), const int>); STATIC_CHECK(std::is_same_v<decltype(i), const int>);
constexpr auto v = cast_to<int>(float2(1.5f)); constexpr auto v = cast_to<int>(float2(1.5f));
STATIC_REQUIRE(v == int2(1)); STATIC_CHECK(v == int2(1));
STATIC_REQUIRE(std::is_same_v<decltype(v)::component_type, int>); STATIC_CHECK(std::is_same_v<decltype(v)::component_type, int>);
constexpr auto m = cast_to<int>(float2x2(1.5f)); constexpr auto m = cast_to<int>(float2x2(1.5f));
STATIC_REQUIRE(m == int2x2(1)); STATIC_CHECK(m == int2x2(1));
STATIC_REQUIRE(std::is_same_v<decltype(m)::row_type, int2>); 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)); constexpr auto q = cast_to<int>(qfloat(1.5f, 2.2f, 3.6f, 4.5f));
STATIC_REQUIRE(q == qua(1,2,3,4)); STATIC_CHECK(q == qua(1,2,3,4));
STATIC_REQUIRE(std::is_same_v<decltype(q)::component_type, int>); STATIC_CHECK(std::is_same_v<decltype(q)::component_type, int>);
} }
} }
TEST_CASE("vmath/ext/access") { TEST_CASE("vmath/ext/access") {
SUBCASE("component") { SUBCASE("component") {
STATIC_REQUIRE(component(int2{1,2}, 0) == 1); STATIC_CHECK(component(int2{1,2}, 0) == 1);
STATIC_REQUIRE(component(int2{1,2}, 1) == 2); STATIC_CHECK(component(int2{1,2}, 1) == 2);
STATIC_REQUIRE(component(int2{0,0}, 0, 1) == int2{1,0}); STATIC_CHECK(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}, 1, 2) == int2{0,2});
} }
SUBCASE("row") { SUBCASE("row") {
STATIC_REQUIRE(row(int2x2(1,2,3,4), 0) == int2(1,2)); STATIC_CHECK(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), 1) == int2(3,4));
STATIC_REQUIRE(row(int2x2(), 0, {1,2}) == int2x2(1,2,0,1)); STATIC_CHECK(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(), 1, {3,4}) == int2x2(1,0,3,4));
} }
SUBCASE("column") { SUBCASE("column") {
STATIC_REQUIRE(column(int2x2(1,2,3,4), 0) == int2(1,3)); STATIC_CHECK(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), 1) == int2(2,4));
STATIC_REQUIRE(column(int2x2(), 0, {2,3}) == int2x2(2,0,3,1)); STATIC_CHECK(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(), 1, {3,4}) == int2x2(1,3,0,4));
} }
SUBCASE("real") { SUBCASE("real") {
STATIC_REQUIRE(real(qua{1,2,3,4}) == 4); STATIC_CHECK(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}, 5) == qua{1,2,3,5});
} }
SUBCASE("imag") { SUBCASE("imag") {
STATIC_REQUIRE(imag(qua{1,2,3,4}) == vec{1,2,3}); STATIC_CHECK(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}, {4,3,2}) == qua{4,3,2,4});
} }
} }
TEST_CASE("vmath/ext/matrix_transform") { TEST_CASE("vmath/ext/matrix_transform") {
SUBCASE("translate") { 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_CHECK(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(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_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_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(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") { 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)); CHECK(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)); CHECK(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(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)); 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));
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)); 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));
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(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)); CHECK(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)); 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));
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)); 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));
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(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)); CHECK(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)); 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));
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)); 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));
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(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") { 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_CHECK(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_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(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_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_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_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_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(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") { SUBCASE("shear") {
STATIC_REQUIRE(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(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_CHECK(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_CHECK(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(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_CHECK(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_CHECK(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_CHECK(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(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_CHECK(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_CHECK(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_CHECK(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_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_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(shear(float2(0.f,1.f)),float2(0.f,1.f)) == uapprox3(2.f,7.f,1.f));
} }
SUBCASE("matrix look_at") { SUBCASE("matrix look_at") {
@@ -279,26 +279,26 @@ TEST_CASE("vmath/ext/matrix_transform") {
TEST_CASE("vmath/ext/matrix_projections") { TEST_CASE("vmath/ext/matrix_projections") {
SUBCASE("orthographic") { SUBCASE("orthographic") {
REQUIRE(all(approx( CHECK(all(approx(
orthographic_lh(800.f, 600.f, 5.f, 10.f), 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)))); 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), 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)))); scale(1.f,1.f,-1.f) * orthographic_rh(100.f, 800.f, 50.f, 640.f, 5.f, 10.f))));
} }
SUBCASE("perspective") { SUBCASE("perspective") {
REQUIRE(all(approx( CHECK(all(approx(
perspective_lh(800.f, 600.f, 5.f, 10.f), 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)))); 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), 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)))); 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), 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)))); 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") { TEST_CASE("vmath/ext/vector_transform") {
SUBCASE("angle") { SUBCASE("angle") {
REQUIRE(angle(float2(2.f,0.f), float2(0.f,1.f)) == uapprox(radians(90.f))); CHECK(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))); CHECK(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))); CHECK(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))); CHECK(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))); CHECK(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(float3(0.f,0.f,3.f), float3(0.f,1.f,0.f)) == uapprox(radians(90.f)));
} }
SUBCASE("rotate") { SUBCASE("rotate") {
REQUIRE(rotate(float2(2.f,0.f), radians(90.f)) == uapprox2(0.f,2.f)); CHECK(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(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)); CHECK(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)); CHECK(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_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)); CHECK(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), radians(90.f), float3(0,0,1)) == uapprox3(0.f,1.5f,0.f));
} }
SUBCASE("project") { SUBCASE("project") {
STATIC_REQUIRE(project(float2(2.f, 2.f), float2(0.f, 1.f)) == uapprox2(0.f, 2.f)); STATIC_CHECK(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(float3(2.f, 2.f, 2.f), float3(0.f, 0.f, 1.f)) == uapprox3(0.f, 0.f, 2.f));
} }
SUBCASE("perpendicular") { SUBCASE("perpendicular") {
STATIC_REQUIRE(perpendicular(float2(2.f, 2.f), float2(0.f, 1.f)) == uapprox2(2.f, 0.f)); STATIC_CHECK(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(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") { TEST_CASE("vmath/ext/quaternion_transform") {
SUBCASE("qrotate(m)") { 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(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))); 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(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))); 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(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))); 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)") { SUBCASE("qrotate(q, m)") {
REQUIRE(all(approx( CHECK(all(approx(
vec{4.f,3.f,2.f} * qrotate( vec{4.f,3.f,2.f} * qrotate(
qrotate(float3x3(rotate(0.f, vec{1.f,2.f,3.f}))), qrotate(float3x3(rotate(0.f, vec{1.f,2.f,3.f}))),
float3x3(rotate(0.f, vec{3.f,2.f,1.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)") { SUBCASE("qrotate(from, to)") {
REQUIRE(+unit3_x<float> * qrotate(-unit3_x<float>, +unit3_x<float>) == uapprox3(-unit3_x<float>)); CHECK(+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>)); CHECK(-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>)); CHECK(+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)); 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));
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(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)") { 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})))) * inverse(qrotate(float3x3(rotate(radians(12.f), {2.f,2.f,2.f})))) *
qrotate( qrotate(
qrotate(float3x3(rotate(radians(12.f), {2.f,2.f,2.f}))), 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)") { SUBCASE("qrotate(angle, axis)") {
REQUIRE(all(approx( CHECK(all(approx(
rotate(12.3f, float3(1.f,2.f,3.f)), rotate(12.3f, float3(1.f,2.f,3.f)),
rotate(qrotate(12.3f, float3(1.f,2.f,3.f)) * 2.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)); CHECK(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)); CHECK(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(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)); CHECK(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,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)); CHECK(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)); CHECK(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_z(12.3f) == qrotate(12.3f, unit3_z<float> * 2.f));
} }
SUBCASE("qrotate(q, angle, axis)") { 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)); CHECK(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)); CHECK(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(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)); 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));
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,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") { SUBCASE("qlook_at") {
REQUIRE(all(approx( CHECK(all(approx(
qlook_at_lh(float3(1.f,2.f,3.f), float3(0,1,0)), 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))))))); 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)), 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))))))); 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") { TEST_CASE("vmath/fun") {
SUBCASE("Angle and Trigonometric Functions") { SUBCASE("Angle and Trigonometric Functions") {
STATIC_REQUIRE(radians(degrees(12.13f)) == uapprox(12.13f)); STATIC_CHECK(radians(degrees(12.13f)) == uapprox(12.13f));
STATIC_REQUIRE(degrees(radians(12.13f)) == uapprox(12.13f)); STATIC_CHECK(degrees(radians(12.13f)) == uapprox(12.13f));
{ {
REQUIRE(asin(sin(1.23f)) == uapprox(1.23f)); CHECK(asin(sin(1.23f)) == uapprox(1.23f));
REQUIRE(acos(cos(1.23f)) == uapprox(1.23f)); CHECK(acos(cos(1.23f)) == uapprox(1.23f));
REQUIRE(atan(tan(1.23f)) == uapprox(1.23f)); CHECK(atan(tan(1.23f)) == uapprox(1.23f));
REQUIRE(asinh(sinh(1.23f)) == uapprox(1.23f)); CHECK(asinh(sinh(1.23f)) == uapprox(1.23f));
REQUIRE(acosh(cosh(1.23f)) == uapprox(1.23f)); CHECK(acosh(cosh(1.23f)) == uapprox(1.23f));
REQUIRE(atanh(tanh(1.23f)) == uapprox(1.23f)); CHECK(atanh(tanh(1.23f)) == uapprox(1.23f));
} }
{ {
float out_s{}, out_c{}; float out_s{}, out_c{};
sincos(15.f, &out_s, &out_c); sincos(15.f, &out_s, &out_c);
REQUIRE(out_s == uapprox(sin(15.f))); CHECK(out_s == uapprox(sin(15.f)));
REQUIRE(out_c == uapprox(cos(15.f))); CHECK(out_c == uapprox(cos(15.f)));
const auto [out_s2, out_c2] = sincos(15.f); const auto [out_s2, out_c2] = sincos(15.f);
REQUIRE(out_s2 == uapprox(sin(15.f))); CHECK(out_s2 == uapprox(sin(15.f)));
REQUIRE(out_c2 == uapprox(cos(15.f))); CHECK(out_c2 == uapprox(cos(15.f)));
} }
} }
@@ -49,118 +49,118 @@ TEST_CASE("vmath/fun") {
} }
SUBCASE("Common Functions") { SUBCASE("Common Functions") {
STATIC_REQUIRE(vmath_hpp::abs(1) == 1); STATIC_CHECK(vmath_hpp::abs(1) == 1);
STATIC_REQUIRE(vmath_hpp::abs(-1) == 1); STATIC_CHECK(vmath_hpp::abs(-1) == 1);
STATIC_REQUIRE(vmath_hpp::abs(1.f) == uapprox(1.f)); STATIC_CHECK(vmath_hpp::abs(1.f) == uapprox(1.f));
STATIC_REQUIRE(vmath_hpp::abs(-1.f) == uapprox(1.f)); STATIC_CHECK(vmath_hpp::abs(-1.f) == uapprox(1.f));
STATIC_REQUIRE(sqr(2) == 4); STATIC_CHECK(sqr(2) == 4);
STATIC_REQUIRE(sqr(-4.f) == uapprox(16.f)); STATIC_CHECK(sqr(-4.f) == uapprox(16.f));
STATIC_REQUIRE(sign(2) == 1); STATIC_CHECK(sign(2) == 1);
STATIC_REQUIRE(sign(-2) == -1); STATIC_CHECK(sign(-2) == -1);
STATIC_REQUIRE(sign(0) == 0); STATIC_CHECK(sign(0) == 0);
STATIC_REQUIRE(sign(2.f) == uapprox(1.f)); STATIC_CHECK(sign(2.f) == uapprox(1.f));
STATIC_REQUIRE(sign(-2.f) == uapprox(-1.f)); STATIC_CHECK(sign(-2.f) == uapprox(-1.f));
STATIC_REQUIRE(sign(0.f) == uapprox(0.f)); STATIC_CHECK(sign(0.f) == uapprox(0.f));
STATIC_REQUIRE(rcp(2.f) == uapprox(0.5f)); STATIC_CHECK(rcp(2.f) == uapprox(0.5f));
STATIC_REQUIRE(rcp(4.f) == uapprox(0.25f)); STATIC_CHECK(rcp(4.f) == uapprox(0.25f));
REQUIRE(floor(1.7f) == uapprox(1.f)); CHECK(floor(1.7f) == uapprox(1.f));
REQUIRE(trunc(1.7f) == uapprox(1.f)); CHECK(trunc(1.7f) == uapprox(1.f));
REQUIRE(round(1.7f) == uapprox(2.f)); CHECK(round(1.7f) == uapprox(2.f));
REQUIRE(ceil(1.7f) == uapprox(2.f)); CHECK(ceil(1.7f) == uapprox(2.f));
REQUIRE(fract(1.7f) == uapprox(0.7f)); CHECK(fract(1.7f) == uapprox(0.7f));
REQUIRE(fract(-2.3f) == 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{}; float out_i{};
REQUIRE(modf(1.7f, &out_i) == uapprox(0.7f)); CHECK(modf(1.7f, &out_i) == uapprox(0.7f));
REQUIRE(out_i == uapprox(1.f)); CHECK(out_i == uapprox(1.f));
} }
STATIC_REQUIRE(min(0.f, 1.f) == uapprox(0.f)); STATIC_CHECK(min(0.f, 1.f) == uapprox(0.f));
STATIC_REQUIRE(max(0.f, 1.f) == uapprox(1.f)); STATIC_CHECK(max(0.f, 1.f) == uapprox(1.f));
STATIC_REQUIRE(clamp(1.0f, 2.f, 3.f) == uapprox(2.0f)); STATIC_CHECK(clamp(1.0f, 2.f, 3.f) == uapprox(2.0f));
STATIC_REQUIRE(clamp(2.5f, 2.f, 3.f) == uapprox(2.5f)); STATIC_CHECK(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(3.5f, 2.f, 3.f) == uapprox(3.0f));
STATIC_REQUIRE(saturate(-0.5f) == uapprox(0.f)); STATIC_CHECK(saturate(-0.5f) == uapprox(0.f));
STATIC_REQUIRE(saturate(0.5f) == uapprox(0.5f)); STATIC_CHECK(saturate(0.5f) == uapprox(0.5f));
STATIC_REQUIRE(saturate(1.5f) == uapprox(1.f)); STATIC_CHECK(saturate(1.5f) == uapprox(1.f));
STATIC_REQUIRE(lerp(2.f, 10.f, 0.f) == uapprox(2.f)); STATIC_CHECK(lerp(2.f, 10.f, 0.f) == uapprox(2.f));
STATIC_REQUIRE(lerp(2.f, 10.f, 0.5f) == uapprox(6.f)); STATIC_CHECK(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, 1.f) == uapprox(10.f));
STATIC_REQUIRE(lerp(2.f, 10.f, 0.f, 1.f) == uapprox(10.f)); STATIC_CHECK(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_CHECK(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.5f, 0.2f) == uapprox(3.f));
STATIC_REQUIRE(step(0.5f, 0.4f) == uapprox(0.f)); STATIC_CHECK(step(0.5f, 0.4f) == uapprox(0.f));
STATIC_REQUIRE(step(0.5f, 0.6f) == uapprox(1.f)); STATIC_CHECK(step(0.5f, 0.6f) == uapprox(1.f));
STATIC_REQUIRE(smoothstep(0.f, 1.f, 0.1f) == uapprox(0.028f)); STATIC_CHECK(smoothstep(0.f, 1.f, 0.1f) == uapprox(0.028f));
REQUIRE_FALSE(vmath_hpp::isnan(1.f)); CHECK_FALSE(vmath_hpp::isnan(1.f));
REQUIRE_FALSE(vmath_hpp::isinf(1.f)); CHECK_FALSE(vmath_hpp::isinf(1.f));
REQUIRE(vmath_hpp::isfinite(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{}; int out_exp{};
REQUIRE(frexp(1.7f, &out_exp) == uapprox(0.85f)); CHECK(frexp(1.7f, &out_exp) == uapprox(0.85f));
REQUIRE(out_exp == 1); CHECK(out_exp == 1);
} }
REQUIRE(ldexp(0.85f, 1) == uapprox(1.7f)); CHECK(ldexp(0.85f, 1) == uapprox(1.7f));
} }
SUBCASE("Geometric Functions") { SUBCASE("Geometric Functions") {
STATIC_REQUIRE(length(10.f) == uapprox(10.f)); STATIC_CHECK(length(10.f) == uapprox(10.f));
STATIC_REQUIRE(length(-10.f) == uapprox(10.f)); STATIC_CHECK(length(-10.f) == uapprox(10.f));
STATIC_REQUIRE(length2(10.f) == uapprox(100.f)); STATIC_CHECK(length2(10.f) == uapprox(100.f));
STATIC_REQUIRE(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_CHECK(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_REQUIRE(distance2(5.f, 10.f) == uapprox(25.f)); STATIC_CHECK(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_REQUIRE(dot(2.f, 5.f) == uapprox(10.f)); STATIC_CHECK(dot(2.f, 5.f) == uapprox(10.f));
REQUIRE(normalize(0.5f) == uapprox(1.f)); CHECK(normalize(0.5f) == uapprox(1.f));
STATIC_REQUIRE(faceforward(1.f, 2.f, 3.f) == uapprox(-1.f)); STATIC_CHECK(faceforward(1.f, 2.f, 3.f) == uapprox(-1.f));
STATIC_REQUIRE(reflect(1.f, 2.f) == uapprox(-7.f)); STATIC_CHECK(reflect(1.f, 2.f) == uapprox(-7.f));
REQUIRE(refract(1.f, 2.f, 1.f) == uapprox(-7.f)); CHECK(refract(1.f, 2.f, 1.f) == uapprox(-7.f));
} }
SUBCASE("Relational Functions") { SUBCASE("Relational Functions") {
STATIC_REQUIRE_FALSE(any(false)); STATIC_CHECK_FALSE(any(false));
STATIC_REQUIRE_FALSE(any(0)); STATIC_CHECK_FALSE(any(0));
STATIC_REQUIRE(any(true)); STATIC_CHECK(any(true));
STATIC_REQUIRE(any(1)); STATIC_CHECK(any(1));
STATIC_REQUIRE_FALSE(all(false)); STATIC_CHECK_FALSE(all(false));
STATIC_REQUIRE_FALSE(all(0)); STATIC_CHECK_FALSE(all(0));
STATIC_REQUIRE(all(true)); STATIC_CHECK(all(true));
STATIC_REQUIRE(all(1)); STATIC_CHECK(all(1));
STATIC_REQUIRE(approx(1, 1)); STATIC_CHECK(approx(1, 1));
STATIC_REQUIRE_FALSE(approx(0, 1)); STATIC_CHECK_FALSE(approx(0, 1));
STATIC_REQUIRE_FALSE(approx(0, 1, 0)); STATIC_CHECK_FALSE(approx(0, 1, 0));
STATIC_REQUIRE(approx(0, 1, 1)); STATIC_CHECK(approx(0, 1, 1));
STATIC_REQUIRE(approx(1.f, 1.f + std::numeric_limits<float>::epsilon() * 0.5f)); STATIC_CHECK(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_CHECK_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_CHECK(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_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") { TEST_CASE("vmath/mat_fun") {
SUBCASE("detail") { SUBCASE("detail") {
STATIC_REQUIRE(map_join([](const int2& x){ STATIC_CHECK(map_join([](const int2& x){
return x * 2; return x * 2;
}, int2x2{}) == int2x2(2,0,0,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; return x + y;
}, int2x2{}, int2x2{}) == int2x2(2,0,0,2)); }, 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; return x + y + z;
}, int2x2{}, int2x2{}, int2x2{}) == int2x2(3,0,0,3)); }, 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; return acc + x.x;
}, 0, int2x2{}) == 1); }, 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; return acc + x.x + y.x;
}, 0, int2x2{}, int2x2{}) == 2); }, 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; return acc + x;
}, int2x2{}) == int2(1,1)); }, int2x2{}) == int2(1,1));
} }
SUBCASE("operators") { SUBCASE("operators") {
STATIC_REQUIRE(+int2x2(1,-2,3,-4) == int2x2(1,-2,3,-4)); STATIC_CHECK(+int2x2(1,-2,3,-4) == int2x2(1,-2,3,-4));
STATIC_REQUIRE(-int2x2(1,-2,3,-4) == int2x2(-1,2,-3,4)); STATIC_CHECK(-int2x2(1,-2,3,-4) == int2x2(-1,2,-3,4));
STATIC_REQUIRE(~uint2x2(0xF0F0F0F0,0x0F0F0F0F,0xF0F0F0F0,0x0F0F0F0F) == uint2x2(0x0F0F0F0F,0xF0F0F0F0,0x0F0F0F0F,0xF0F0F0F0)); STATIC_CHECK(~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,0,1,2) == bool2x2(false,true,false,false));
STATIC_REQUIRE(int2x2(1,2,3,4) + 2 == int2x2(3,4,5,6)); STATIC_CHECK(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_CHECK(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_CHECK(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_CHECK(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_CHECK((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_CHECK((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_CHECK((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_CHECK((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,0,1,0) || 1) == bool2x2(1,1,1,1));
STATIC_REQUIRE(4 + int2x2(1,2,3,4) == int2x2(5,6,7,8)); STATIC_CHECK(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_CHECK(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_CHECK(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_CHECK(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_CHECK((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_CHECK((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_CHECK((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_CHECK((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((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_CHECK(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(-4,-4,-4,-4));
STATIC_REQUIRE(int2x2() * int2x2() == int2x2()); STATIC_CHECK(int2x2() * int2x2() == int2x2());
STATIC_REQUIRE(int3x3() * int3x3() == int3x3()); STATIC_CHECK(int3x3() * int3x3() == int3x3());
STATIC_REQUIRE(int2(1,2) * int2x2() == int2(1,2)); STATIC_CHECK(int2(1,2) * int2x2() == int2(1,2));
STATIC_REQUIRE(int3(1,2,3) * int3x3() == int3(1,2,3)); STATIC_CHECK(int3(1,2,3) * int3x3() == int3(1,2,3));
STATIC_REQUIRE(int4(1,2,3,4) * int4x4() == int4(1,2,3,4)); 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_CHECK((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_CHECK((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_CHECK((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_CHECK((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(0,1,0,1) || int2x2(1,0,1,0)) == bool2x2(1,1,1,1));
{ {
int2x2 v{1,2,3,4}; int2x2 v{1,2,3,4};
REQUIRE(&v == &(v += 3)); CHECK(&v == &(v += 3));
REQUIRE(v == int2x2{4,5,6,7}); CHECK(v == int2x2{4,5,6,7});
REQUIRE(&v == &(v += int2x2{1,2,3,4})); CHECK(&v == &(v += int2x2{1,2,3,4}));
REQUIRE(v == int2x2{5,7,9,11}); CHECK(v == int2x2{5,7,9,11});
} }
{ {
int2x2 v{4,5,6,7}; int2x2 v{4,5,6,7};
REQUIRE(&v == &(v -= 3)); CHECK(&v == &(v -= 3));
REQUIRE(v == int2x2{1,2,3,4}); CHECK(v == int2x2{1,2,3,4});
REQUIRE(&v == &(v -= int2x2{2,4,6,8})); CHECK(&v == &(v -= int2x2{2,4,6,8}));
REQUIRE(v == int2x2{-1,-2,-3,-4}); CHECK(v == int2x2{-1,-2,-3,-4});
} }
{ {
int2x2 v{1,2,3,4}; int2x2 v{1,2,3,4};
REQUIRE(&v == &(v *= 3)); CHECK(&v == &(v *= 3));
REQUIRE(v == int2x2{3,6,9,12}); CHECK(v == int2x2{3,6,9,12});
} }
{ {
int4 v{0, 0, 0, 1}; int4 v{0, 0, 0, 1};
REQUIRE(&v == &(v *= translate(int3{1,2,3}))); CHECK(&v == &(v *= translate(int3{1,2,3})));
REQUIRE(v == uapprox4(1,2,3,1)); CHECK(v == uapprox4(1,2,3,1));
} }
{ {
int3 v{1, 2, 3}; int3 v{1, 2, 3};
REQUIRE(&v == &(v *= int3x3(scale(int3{2,3,4})))); CHECK(&v == &(v *= int3x3(scale(int3{2,3,4}))));
REQUIRE(v == int3(2,6,12)); CHECK(v == int3(2,6,12));
} }
{ {
int4x4 v = translate(int3{1, 2, 3}); int4x4 v = translate(int3{1, 2, 3});
REQUIRE(&v == &(v *= translate(int3{1,2,3}))); CHECK(&v == &(v *= translate(int3{1,2,3})));
REQUIRE(v == translate(int3{2,4,6})); CHECK(v == translate(int3{2,4,6}));
} }
{ {
int3x3 v = int3x3(scale(int3{1, 2, 3})); int3x3 v = int3x3(scale(int3{1, 2, 3}));
REQUIRE(&v == &(v *= int3x3(scale(int3{2,3,4})))); CHECK(&v == &(v *= int3x3(scale(int3{2,3,4}))));
REQUIRE(v == int3x3(scale(int3{2,6,12}))); CHECK(v == int3x3(scale(int3{2,6,12})));
} }
{ {
int2x2 v1{11,12,11,12}; int2x2 v1{11,12,11,12};
REQUIRE(&v1 == &(v1 &= 6)); CHECK(&v1 == &(v1 &= 6));
REQUIRE(v1 == int2x2(2,4,2,4)); CHECK(v1 == int2x2(2,4,2,4));
int2x2 v2{6,7,6,7}; int2x2 v2{6,7,6,7};
REQUIRE(&v2 == &(v2 &= int2x2(11,12,11,12))); CHECK(&v2 == &(v2 &= int2x2(11,12,11,12)));
REQUIRE(v2 == int2x2(2,4,2,4)); CHECK(v2 == int2x2(2,4,2,4));
} }
{ {
int2x2 v1{11,12,11,12}; int2x2 v1{11,12,11,12};
REQUIRE(&v1 == &(v1 |= 6)); CHECK(&v1 == &(v1 |= 6));
REQUIRE(v1 == int2x2(15,14,15,14)); CHECK(v1 == int2x2(15,14,15,14));
int2x2 v2{6,7,6,7}; int2x2 v2{6,7,6,7};
REQUIRE(&v2 == &(v2 |= int2x2(11,12,11,12))); CHECK(&v2 == &(v2 |= int2x2(11,12,11,12)));
REQUIRE(v2 == int2x2(15,15,15,15)); CHECK(v2 == int2x2(15,15,15,15));
} }
{ {
int2x2 v1{11,12,11,12}; int2x2 v1{11,12,11,12};
REQUIRE(&v1 == &(v1 ^= 6)); CHECK(&v1 == &(v1 ^= 6));
REQUIRE(v1 == int2x2(13,10,13,10)); CHECK(v1 == int2x2(13,10,13,10));
int2x2 v2{6,7,6,7}; int2x2 v2{6,7,6,7};
REQUIRE(&v2 == &(v2 ^= int2x2(11,12,11,12))); CHECK(&v2 == &(v2 ^= int2x2(11,12,11,12)));
REQUIRE(v2 == int2x2(13,11,13,11)); CHECK(v2 == int2x2(13,11,13,11));
} }
} }
SUBCASE("relational functions") { SUBCASE("relational functions") {
STATIC_REQUIRE_FALSE(any(bool2x2(false, false, false, false))); STATIC_CHECK_FALSE(any(bool2x2(false, false, false, false)));
STATIC_REQUIRE(any(bool2x2(true, false, true, false))); STATIC_CHECK(any(bool2x2(true, false, true, false)));
STATIC_REQUIRE(any(bool2x2(false, true, false, true))); STATIC_CHECK(any(bool2x2(false, true, false, true)));
STATIC_REQUIRE(any(bool2x2(true, true, true, true))); STATIC_CHECK(any(bool2x2(true, true, true, true)));
STATIC_REQUIRE_FALSE(any(int2x2(0, 0, 0, 0))); STATIC_CHECK_FALSE(any(int2x2(0, 0, 0, 0)));
STATIC_REQUIRE(any(int2x2(1, 0, 1, 0))); STATIC_CHECK(any(int2x2(1, 0, 1, 0)));
STATIC_REQUIRE(any(int2x2(0, 1, 0, 1))); STATIC_CHECK(any(int2x2(0, 1, 0, 1)));
STATIC_REQUIRE(any(int2x2(1, 1, 1, 1))); STATIC_CHECK(any(int2x2(1, 1, 1, 1)));
STATIC_REQUIRE_FALSE(all(bool2x2(false, false, false, false))); STATIC_CHECK_FALSE(all(bool2x2(false, false, false, false)));
STATIC_REQUIRE_FALSE(all(bool2x2(true, false, true, false))); STATIC_CHECK_FALSE(all(bool2x2(true, false, true, false)));
STATIC_REQUIRE_FALSE(all(bool2x2(false, true, false, true))); STATIC_CHECK_FALSE(all(bool2x2(false, true, false, true)));
STATIC_REQUIRE(all(bool2x2(true, true, true, true))); STATIC_CHECK(all(bool2x2(true, true, true, true)));
STATIC_REQUIRE_FALSE(all(int2x2(0, 0, 0, 0))); STATIC_CHECK_FALSE(all(int2x2(0, 0, 0, 0)));
STATIC_REQUIRE_FALSE(all(int2x2(1, 0, 1, 0))); STATIC_CHECK_FALSE(all(int2x2(1, 0, 1, 0)));
STATIC_REQUIRE_FALSE(all(int2x2(0, 1, 0, 1))); STATIC_CHECK_FALSE(all(int2x2(0, 1, 0, 1)));
STATIC_REQUIRE(all(int2x2(1, 1, 1, 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_CHECK(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_CHECK(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_CHECK(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), 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_CHECK(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_CHECK(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_CHECK(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(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_CHECK(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(not_equal_to(int2x2(1,1,1,1), int2x2(0,1,2,3)) == bool2x2(true, false, true, true));
} }
SUBCASE("transpose") { SUBCASE("transpose") {
STATIC_REQUIRE(transpose(int2x2( STATIC_CHECK(transpose(int2x2(
1, 2, 1, 2,
3, 4 3, 4
)) == int2x2( )) == int2x2(
@@ -207,7 +207,7 @@ TEST_CASE("vmath/mat_fun") {
2, 4 2, 4
)); ));
STATIC_REQUIRE(transpose(int3x3( STATIC_CHECK(transpose(int3x3(
1, 2, 3, 1, 2, 3,
4, 5, 6, 4, 5, 6,
7, 8, 9 7, 8, 9
@@ -217,7 +217,7 @@ TEST_CASE("vmath/mat_fun") {
3, 6, 9 3, 6, 9
)); ));
STATIC_REQUIRE(transpose(int4x4( STATIC_CHECK(transpose(int4x4(
1, 2, 3, 4, 1, 2, 3, 4,
5, 6, 7, 8, 5, 6, 7, 8,
9, 10, 11, 12, 9, 10, 11, 12,
@@ -234,32 +234,32 @@ TEST_CASE("vmath/mat_fun") {
constexpr int2x2 m2{1,2,3,4}; constexpr int2x2 m2{1,2,3,4};
constexpr int3x3 m3{1,2,3,4,5,6,7,8,9}; 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}; 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_CHECK(determinant(m2) == determinant(transpose(m2)));
STATIC_REQUIRE(determinant(m3) == determinant(transpose(m3))); STATIC_CHECK(determinant(m3) == determinant(transpose(m3)));
STATIC_REQUIRE(determinant(m4) == determinant(transpose(m4))); STATIC_CHECK(determinant(m4) == determinant(transpose(m4)));
STATIC_REQUIRE(determinant(generate_frank_matrix<int, 2>()) == 1); STATIC_CHECK(determinant(generate_frank_matrix<int, 2>()) == 1);
STATIC_REQUIRE(determinant(generate_frank_matrix<int, 3>()) == 1); STATIC_CHECK(determinant(generate_frank_matrix<int, 3>()) == 1);
STATIC_REQUIRE(determinant(generate_frank_matrix<int, 4>()) == 1); STATIC_CHECK(determinant(generate_frank_matrix<int, 4>()) == 1);
STATIC_REQUIRE(determinant(transpose(generate_frank_matrix<int, 2>())) == 1); STATIC_CHECK(determinant(transpose(generate_frank_matrix<int, 2>())) == 1);
STATIC_REQUIRE(determinant(transpose(generate_frank_matrix<int, 3>())) == 1); STATIC_CHECK(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, 4>())) == 1);
} }
SUBCASE("inverse") { SUBCASE("inverse") {
STATIC_REQUIRE(inverse(float2x2()) == float2x2()); STATIC_CHECK(inverse(float2x2()) == float2x2());
STATIC_REQUIRE(inverse(float3x3()) == float3x3()); STATIC_CHECK(inverse(float3x3()) == float3x3());
STATIC_REQUIRE(inverse(float4x4()) == float4x4()); STATIC_CHECK(inverse(float4x4()) == float4x4());
STATIC_REQUIRE(inverse(float2x2(0.5)) == float2x2(2.f)); STATIC_CHECK(inverse(float2x2(0.5)) == float2x2(2.f));
STATIC_REQUIRE(inverse(float3x3(0.5)) == float3x3(2.f)); STATIC_CHECK(inverse(float3x3(0.5)) == float3x3(2.f));
STATIC_REQUIRE(inverse(float4x4(0.5)) == float4x4(2.f)); STATIC_CHECK(inverse(float4x4(0.5)) == float4x4(2.f));
{ {
constexpr float4x4 m1 = translate(float3(1.f, 2.f, 3.f)); constexpr float4x4 m1 = translate(float3(1.f, 2.f, 3.f));
constexpr float4x4 rm1 = inverse(m1); constexpr float4x4 rm1 = inverse(m1);
STATIC_REQUIRE(all(approx( STATIC_CHECK(all(approx(
unit4_z<float> * m1 * rm1, unit4_z<float> * m1 * rm1,
unit4_z<float>))); unit4_z<float>)));
} }
@@ -268,7 +268,7 @@ TEST_CASE("vmath/mat_fun") {
const float3 axis2 = normalize(float3(1.f, 2.f, 3.f)); const float3 axis2 = normalize(float3(1.f, 2.f, 3.f));
const float4x4 m2 = rotate(0.5f,axis2); const float4x4 m2 = rotate(0.5f,axis2);
const float4x4 rm2 = inverse(m2); const float4x4 rm2 = inverse(m2);
REQUIRE(all(approx( CHECK(all(approx(
unit4_z<float> * m2 * rm2, unit4_z<float> * m2 * rm2,
unit4_z<float>))); unit4_z<float>)));
} }
@@ -277,7 +277,7 @@ TEST_CASE("vmath/mat_fun") {
const float3 axis3 = normalize(float3(1.f, 2.f, 3.f)); const float3 axis3 = normalize(float3(1.f, 2.f, 3.f));
const float3x3 m3 = float3x3(rotate(0.5f,axis3)); const float3x3 m3 = float3x3(rotate(0.5f,axis3));
const float3x3 rm3 = inverse(m3); const float3x3 rm3 = inverse(m3);
REQUIRE(all(approx( CHECK(all(approx(
unit3_z<float> * m3 * rm3, unit3_z<float> * m3 * rm3,
unit3_z<float>))); unit3_z<float>)));
} }
@@ -286,7 +286,7 @@ TEST_CASE("vmath/mat_fun") {
const float3 axis4 = normalize(float3(0.f, 0.f, 3.f)); const float3 axis4 = normalize(float3(0.f, 0.f, 3.f));
const float2x2 m4 = float2x2(rotate(0.5f,axis4)); const float2x2 m4 = float2x2(rotate(0.5f,axis4));
const float2x2 rm4 = inverse(m4); const float2x2 rm4 = inverse(m4);
REQUIRE(all(approx( CHECK(all(approx(
unit2_y<float> * m4 * rm4, unit2_y<float> * m4 * rm4,
unit2_y<float>))); unit2_y<float>)));
} }

280
untests/vmath_mat_tests.cpp
View File

@@ -14,81 +14,81 @@ namespace
TEST_CASE("vmath/mat") { TEST_CASE("vmath/mat") {
SUBCASE("size/sizeof") { SUBCASE("size/sizeof") {
STATIC_REQUIRE(int2x2{}.size == 2); STATIC_CHECK(int2x2{}.size == 2);
STATIC_REQUIRE(int3x3{}.size == 3); STATIC_CHECK(int3x3{}.size == 3);
STATIC_REQUIRE(int4x4{}.size == 4); STATIC_CHECK(int4x4{}.size == 4);
STATIC_REQUIRE(sizeof(int2x2{}) == sizeof(int) * 2 * 2); STATIC_CHECK(sizeof(int2x2{}) == sizeof(int) * 2 * 2);
STATIC_REQUIRE(sizeof(int3x3{}) == sizeof(int) * 3 * 3); STATIC_CHECK(sizeof(int3x3{}) == sizeof(int) * 3 * 3);
STATIC_REQUIRE(sizeof(int4x4{}) == sizeof(int) * 4 * 4); STATIC_CHECK(sizeof(int4x4{}) == sizeof(int) * 4 * 4);
} }
SUBCASE("guides") { SUBCASE("guides") {
STATIC_REQUIRE(mat{1,2,3,4}.size == 2); STATIC_CHECK(mat{1,2,3,4}.size == 2);
STATIC_REQUIRE(mat{{1,2},{3,4}}.size == 2); STATIC_CHECK(mat{{1,2},{3,4}}.size == 2);
STATIC_REQUIRE(mat{vec{1,2},vec{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_CHECK(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_CHECK(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_CHECK(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{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_CHECK(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_CHECK(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_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_REQUIRE(mat{mat{1,2,3,4,5,6,7,8,9},vec{5,6,7}}.size == 4); STATIC_CHECK(mat{mat{1,2,3,4,5,6,7,8,9},vec{5,6,7}}.size == 4);
} }
SUBCASE("ctors") { SUBCASE("ctors") {
{ {
STATIC_REQUIRE(int2x2()[0] == int2(1,0)); STATIC_CHECK(int2x2()[0] == int2(1,0));
STATIC_REQUIRE(int2x2()[1] == int2(0,1)); STATIC_CHECK(int2x2()[1] == int2(0,1));
STATIC_REQUIRE(int2x2(1,2,3,4)[0] == int2(1,2)); STATIC_CHECK(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)[1] == int2(3,4));
STATIC_REQUIRE(int2x2({1,2},{3,4})[0] == int2(1,2)); STATIC_CHECK(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})[1] == int2(3,4));
} }
{ {
constexpr int2x2 v(1,2,3,4); constexpr int2x2 v(1,2,3,4);
constexpr int2x2 v2 = v; 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 v(1,2,3,4);
constexpr int2x2 v2 = std::move(v); 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_CHECK(int2x2() == int2x2(1,0,0,1));
STATIC_REQUIRE(int2x2(2) == int2x2(2,0,0,2)); STATIC_CHECK(int2x2(2) == int2x2(2,0,0,2));
STATIC_REQUIRE(int2x2(int2{2,3}) == int2x2(2,0,0,3)); STATIC_CHECK(int2x2(int2{2,3}) == int2x2(2,0,0,3));
STATIC_REQUIRE(int2x2(1,2,3,4) == int2x2(1,2,3,4)); STATIC_CHECK(int2x2(1,2,3,4) == int2x2(1,2,3,4));
STATIC_REQUIRE(int2x2({1,2},{3,4}) == int2x2(1,2,3,4)); STATIC_CHECK(int2x2({1,2},{3,4}) == int2x2(1,2,3,4));
STATIC_REQUIRE(int2x2(int2x2({1,2},{3,4})) == int2x2(1,2,3,4)); STATIC_CHECK(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_CHECK(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(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_CHECK(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_CHECK(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_CHECK(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_CHECK(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_CHECK(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_CHECK(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_CHECK(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_CHECK(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(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_CHECK(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_CHECK(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_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_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_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_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_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_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_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_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_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_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_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_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(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 v(1,2,3,4);
int2x2 v2; int2x2 v2;
v2 = v; v2 = v;
REQUIRE(v2 == int2x2(1,2,3,4)); CHECK(v2 == int2x2(1,2,3,4));
} }
{ {
int2x2 v(1,2,3,4); int2x2 v(1,2,3,4);
int2x2 v2; int2x2 v2;
v2 = std::move(v); 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 v1(1,2,3,4);
int2x2 v2(4,5,6,7); int2x2 v2(4,5,6,7);
v1.swap(v2); v1.swap(v2);
REQUIRE(v1 == int2x2(4,5,6,7)); CHECK(v1 == int2x2(4,5,6,7));
REQUIRE(v2 == int2x2(1,2,3,4)); CHECK(v2 == int2x2(1,2,3,4));
} }
{ {
int2x2 v1(1,2,3,4); int2x2 v1(1,2,3,4);
int2x2 v2(4,5,6,7); int2x2 v2(4,5,6,7);
swap(v1, v2); swap(v1, v2);
REQUIRE(v1 == int2x2(4,5,6,7)); CHECK(v1 == int2x2(4,5,6,7));
REQUIRE(v2 == int2x2(1,2,3,4)); CHECK(v2 == int2x2(1,2,3,4));
} }
} }
@@ -128,121 +128,121 @@ TEST_CASE("vmath/mat") {
{ {
int2x2 m{1,2,3,4}; int2x2 m{1,2,3,4};
REQUIRE(*m.begin() == vec{1,2}); CHECK(*m.begin() == vec{1,2});
REQUIRE(*(m.begin() + 1) == vec{3,4}); CHECK(*(m.begin() + 1) == vec{3,4});
REQUIRE(*(m.end() - 1) == vec{3,4}); CHECK(*(m.end() - 1) == vec{3,4});
REQUIRE(*(m.end() - 2) == vec{1,2}); CHECK(*(m.end() - 2) == vec{1,2});
REQUIRE(m.begin() + 2 == m.end()); CHECK(m.begin() + 2 == m.end());
REQUIRE(m.end() - 2 == m.begin()); CHECK(m.end() - 2 == m.begin());
REQUIRE(*m.cbegin() == vec{1,2}); CHECK(*m.cbegin() == vec{1,2});
REQUIRE(*(m.cbegin() + 1) == vec{3,4}); CHECK(*(m.cbegin() + 1) == vec{3,4});
REQUIRE(*(m.cend() - 1) == vec{3,4}); CHECK(*(m.cend() - 1) == vec{3,4});
REQUIRE(*(m.cend() - 2) == vec{1,2}); CHECK(*(m.cend() - 2) == vec{1,2});
REQUIRE(m.cbegin() + 2 == m.cend()); CHECK(m.cbegin() + 2 == m.cend());
REQUIRE(m.cend() - 2 == m.cbegin()); CHECK(m.cend() - 2 == m.cbegin());
REQUIRE(*m.rbegin() == vec{3,4}); CHECK(*m.rbegin() == vec{3,4});
REQUIRE(*(m.rbegin() + 1) == vec{1,2}); CHECK(*(m.rbegin() + 1) == vec{1,2});
REQUIRE(*(m.rend() - 1) == vec{1,2}); CHECK(*(m.rend() - 1) == vec{1,2});
REQUIRE(*(m.rend() - 2) == vec{3,4}); CHECK(*(m.rend() - 2) == vec{3,4});
REQUIRE(m.rbegin() + 2 == m.rend()); CHECK(m.rbegin() + 2 == m.rend());
REQUIRE(m.rend() - 2 == m.rbegin()); CHECK(m.rend() - 2 == m.rbegin());
REQUIRE(*m.crbegin() == vec{3,4}); CHECK(*m.crbegin() == vec{3,4});
REQUIRE(*(m.crbegin() + 1) == vec{1,2}); CHECK(*(m.crbegin() + 1) == vec{1,2});
REQUIRE(*(m.crend() - 1) == vec{1,2}); CHECK(*(m.crend() - 1) == vec{1,2});
REQUIRE(*(m.crend() - 2) == vec{3,4}); CHECK(*(m.crend() - 2) == vec{3,4});
REQUIRE(m.crbegin() + 2 == m.crend()); CHECK(m.crbegin() + 2 == m.crend());
REQUIRE(m.crend() - 2 == m.crbegin()); CHECK(m.crend() - 2 == m.crbegin());
*m.begin() = {5,6}; *m.begin() = {5,6};
REQUIRE(m == int2x2{5,6,3,4}); CHECK(m == int2x2{5,6,3,4});
*m.rbegin() = {7,8}; *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}; const int2x2 m{1,2,3,4};
REQUIRE(*m.begin() == vec{1,2}); CHECK(*m.begin() == vec{1,2});
REQUIRE(*(m.begin() + 1) == vec{3,4}); CHECK(*(m.begin() + 1) == vec{3,4});
REQUIRE(*(m.end() - 1) == vec{3,4}); CHECK(*(m.end() - 1) == vec{3,4});
REQUIRE(*(m.end() - 2) == vec{1,2}); CHECK(*(m.end() - 2) == vec{1,2});
REQUIRE(m.begin() + 2 == m.end()); CHECK(m.begin() + 2 == m.end());
REQUIRE(m.end() - 2 == m.begin()); CHECK(m.end() - 2 == m.begin());
REQUIRE(*m.cbegin() == vec{1,2}); CHECK(*m.cbegin() == vec{1,2});
REQUIRE(*(m.cbegin() + 1) == vec{3,4}); CHECK(*(m.cbegin() + 1) == vec{3,4});
REQUIRE(*(m.cend() - 1) == vec{3,4}); CHECK(*(m.cend() - 1) == vec{3,4});
REQUIRE(*(m.cend() - 2) == vec{1,2}); CHECK(*(m.cend() - 2) == vec{1,2});
REQUIRE(m.cbegin() + 2 == m.cend()); CHECK(m.cbegin() + 2 == m.cend());
REQUIRE(m.cend() - 2 == m.cbegin()); CHECK(m.cend() - 2 == m.cbegin());
REQUIRE(*m.rbegin() == vec{3,4}); CHECK(*m.rbegin() == vec{3,4});
REQUIRE(*(m.rbegin() + 1) == vec{1,2}); CHECK(*(m.rbegin() + 1) == vec{1,2});
REQUIRE(*(m.rend() - 1) == vec{1,2}); CHECK(*(m.rend() - 1) == vec{1,2});
REQUIRE(*(m.rend() - 2) == vec{3,4}); CHECK(*(m.rend() - 2) == vec{3,4});
REQUIRE(m.rbegin() + 2 == m.rend()); CHECK(m.rbegin() + 2 == m.rend());
REQUIRE(m.rend() - 2 == m.rbegin()); CHECK(m.rend() - 2 == m.rbegin());
REQUIRE(*m.crbegin() == vec{3,4}); CHECK(*m.crbegin() == vec{3,4});
REQUIRE(*(m.crbegin() + 1) == vec{1,2}); CHECK(*(m.crbegin() + 1) == vec{1,2});
REQUIRE(*(m.crend() - 1) == vec{1,2}); CHECK(*(m.crend() - 1) == vec{1,2});
REQUIRE(*(m.crend() - 2) == vec{3,4}); CHECK(*(m.crend() - 2) == vec{3,4});
REQUIRE(m.crbegin() + 2 == m.crend()); CHECK(m.crbegin() + 2 == m.crend());
REQUIRE(m.crend() - 2 == m.crbegin()); CHECK(m.crend() - 2 == m.crbegin());
} }
} }
SUBCASE("data") { SUBCASE("data") {
{ {
int2x2 m2; int2x2 m2;
REQUIRE(m2.data() == &m2[0]); CHECK(m2.data() == &m2[0]);
int3x3 m3; int3x3 m3;
REQUIRE(m3.data() == &m3[0]); CHECK(m3.data() == &m3[0]);
int4x4 m4; int4x4 m4;
REQUIRE(m4.data() == &m4[0]); CHECK(m4.data() == &m4[0]);
} }
{ {
const int2x2 m2; const int2x2 m2;
REQUIRE(m2.data() == &m2[0]); CHECK(m2.data() == &m2[0]);
const int3x3 m3; const int3x3 m3;
REQUIRE(m3.data() == &m3[0]); CHECK(m3.data() == &m3[0]);
const int4x4 m4; const int4x4 m4;
REQUIRE(m4.data() == &m4[0]); CHECK(m4.data() == &m4[0]);
} }
} }
SUBCASE("operator[]") { SUBCASE("operator[]") {
{ {
STATIC_REQUIRE(int2x2()[0] == int2(1,0)); STATIC_CHECK(int2x2()[0] == int2(1,0));
STATIC_REQUIRE(int2x2()[1] == int2(0,1)); STATIC_CHECK(int2x2()[1] == int2(0,1));
STATIC_REQUIRE(int3x3()[0] == int3(1,0,0)); STATIC_CHECK(int3x3()[0] == int3(1,0,0));
STATIC_REQUIRE(int3x3()[1] == int3(0,1,0)); STATIC_CHECK(int3x3()[1] == int3(0,1,0));
STATIC_REQUIRE(int3x3()[2] == int3(0,0,1)); STATIC_CHECK(int3x3()[2] == int3(0,0,1));
STATIC_REQUIRE(int4x4()[0] == int4(1,0,0,0)); STATIC_CHECK(int4x4()[0] == int4(1,0,0,0));
STATIC_REQUIRE(int4x4()[1] == int4(0,1,0,0)); STATIC_CHECK(int4x4()[1] == int4(0,1,0,0));
STATIC_REQUIRE(int4x4()[2] == int4(0,0,1,0)); STATIC_CHECK(int4x4()[2] == int4(0,0,1,0));
STATIC_REQUIRE(int4x4()[3] == int4(0,0,0,1)); STATIC_CHECK(int4x4()[3] == int4(0,0,0,1));
} }
{ {
int2x2 v; int2x2 v;
v[0] = int2(1,2); v[0] = int2(1,2);
v[1] = int2(3,4); v[1] = int2(3,4);
REQUIRE(v == int2x2(1,2,3,4)); CHECK(v == int2x2(1,2,3,4));
} }
{ {
int3x3 v; int3x3 v;
v[0] = int3(1,2,3); v[0] = int3(1,2,3);
v[1] = int3(4,5,6); v[1] = int3(4,5,6);
v[2] = int3(7,8,9); 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; int4x4 v;
@@ -250,33 +250,35 @@ TEST_CASE("vmath/mat") {
v[1] = int4(5,6,7,8); v[1] = int4(5,6,7,8);
v[2] = int4(9,10,11,12); v[2] = int4(9,10,11,12);
v[3] = int4(13,14,15,16); 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") { SUBCASE("at") {
STATIC_REQUIRE(int2x2(1,2,3,4).at(0) == int2(1,2)); STATIC_CHECK(int2x2(1,2,3,4).at(0) == int2(1,2));
STATIC_REQUIRE(int2x2(1,2,3,4).at(1) == int2(3,4)); STATIC_CHECK(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); #ifndef VMATH_HPP_NO_EXCEPTIONS
CHECK_THROWS_AS((void)int2x2(1,2,3,4).at(2), std::out_of_range);
#endif
} }
SUBCASE("operator==/operator!=") { SUBCASE("operator==/operator!=") {
STATIC_REQUIRE(int2x2(1,2,3,4) == int2x2(1,2,3,4)); STATIC_CHECK(int2x2(1,2,3,4) == int2x2(1,2,3,4));
STATIC_REQUIRE_FALSE(int2x2(1,2,3,4) == int2x2(2,2,3,4)); STATIC_CHECK_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_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_CHECK_FALSE(int2x2(1,2,3,4) != int2x2(1,2,3,4));
STATIC_REQUIRE(int2x2(1,2,3,4) != int2x2(2,2,3,4)); STATIC_CHECK(int2x2(1,2,3,4) != int2x2(2,2,3,4));
STATIC_REQUIRE(int2x2(1,2,3,4) != int2x2(1,3,3,4)); STATIC_CHECK(int2x2(1,2,3,4) != int2x2(1,3,3,4));
} }
SUBCASE("operator<") { 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_CHECK(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_FALSE(int2x2(1,2,3,4) < int2x2(1,1,3,4));
STATIC_REQUIRE(int2x2(0,3,3,4) < int2x2(1,2,3,4)); STATIC_CHECK(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_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") { TEST_CASE("vmath/qua_fun") {
SUBCASE("Operators") { SUBCASE("Operators") {
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_REQUIRE(-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_CHECK(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,5,7,9) == qua(-2,-3,-4,-5));
{ {
qua v{1,2,3,4}; qua v{1,2,3,4};
REQUIRE(&v == &(v += qua{3,4,5,6})); CHECK(&v == &(v += qua{3,4,5,6}));
REQUIRE(v == qua{4,6,8,10}); CHECK(v == qua{4,6,8,10});
} }
{ {
qua v{1,2,3,4}; qua v{1,2,3,4};
REQUIRE(&v == &(v -= qua{3,4,5,6})); CHECK(&v == &(v -= qua{3,4,5,6}));
REQUIRE(v == qua{-2,-2,-2,-2}); CHECK(v == qua{-2,-2,-2,-2});
} }
STATIC_REQUIRE(qua(1,2,3,4) * 2 == qua(2,4,6,8)); STATIC_CHECK(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(2,4,6,8) / 2 == qua(1,2,3,4));
STATIC_REQUIRE(2 * qua(1,2,3,4) == qua(2,4,6,8)); STATIC_CHECK(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(8 / qua(1,2,4,8) == qua(8,4,2,1));
{ {
qua v{1,2,3,4}; qua v{1,2,3,4};
REQUIRE(&v == &(v *= 2)); CHECK(&v == &(v *= 2));
REQUIRE(v == qua{2,4,6,8}); CHECK(v == qua{2,4,6,8});
REQUIRE(&v == &(v *= qua<int>{})); CHECK(&v == &(v *= qua<int>{}));
REQUIRE(v == qua{2,4,6,8}); CHECK(v == qua{2,4,6,8});
} }
{ {
qua v{2,4,6,8}; qua v{2,4,6,8};
REQUIRE(&v == &(v /= 2)); CHECK(&v == &(v /= 2));
REQUIRE(v == qua{1,2,3,4}); CHECK(v == qua{1,2,3,4});
} }
{ {
float3 v{1,0,0}; float3 v{1,0,0};
REQUIRE(&v == &(v *= qfloat{0,0,0.7071067812f,0.7071067812f})); CHECK(&v == &(v *= qfloat{0,0,0.7071067812f,0.7071067812f}));
REQUIRE(v == uapprox3(0.f,1.f,0.f)); CHECK(v == uapprox3(0.f,1.f,0.f));
} }
STATIC_REQUIRE(qfloat{} * qfloat{} == qfloat{}); STATIC_CHECK(qfloat{} * qfloat{} == qfloat{});
STATIC_REQUIRE(float3{1,2,3} * qfloat{} == uapprox3(1.f,2.f,3.f)); STATIC_CHECK(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(float3{1,0,0} * qfloat{0,0,0.7071067812f,0.7071067812f} == uapprox3(0.f,1.f,0.f));
} }
SUBCASE("Common Functions") { SUBCASE("Common Functions") {
{ {
REQUIRE(all(approx( CHECK(all(approx(
qrotate_z(radians(5.f)), qrotate_z(radians(5.f)),
nlerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 0.f), nlerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 0.f),
0.00001f))); 0.00001f)));
REQUIRE(all(approx( CHECK(all(approx(
qrotate_z(radians(6.f)), qrotate_z(radians(6.f)),
nlerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 0.1f), nlerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 0.1f),
0.00001f))); 0.00001f)));
REQUIRE(all(approx( CHECK(all(approx(
qrotate_z(radians(10.f)), qrotate_z(radians(10.f)),
nlerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 0.5f), nlerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 0.5f),
0.00001f))); 0.00001f)));
REQUIRE(all(approx( CHECK(all(approx(
qrotate_z(radians(15.f)), qrotate_z(radians(15.f)),
nlerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 1.f), nlerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 1.f),
0.00001f))); 0.00001f)));
REQUIRE(all(approx( CHECK(all(approx(
qrotate_z(radians(315.f)), qrotate_z(radians(315.f)),
nlerp(qrotate_z(radians(270.f)), qrotate_z(radians(0.f)), 0.5f)))); nlerp(qrotate_z(radians(270.f)), qrotate_z(radians(0.f)), 0.5f))));
REQUIRE(all(approx( CHECK(all(approx(
qrotate_z(radians(290.f)), qrotate_z(radians(290.f)),
nlerp(qrotate_z(radians(220.f)), qrotate_z(radians(0.f)), 0.5f)))); nlerp(qrotate_z(radians(220.f)), qrotate_z(radians(0.f)), 0.5f))));
} }
{ {
REQUIRE(all(approx( CHECK(all(approx(
qrotate_z(radians(5.f)), qrotate_z(radians(5.f)),
slerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 0.f), slerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 0.f),
0.00001f))); 0.00001f)));
REQUIRE(all(approx( CHECK(all(approx(
qrotate_z(radians(6.f)), qrotate_z(radians(6.f)),
slerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 0.1f), slerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 0.1f),
0.00001f))); 0.00001f)));
REQUIRE(all(approx( CHECK(all(approx(
qrotate_z(radians(10.f)), qrotate_z(radians(10.f)),
slerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 0.5f), slerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 0.5f),
0.00001f))); 0.00001f)));
REQUIRE(all(approx( CHECK(all(approx(
qrotate_z(radians(15.f)), qrotate_z(radians(15.f)),
slerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 1.f), slerp(qrotate_z(radians(5.f)), qrotate_z(radians(15.f)), 1.f),
0.00001f))); 0.00001f)));
REQUIRE(all(approx( CHECK(all(approx(
qrotate_z(radians(0.f)), qrotate_z(radians(0.f)),
slerp(qrotate_z(radians(0.f)), qrotate_z(radians(0.f)), 0.5f)))); slerp(qrotate_z(radians(0.f)), qrotate_z(radians(0.f)), 0.5f))));
REQUIRE(all(approx( CHECK(all(approx(
qrotate_z(radians(0.25f)), qrotate_z(radians(0.25f)),
slerp(qrotate_z(radians(0.f)), qrotate_z(radians(0.5f)), 0.5f)))); slerp(qrotate_z(radians(0.f)), qrotate_z(radians(0.5f)), 0.5f))));
REQUIRE(all(approx( CHECK(all(approx(
qrotate_z(radians(-45.f)), qrotate_z(radians(-45.f)),
slerp(qrotate_z(radians(0.f)), qrotate_z(radians(270.f)), 0.5f)))); slerp(qrotate_z(radians(0.f)), qrotate_z(radians(270.f)), 0.5f))));
REQUIRE(all(approx( CHECK(all(approx(
qrotate_z(radians(-70.f)), qrotate_z(radians(-70.f)),
slerp(qrotate_z(radians(0.f)), qrotate_z(radians(220.f)), 0.5f)))); slerp(qrotate_z(radians(0.f)), qrotate_z(radians(220.f)), 0.5f))));
REQUIRE(all(approx( CHECK(all(approx(
qrotate_z(radians(315.f)), qrotate_z(radians(315.f)),
slerp(qrotate_z(radians(270.f)), qrotate_z(radians(0.f)), 0.5f)))); slerp(qrotate_z(radians(270.f)), qrotate_z(radians(0.f)), 0.5f))));
REQUIRE(all(approx( CHECK(all(approx(
qrotate_z(radians(290.f)), qrotate_z(radians(290.f)),
slerp(qrotate_z(radians(220.f)), qrotate_z(radians(0.f)), 0.5f)))); slerp(qrotate_z(radians(220.f)), qrotate_z(radians(0.f)), 0.5f))));
} }
{ {
REQUIRE_FALSE(any(isnan(qfloat(1,1,1,1)))); CHECK_FALSE(any(isnan(qfloat(1,1,1,1))));
REQUIRE_FALSE(any(isinf(qfloat(1,1,1,1)))); CHECK_FALSE(any(isinf(qfloat(1,1,1,1))));
REQUIRE(all(isfinite(qfloat(1,1,1,1)))); CHECK(all(isfinite(qfloat(1,1,1,1))));
} }
} }
SUBCASE("Geometric Functions") { 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)); CHECK(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));
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_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));
REQUIRE(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)) * 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))); CHECK(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))); CHECK(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))); CHECK(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))); CHECK(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(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") { SUBCASE("Relational Functions") {
STATIC_REQUIRE(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)) == 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_CHECK(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_CHECK(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), 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_CHECK(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_CHECK(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_CHECK(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(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_CHECK(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(not_equal_to(qua(1,1,1,1), qua(0,1,2,3)) == bool4(true, false, true, true));
} }
SUBCASE("Quaternion Functions") { SUBCASE("Quaternion Functions") {
STATIC_REQUIRE(conjugate(qua(1,2,3,4)) == qua(-1,-2,-3,4)); STATIC_CHECK(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_CHECK(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(inverse(qua(0.f,0.f,0.7071067812f,0.7071067812f)).s == uapprox(0.7071067812f));
REQUIRE(inverse(qrotate_x(10.f)) == qrotate_x(-10.f)); CHECK(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(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") { TEST_CASE("vmath/qua") {
SUBCASE("size/sizeof") { SUBCASE("size/sizeof") {
STATIC_REQUIRE(qfloat{}.size == 4); STATIC_CHECK(qfloat{}.size == 4);
STATIC_REQUIRE(qdouble{}.size == 4); STATIC_CHECK(qdouble{}.size == 4);
STATIC_REQUIRE(sizeof(qfloat{}) == sizeof(float) * 4); STATIC_CHECK(sizeof(qfloat{}) == sizeof(float) * 4);
STATIC_REQUIRE(sizeof(qdouble{}) == sizeof(double) * 4); STATIC_CHECK(sizeof(qdouble{}) == sizeof(double) * 4);
} }
SUBCASE("guides") { SUBCASE("guides") {
STATIC_REQUIRE(qua{1,2,3,4}.size == 4); STATIC_CHECK(qua{1,2,3,4}.size == 4);
STATIC_REQUIRE(qua{{1,2,3},4}.size == 4); STATIC_CHECK(qua{{1,2,3},4}.size == 4);
STATIC_REQUIRE(qua{vec{1,2,3},4}.size == 4); STATIC_CHECK(qua{vec{1,2,3},4}.size == 4);
STATIC_REQUIRE(qua{{1,2,3,4}}.size == 4); STATIC_CHECK(qua{{1,2,3,4}}.size == 4);
STATIC_REQUIRE(qua(vec{1,2,3,4}).size == 4); STATIC_CHECK(qua(vec{1,2,3,4}).size == 4);
} }
SUBCASE("ctors") { SUBCASE("ctors") {
{ {
STATIC_REQUIRE(qfloat{}.v == uapprox3(0.f)); STATIC_CHECK(qfloat{}.v == uapprox3(0.f));
STATIC_REQUIRE(qfloat{}.s == uapprox(1.f)); STATIC_CHECK(qfloat{}.s == uapprox(1.f));
STATIC_REQUIRE(qfloat{1,2,3,4}.v == uapprox3(1.f,2.f,3.f)); STATIC_CHECK(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}.s == uapprox(4.f));
STATIC_REQUIRE(qfloat{{1,2,3},4}.v == uapprox3(1.f,2.f,3.f)); STATIC_CHECK(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}.s == uapprox(4.f));
STATIC_REQUIRE(qfloat{{1,2,3,4}}.v == uapprox3(1.f,2.f,3.f)); STATIC_CHECK(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}}.s == uapprox(4.f));
} }
{ {
constexpr qfloat q(1,2,3,4); constexpr qfloat q(1,2,3,4);
constexpr qfloat q2 = q; 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 q(1,2,3,4);
constexpr qfloat q2 = std::move(q); 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_CHECK(qfloat(1,2,3,4) == qfloat(1,2,3,4));
STATIC_REQUIRE(qfloat(float3(1,2,3),4) == qfloat(1,2,3,4)); STATIC_CHECK(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(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 v(1,2,3,4);
qfloat v2; qfloat v2;
v2 = v; v2 = v;
REQUIRE(v2 == qfloat(1,2,3,4)); CHECK(v2 == qfloat(1,2,3,4));
} }
{ {
qfloat v(1,2,3,4); qfloat v(1,2,3,4);
qfloat v2; qfloat v2;
v2 = std::move(v); 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 v1(1,2,3,4);
qfloat v2(4,5,6,7); qfloat v2(4,5,6,7);
v1.swap(v2); v1.swap(v2);
REQUIRE(v1 == qfloat(4,5,6,7)); CHECK(v1 == qfloat(4,5,6,7));
REQUIRE(v2 == qfloat(1,2,3,4)); CHECK(v2 == qfloat(1,2,3,4));
} }
{ {
qfloat v1(1,2,3,4); qfloat v1(1,2,3,4);
qfloat v2(4,5,6,7); qfloat v2(4,5,6,7);
swap(v1, v2); swap(v1, v2);
REQUIRE(v1 == qfloat(4,5,6,7)); CHECK(v1 == qfloat(4,5,6,7));
REQUIRE(v2 == qfloat(1,2,3,4)); CHECK(v2 == qfloat(1,2,3,4));
} }
} }
@@ -96,134 +96,136 @@ TEST_CASE("vmath/qua") {
{ {
qfloat v{1,2,3,4}; qfloat v{1,2,3,4};
REQUIRE(*v.begin() == 1); CHECK(*v.begin() == 1);
REQUIRE(*(v.begin() + 1) == 2); CHECK(*(v.begin() + 1) == 2);
REQUIRE(*(v.end() - 1) == 4); CHECK(*(v.end() - 1) == 4);
REQUIRE(*(v.end() - 2) == 3); CHECK(*(v.end() - 2) == 3);
REQUIRE(v.begin() + 4 == v.end()); CHECK(v.begin() + 4 == v.end());
REQUIRE(v.end() - 4 == v.begin()); CHECK(v.end() - 4 == v.begin());
REQUIRE(*v.cbegin() == 1); CHECK(*v.cbegin() == 1);
REQUIRE(*(v.cbegin() + 1) == 2); CHECK(*(v.cbegin() + 1) == 2);
REQUIRE(*(v.cend() - 1) == 4); CHECK(*(v.cend() - 1) == 4);
REQUIRE(*(v.cend() - 2) == 3); CHECK(*(v.cend() - 2) == 3);
REQUIRE(v.cbegin() + 4 == v.cend()); CHECK(v.cbegin() + 4 == v.cend());
REQUIRE(v.cend() - 4 == v.cbegin()); CHECK(v.cend() - 4 == v.cbegin());
REQUIRE(*v.rbegin() == 4); CHECK(*v.rbegin() == 4);
REQUIRE(*(v.rbegin() + 1) == 3); CHECK(*(v.rbegin() + 1) == 3);
REQUIRE(*(v.rend() - 1) == 1); CHECK(*(v.rend() - 1) == 1);
REQUIRE(*(v.rend() - 2) == 2); CHECK(*(v.rend() - 2) == 2);
REQUIRE(v.rbegin() + 4 == v.rend()); CHECK(v.rbegin() + 4 == v.rend());
REQUIRE(v.rend() - 4 == v.rbegin()); CHECK(v.rend() - 4 == v.rbegin());
REQUIRE(*v.crbegin() == 4); CHECK(*v.crbegin() == 4);
REQUIRE(*(v.crbegin() + 1) == 3); CHECK(*(v.crbegin() + 1) == 3);
REQUIRE(*(v.crend() - 1) == 1); CHECK(*(v.crend() - 1) == 1);
REQUIRE(*(v.crend() - 2) == 2); CHECK(*(v.crend() - 2) == 2);
REQUIRE(v.crbegin() + 4 == v.crend()); CHECK(v.crbegin() + 4 == v.crend());
REQUIRE(v.crend() - 4 == v.crbegin()); CHECK(v.crend() - 4 == v.crbegin());
*v.begin() = 3; *v.begin() = 3;
REQUIRE(v == qfloat{3,2,3,4}); CHECK(v == qfloat{3,2,3,4});
*v.rbegin() = 5; *v.rbegin() = 5;
REQUIRE(v == qfloat{3,2,3,5}); CHECK(v == qfloat{3,2,3,5});
} }
{ {
const qfloat v{1,2,3,4}; const qfloat v{1,2,3,4};
REQUIRE(*v.begin() == 1); CHECK(*v.begin() == 1);
REQUIRE(*(v.begin() + 1) == 2); CHECK(*(v.begin() + 1) == 2);
REQUIRE(*(v.end() - 1) == 4); CHECK(*(v.end() - 1) == 4);
REQUIRE(*(v.end() - 2) == 3); CHECK(*(v.end() - 2) == 3);
REQUIRE(v.begin() + 4 == v.end()); CHECK(v.begin() + 4 == v.end());
REQUIRE(v.end() - 4 == v.begin()); CHECK(v.end() - 4 == v.begin());
REQUIRE(*v.cbegin() == 1); CHECK(*v.cbegin() == 1);
REQUIRE(*(v.cbegin() + 1) == 2); CHECK(*(v.cbegin() + 1) == 2);
REQUIRE(*(v.cend() - 1) == 4); CHECK(*(v.cend() - 1) == 4);
REQUIRE(*(v.cend() - 2) == 3); CHECK(*(v.cend() - 2) == 3);
REQUIRE(v.cbegin() + 4 == v.cend()); CHECK(v.cbegin() + 4 == v.cend());
REQUIRE(v.cend() - 4 == v.cbegin()); CHECK(v.cend() - 4 == v.cbegin());
REQUIRE(*v.rbegin() == 4); CHECK(*v.rbegin() == 4);
REQUIRE(*(v.rbegin() + 1) == 3); CHECK(*(v.rbegin() + 1) == 3);
REQUIRE(*(v.rend() - 1) == 1); CHECK(*(v.rend() - 1) == 1);
REQUIRE(*(v.rend() - 2) == 2); CHECK(*(v.rend() - 2) == 2);
REQUIRE(v.rbegin() + 4 == v.rend()); CHECK(v.rbegin() + 4 == v.rend());
REQUIRE(v.rend() - 4 == v.rbegin()); CHECK(v.rend() - 4 == v.rbegin());
REQUIRE(*v.crbegin() == 4); CHECK(*v.crbegin() == 4);
REQUIRE(*(v.crbegin() + 1) == 3); CHECK(*(v.crbegin() + 1) == 3);
REQUIRE(*(v.crend() - 1) == 1); CHECK(*(v.crend() - 1) == 1);
REQUIRE(*(v.crend() - 2) == 2); CHECK(*(v.crend() - 2) == 2);
REQUIRE(v.crbegin() + 4 == v.crend()); CHECK(v.crbegin() + 4 == v.crend());
REQUIRE(v.crend() - 4 == v.crbegin()); CHECK(v.crend() - 4 == v.crbegin());
} }
} }
SUBCASE("data") { SUBCASE("data") {
{ {
qfloat i2; qfloat i2;
REQUIRE(i2.data() == &i2[0]); CHECK(i2.data() == &i2[0]);
} }
{ {
const qfloat i2; const qfloat i2;
REQUIRE(i2.data() == &i2[0]); CHECK(i2.data() == &i2[0]);
} }
} }
SUBCASE("operator[]") { SUBCASE("operator[]") {
{ {
STATIC_REQUIRE(qua(1,2,3,4).v == vec(1,2,3)); STATIC_CHECK(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).s == 4);
} }
{ {
STATIC_REQUIRE(qua(1,2,3,4)[0] == 1); STATIC_CHECK(qua(1,2,3,4)[0] == 1);
STATIC_REQUIRE(qua(1,2,3,4)[1] == 2); STATIC_CHECK(qua(1,2,3,4)[1] == 2);
STATIC_REQUIRE(qua(1,2,3,4)[2] == 3); STATIC_CHECK(qua(1,2,3,4)[2] == 3);
STATIC_REQUIRE(qua(1,2,3,4)[3] == 4); STATIC_CHECK(qua(1,2,3,4)[3] == 4);
} }
{ {
qua<int> v; qua<int> v;
v.v = vec(1,2,3); v.v = vec(1,2,3);
v.s = 4; v.s = 4;
REQUIRE(v == qua(1,2,3,4)); CHECK(v == qua(1,2,3,4));
} }
} }
SUBCASE("at") { SUBCASE("at") {
STATIC_REQUIRE(qfloat(1,2,3,4).at(0) == 1); STATIC_CHECK(qfloat(1,2,3,4).at(0) == 1);
STATIC_REQUIRE(qfloat(1,2,3,4).at(1) == 2); STATIC_CHECK(qfloat(1,2,3,4).at(1) == 2);
STATIC_REQUIRE(qfloat(1,2,3,4).at(2) == 3); STATIC_CHECK(qfloat(1,2,3,4).at(2) == 3);
STATIC_REQUIRE(qfloat(1,2,3,4).at(3) == 4); STATIC_CHECK(qfloat(1,2,3,4).at(3) == 4);
REQUIRE_THROWS_AS((void)qfloat(1,2,3,4).at(4), std::out_of_range); #ifndef VMATH_HPP_NO_EXCEPTIONS
CHECK_THROWS_AS((void)qfloat(1,2,3,4).at(4), std::out_of_range);
#endif
} }
SUBCASE("operator==/operator!=") { SUBCASE("operator==/operator!=") {
STATIC_REQUIRE(qfloat(1,2,3,4) == qfloat(1,2,3,4)); STATIC_CHECK(qfloat(1,2,3,4) == qfloat(1,2,3,4));
STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) == qfloat(2,2,3,4)); STATIC_CHECK_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_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_CHECK_FALSE(qfloat(1,2,3,4) != qfloat(1,2,3,4));
STATIC_REQUIRE(qfloat(1,2,3,4) != qfloat(2,2,3,4)); STATIC_CHECK(qfloat(1,2,3,4) != qfloat(2,2,3,4));
STATIC_REQUIRE(qfloat(1,2,3,4) != qfloat(1,3,3,4)); STATIC_CHECK(qfloat(1,2,3,4) != qfloat(1,3,3,4));
} }
SUBCASE("operator<") { 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_CHECK(qfloat(0,2,3,4) < qfloat(1,2,3,4));
STATIC_REQUIRE(qfloat(1,1,3,4) < qfloat(1,2,3,4)); STATIC_CHECK(qfloat(1,1,3,4) < qfloat(1,2,3,4));
STATIC_REQUIRE(qfloat(1,2,2,4) < qfloat(1,2,3,4)); STATIC_CHECK(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(1,2,3,3) < qfloat(1,2,3,4));
STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) < qfloat(0,2,3,4)); STATIC_CHECK_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_CHECK_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_CHECK_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(1,2,3,3));
STATIC_REQUIRE(qfloat(0,3,3,4) < qfloat(1,2,3,4)); STATIC_CHECK(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_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") { TEST_CASE("vmath/vec_fun") {
SUBCASE("Detail") { SUBCASE("Detail") {
STATIC_REQUIRE(map_join([](const int& x){ STATIC_CHECK(map_join([](const int& x){
return x * 2; return x * 2;
}, int2{1}) == int2{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; return x + y;
}, int2{1}, int2{1}) == int2{2}); }, 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; return x + y + z;
}, int2{1}, int2{1}, int2{1}) == int2(3)); }, 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; return acc + x;
}, 0, int2{1}) == 2); }, 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; return acc + x + y;
}, 0, int2{1}, int2{1}) == 4); }, 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; return acc + x;
}, int2{1}) == 2); }, int2{1}) == 2);
} }
SUBCASE("Operators") { SUBCASE("Operators") {
STATIC_REQUIRE(+int2(1,-2) == int2(1,-2)); STATIC_CHECK(+int2(1,-2) == int2(1,-2));
STATIC_REQUIRE(-int2(1,-2) == int2(-1,2)); STATIC_CHECK(-int2(1,-2) == int2(-1,2));
STATIC_REQUIRE(~uint2(0xF0F0F0F0,0x0F0F0F0F) == uint2(0x0F0F0F0F,0xF0F0F0F0)); STATIC_CHECK(~uint2(0xF0F0F0F0,0x0F0F0F0F) == uint2(0x0F0F0F0F,0xF0F0F0F0));
STATIC_REQUIRE(!int3(-1,0,1) == bool3(false, true, false)); STATIC_CHECK(!int3(-1,0,1) == bool3(false, true, false));
STATIC_REQUIRE(int2(1,2) + 3 == int2(4,5)); STATIC_CHECK(int2(1,2) + 3 == int2(4,5));
STATIC_REQUIRE(int2(1,2) - 3 == int2(-2,-1)); STATIC_CHECK(int2(1,2) - 3 == int2(-2,-1));
STATIC_REQUIRE(int2(1,2) * 3 == int2(3,6)); STATIC_CHECK(int2(1,2) * 3 == int2(3,6));
STATIC_REQUIRE(int2(2,4) / 2 == int2(1,2)); STATIC_CHECK(int2(2,4) / 2 == int2(1,2));
STATIC_REQUIRE((int2(11,12) & 6) == int2(2,4)); STATIC_CHECK((int2(11,12) & 6) == int2(2,4));
STATIC_REQUIRE((int2(11,12) | 6) == int2(15,14)); STATIC_CHECK((int2(11,12) | 6) == int2(15,14));
STATIC_REQUIRE((int2(11,12) ^ 6) == int2(13,10)); STATIC_CHECK((int2(11,12) ^ 6) == int2(13,10));
STATIC_REQUIRE((int2(1,0) && 1) == bool2(1,0)); STATIC_CHECK((int2(1,0) && 1) == bool2(1,0));
STATIC_REQUIRE((int2(1,0) || 1) == bool2(1,1)); STATIC_CHECK((int2(1,0) || 1) == bool2(1,1));
STATIC_REQUIRE(3 + int2(1,2) == int2(4,5)); STATIC_CHECK(3 + int2(1,2) == int2(4,5));
STATIC_REQUIRE(3 - int2(1,2) == int2(2,1)); STATIC_CHECK(3 - int2(1,2) == int2(2,1));
STATIC_REQUIRE(3 * int2(1,2) == int2(3,6)); STATIC_CHECK(3 * int2(1,2) == int2(3,6));
STATIC_REQUIRE(4 / int2(2,4) == int2(2,1)); STATIC_CHECK(4 / int2(2,4) == int2(2,1));
STATIC_REQUIRE((6 & int2(11,12)) == int2(2,4)); STATIC_CHECK((6 & int2(11,12)) == int2(2,4));
STATIC_REQUIRE((6 | int2(11,12)) == int2(15,14)); STATIC_CHECK((6 | int2(11,12)) == int2(15,14));
STATIC_REQUIRE((6 ^ int2(11,12)) == int2(13,10)); STATIC_CHECK((6 ^ int2(11,12)) == int2(13,10));
STATIC_REQUIRE((1 && int2(1,0)) == bool2(1,0)); STATIC_CHECK((1 && int2(1,0)) == bool2(1,0));
STATIC_REQUIRE((1 || int2(1,0)) == bool2(1,1)); STATIC_CHECK((1 || int2(1,0)) == bool2(1,1));
STATIC_REQUIRE(int2(1,2) + int2(3,4) == int2(4,6)); STATIC_CHECK(int2(1,2) + int2(3,4) == int2(4,6));
STATIC_REQUIRE(int2(1,2) - int2(3,4) == int2(-2,-2)); STATIC_CHECK(int2(1,2) - int2(3,4) == int2(-2,-2));
STATIC_REQUIRE(int2(1,2) * int2(3,4) == int2(3,8)); STATIC_CHECK(int2(1,2) * int2(3,4) == int2(3,8));
STATIC_REQUIRE(int2(3,4) / int2(1,2) == int2(3,2)); STATIC_CHECK(int2(3,4) / int2(1,2) == int2(3,2));
STATIC_REQUIRE((int2(6,7) & int2(11,12)) == int2(2,4)); STATIC_CHECK((int2(6,7) & int2(11,12)) == int2(2,4));
STATIC_REQUIRE((int2(6,7) | int2(11,12)) == int2(15,15)); STATIC_CHECK((int2(6,7) | int2(11,12)) == int2(15,15));
STATIC_REQUIRE((int2(6,7) ^ int2(11,12)) == int2(13,11)); STATIC_CHECK((int2(6,7) ^ int2(11,12)) == int2(13,11));
STATIC_REQUIRE((int2(0,1) && int2(1,0)) == bool2(0,0)); STATIC_CHECK((int2(0,1) && int2(1,0)) == bool2(0,0));
STATIC_REQUIRE((int2(0,1) || int2(1,0)) == bool2(1,1)); STATIC_CHECK((int2(0,1) || int2(1,0)) == bool2(1,1));
{ {
int2 v{1,2}; int2 v{1,2};
REQUIRE(&v == &(v += 3)); CHECK(&v == &(v += 3));
REQUIRE(v == int2{4,5}); CHECK(v == int2{4,5});
REQUIRE(&v == &(v += int2{1,2})); CHECK(&v == &(v += int2{1,2}));
REQUIRE(v == int2{5,7}); CHECK(v == int2{5,7});
} }
{ {
int2 v{4,5}; int2 v{4,5};
REQUIRE(&v == &(v -= 3)); CHECK(&v == &(v -= 3));
REQUIRE(v == int2{1,2}); CHECK(v == int2{1,2});
REQUIRE(&v == &(v -= int2{2,4})); CHECK(&v == &(v -= int2{2,4}));
REQUIRE(v == int2{-1,-2}); CHECK(v == int2{-1,-2});
} }
{ {
int2 v{1,2}; int2 v{1,2};
REQUIRE(&v == &(v *= 3)); CHECK(&v == &(v *= 3));
REQUIRE(v == int2{3,6}); CHECK(v == int2{3,6});
REQUIRE(&v == &(v *= int2{2,3})); CHECK(&v == &(v *= int2{2,3}));
REQUIRE(v == int2{6,18}); CHECK(v == int2{6,18});
} }
{ {
int2 v{6,18}; int2 v{6,18};
REQUIRE(&v == &(v /= 2)); CHECK(&v == &(v /= 2));
REQUIRE(v == int2{3,9}); CHECK(v == int2{3,9});
REQUIRE(&v == &(v /= int2{3,4})); CHECK(&v == &(v /= int2{3,4}));
REQUIRE(v == int2{1,2}); CHECK(v == int2{1,2});
} }
{ {
int2 v1{11,12}; int2 v1{11,12};
REQUIRE(&v1 == &(v1 &= 6)); CHECK(&v1 == &(v1 &= 6));
REQUIRE(v1 == int2(2,4)); CHECK(v1 == int2(2,4));
int2 v2{6,7}; int2 v2{6,7};
REQUIRE(&v2 == &(v2 &= int2(11,12))); CHECK(&v2 == &(v2 &= int2(11,12)));
REQUIRE(v2 == int2(2,4)); CHECK(v2 == int2(2,4));
} }
{ {
int2 v1{11,12}; int2 v1{11,12};
REQUIRE(&v1 == &(v1 |= 6)); CHECK(&v1 == &(v1 |= 6));
REQUIRE(v1 == int2(15,14)); CHECK(v1 == int2(15,14));
int2 v2{6,7}; int2 v2{6,7};
REQUIRE(&v2 == &(v2 |= int2(11,12))); CHECK(&v2 == &(v2 |= int2(11,12)));
REQUIRE(v2 == int2(15,15)); CHECK(v2 == int2(15,15));
} }
{ {
int2 v1{11,12}; int2 v1{11,12};
REQUIRE(&v1 == &(v1 ^= 6)); CHECK(&v1 == &(v1 ^= 6));
REQUIRE(v1 == int2(13,10)); CHECK(v1 == int2(13,10));
int2 v2{6,7}; int2 v2{6,7};
REQUIRE(&v2 == &(v2 ^= int2(11,12))); CHECK(&v2 == &(v2 ^= int2(11,12)));
REQUIRE(v2 == int2(13,11)); CHECK(v2 == int2(13,11));
} }
} }
SUBCASE("Angle and Trigonometric Functions") { SUBCASE("Angle and Trigonometric Functions") {
STATIC_REQUIRE(radians(degrees(float2(12.13f))) == uapprox2(12.13f)); STATIC_CHECK(radians(degrees(float2(12.13f))) == uapprox2(12.13f));
STATIC_REQUIRE(degrees(radians(float2(12.13f))) == uapprox2(12.13f)); STATIC_CHECK(degrees(radians(float2(12.13f))) == uapprox2(12.13f));
(void)sin(float2(1.f)); (void)sin(float2(1.f));
(void)cos(float2(1.f)); (void)cos(float2(1.f));
@@ -153,11 +153,11 @@ TEST_CASE("vmath/vec_fun") {
{ {
float2 out_ss{}, out_cs{}; float2 out_ss{}, out_cs{};
sincos(float2(10.f,15.f), &out_ss, &out_cs); sincos(float2(10.f,15.f), &out_ss, &out_cs);
REQUIRE(out_ss == uapprox2(sin(10.f), sin(15.f))); CHECK(out_ss == uapprox2(sin(10.f), sin(15.f)));
REQUIRE(out_cs == uapprox2(cos(10.f), cos(15.f))); CHECK(out_cs == uapprox2(cos(10.f), cos(15.f)));
const auto [out_ss2, out_cs2] = sincos(float2(10.f,15.f)); const auto [out_ss2, out_cs2] = sincos(float2(10.f,15.f));
REQUIRE(out_ss2 == uapprox2(sin(10.f), sin(15.f))); CHECK(out_ss2 == uapprox2(sin(10.f), sin(15.f)));
REQUIRE(out_cs2 == uapprox2(cos(10.f), cos(15.f))); CHECK(out_cs2 == uapprox2(cos(10.f), cos(15.f)));
} }
} }
@@ -172,22 +172,22 @@ TEST_CASE("vmath/vec_fun") {
} }
SUBCASE("Common Functions") { SUBCASE("Common Functions") {
STATIC_REQUIRE(abs(float2(1.f, -1.f)) == uapprox2(1.f,1.f)); STATIC_CHECK(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_CHECK(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_CHECK(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(rcp(float2(2.f, 4.f)) == uapprox2(0.5f,0.25f));
REQUIRE(copysign( CHECK(copysign(
float4(2.f, -4.f, 2.f, -4.f), float4(2.f, -4.f, 2.f, -4.f),
5.f) 5.f)
== uapprox4(2.f, 4.f, 2.f, 4.f)); == uapprox4(2.f, 4.f, 2.f, 4.f));
REQUIRE(copysign( CHECK(copysign(
float4(2.f, -4.f, 2.f, -4.f), float4(2.f, -4.f, 2.f, -4.f),
-5.f) -5.f)
== uapprox4(-2.f, -4.f, -2.f, -4.f)); == uapprox4(-2.f, -4.f, -2.f, -4.f));
REQUIRE(copysign( CHECK(copysign(
float4(2.f, -4.f, 2.f, -4.f), float4(2.f, -4.f, 2.f, -4.f),
float4(10.f, 5.f, -4.f, -0.4)) float4(10.f, 5.f, -4.f, -0.4))
== uapprox4(2.f, 4.f, -2.f, -4.f)); == 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)ceil(float2(1.f, -1.f));
(void)fract(float2(1.f, -1.f)); (void)fract(float2(1.f, -1.f));
REQUIRE(fmod(float2(1.7f), 1.2f) == uapprox2(0.5f)); CHECK(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), float2(1.2f)) == uapprox2(0.5f));
{ {
float2 out_i{}; float2 out_i{};
REQUIRE(modf(float2(1.7f), &out_i) == uapprox2(0.7f)); CHECK(modf(float2(1.7f), &out_i) == uapprox2(0.7f));
REQUIRE(out_i.x == uapprox(1.f)); CHECK(out_i.x == uapprox(1.f));
} }
STATIC_REQUIRE(min(int2(1,2)) == 1); STATIC_CHECK(min(int2(1,2)) == 1);
STATIC_REQUIRE(min(int2(1,2), 1) == int2(1,1)); STATIC_CHECK(min(int2(1,2), 1) == int2(1,1));
STATIC_REQUIRE(min(1, int2(1,2)) == int2(1,1)); STATIC_CHECK(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,1), int2(0,2)) == int2(0,1));
STATIC_REQUIRE(max(int2(1,2)) == 2); STATIC_CHECK(max(int2(1,2)) == 2);
STATIC_REQUIRE(max(int2(1,2), 1) == int2(1,2)); STATIC_CHECK(max(int2(1,2), 1) == int2(1,2));
STATIC_REQUIRE(max(1, int2(1,2)) == int2(1,2)); STATIC_CHECK(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,1), int2(0,2)) == int2(1,2));
STATIC_REQUIRE(clamp(int2(1,2), 0, 1) == int2(1,1)); STATIC_CHECK(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), 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_CHECK(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_CHECK(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), 1.f) == uapprox2(10.f));
STATIC_REQUIRE(lerp(float2(2.f), float2(10.f), 0.f, 1.f) == uapprox2(10.f)); STATIC_CHECK(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_CHECK(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.5f, 0.2f) == uapprox2(3.f));
STATIC_REQUIRE(lerp(float2(2.f), float2(10.f), float2(0.f)) == uapprox2(2.f)); STATIC_CHECK(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_CHECK(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(1.f)) == uapprox2(10.f));
STATIC_REQUIRE(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(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_CHECK(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.5f), float2(0.2f)) == uapprox2(3.f));
STATIC_REQUIRE(step(0.5f, float2(0.4f)) == uapprox2(0.f)); STATIC_CHECK(step(0.5f, float2(0.4f)) == uapprox2(0.f));
STATIC_REQUIRE(step(0.5f, float2(0.6f)) == uapprox2(1.f)); STATIC_CHECK(step(0.5f, float2(0.6f)) == uapprox2(1.f));
STATIC_REQUIRE(step(float2(0.5f), float2(0.4f)) == uapprox2(0.f)); STATIC_CHECK(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(float2(0.5f), float2(0.6f)) == uapprox2(1.f));
STATIC_REQUIRE(smoothstep(0.f, 1.f, float2(0.1f)) == uapprox2(0.028f)); STATIC_CHECK(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(float2(0.f), float2(1.f), float2(0.1f)) == uapprox2(0.028f));
REQUIRE_FALSE(isnan(float2(1.f)).x); CHECK_FALSE(isnan(float2(1.f)).x);
REQUIRE_FALSE(isinf(float2(1.f)).x); CHECK_FALSE(isinf(float2(1.f)).x);
REQUIRE(isfinite(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{}; int2 out_exp{};
REQUIRE(frexp(float2(1.7f), &out_exp).x == uapprox(0.85f)); CHECK(frexp(float2(1.7f), &out_exp).x == uapprox(0.85f));
REQUIRE(out_exp == int2(1)); 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") { SUBCASE("Geometric Functions") {
REQUIRE(length(float2(10.f,0.f)) == uapprox(10.f)); CHECK(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));
STATIC_REQUIRE(length2(float2(10.f,0.f)) == uapprox(100.f)); STATIC_CHECK(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));
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));
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));
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_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_REQUIRE(dot(int2(1,2),int2(3,4)) == 11); STATIC_CHECK(dot(int2(1,2),int2(3,4)) == 11);
STATIC_REQUIRE(cross(int2(1,0),int2(0,1)) == 1); STATIC_CHECK(cross(int2(1,0),int2(0,1)) == 1);
STATIC_REQUIRE(cross(int3(1,0,0),int3(0,1,0)) == int3(0,0,1)); STATIC_CHECK(cross(int3(1,0,0),int3(0,1,0)) == int3(0,0,1));
REQUIRE(normalize(float2(0.5f,0.f)).x == uapprox(1.f)); 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_CHECK(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)); STATIC_CHECK(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)); CHECK(refract(float2(1.f), float2(2.f), 1.f).x == uapprox(-15.f));
} }
SUBCASE("Relational Functions") { SUBCASE("Relational Functions") {
STATIC_REQUIRE_FALSE(any(bool2(false, false))); STATIC_CHECK_FALSE(any(bool2(false, false)));
STATIC_REQUIRE(any(bool2(true, false))); STATIC_CHECK(any(bool2(true, false)));
STATIC_REQUIRE(any(bool2(false, true))); STATIC_CHECK(any(bool2(false, true)));
STATIC_REQUIRE(any(bool2(true, true))); STATIC_CHECK(any(bool2(true, true)));
STATIC_REQUIRE_FALSE(any(int2(0, 0))); STATIC_CHECK_FALSE(any(int2(0, 0)));
STATIC_REQUIRE(any(int2(1, 0))); STATIC_CHECK(any(int2(1, 0)));
STATIC_REQUIRE(any(int2(0, 1))); STATIC_CHECK(any(int2(0, 1)));
STATIC_REQUIRE(any(int2(1, 1))); STATIC_CHECK(any(int2(1, 1)));
STATIC_REQUIRE_FALSE(all(bool2(false, false))); STATIC_CHECK_FALSE(all(bool2(false, false)));
STATIC_REQUIRE_FALSE(all(bool2(true, false))); STATIC_CHECK_FALSE(all(bool2(true, false)));
STATIC_REQUIRE_FALSE(all(bool2(false, true))); STATIC_CHECK_FALSE(all(bool2(false, true)));
STATIC_REQUIRE(all(bool2(true, true))); STATIC_CHECK(all(bool2(true, true)));
STATIC_REQUIRE_FALSE(all(int2(0, 0))); STATIC_CHECK_FALSE(all(int2(0, 0)));
STATIC_REQUIRE_FALSE(all(int2(1, 0))); STATIC_CHECK_FALSE(all(int2(1, 0)));
STATIC_REQUIRE_FALSE(all(int2(0, 1))); STATIC_CHECK_FALSE(all(int2(0, 1)));
STATIC_REQUIRE(all(int2(1, 1))); STATIC_CHECK(all(int2(1, 1)));
STATIC_REQUIRE(approx(int3(1,1,1), int3(0,1,2)) == bool3(false, true, false)); STATIC_CHECK(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_CHECK(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_CHECK(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(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_CHECK(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_CHECK(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_CHECK(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(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_CHECK(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(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") { TEST_CASE("vmath/vec") {
SUBCASE("size/sizeof") { SUBCASE("size/sizeof") {
STATIC_REQUIRE(int2{}.size == 2); STATIC_CHECK(int2{}.size == 2);
STATIC_REQUIRE(int3{}.size == 3); STATIC_CHECK(int3{}.size == 3);
STATIC_REQUIRE(int4{}.size == 4); STATIC_CHECK(int4{}.size == 4);
STATIC_REQUIRE(sizeof(int2{}) == sizeof(int) * 2); STATIC_CHECK(sizeof(int2{}) == sizeof(int) * 2);
STATIC_REQUIRE(sizeof(int3{}) == sizeof(int) * 3); STATIC_CHECK(sizeof(int3{}) == sizeof(int) * 3);
STATIC_REQUIRE(sizeof(int4{}) == sizeof(int) * 4); STATIC_CHECK(sizeof(int4{}) == sizeof(int) * 4);
} }
SUBCASE("guides") { 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_CHECK(vec{1,2,3}.size == 3);
STATIC_REQUIRE(vec{{1,2},3}.size == 3); STATIC_CHECK(vec{{1,2},3}.size == 3);
STATIC_REQUIRE(vec{1,{2,3}}.size == 3); STATIC_CHECK(vec{1,{2,3}}.size == 3);
STATIC_REQUIRE(vec{1,2,3,4}.size == 4); STATIC_CHECK(vec{1,2,3,4}.size == 4);
STATIC_REQUIRE(vec{vec{1,2},3,4}.size == 4); STATIC_CHECK(vec{vec{1,2},3,4}.size == 4);
STATIC_REQUIRE(vec{1,vec{2,3},4}.size == 4); STATIC_CHECK(vec{1,vec{2,3},4}.size == 4);
STATIC_REQUIRE(vec{1,2,vec{3,4}}.size == 4); STATIC_CHECK(vec{1,2,vec{3,4}}.size == 4);
STATIC_REQUIRE(vec{vec{1,2},vec{3,4}}.size == 4); STATIC_CHECK(vec{vec{1,2},vec{3,4}}.size == 4);
STATIC_REQUIRE(vec{vec{1,2,3},4}.size == 4); STATIC_CHECK(vec{vec{1,2,3},4}.size == 4);
STATIC_REQUIRE(vec{1,vec{2,3,4}}.size == 4); STATIC_CHECK(vec{1,vec{2,3,4}}.size == 4);
} }
SUBCASE("ctors") { SUBCASE("ctors") {
{ {
STATIC_REQUIRE(int2().x == 0); STATIC_CHECK(int2().x == 0);
STATIC_REQUIRE(int2().y == 0); STATIC_CHECK(int2().y == 0);
STATIC_REQUIRE(int2(1).x == 1); STATIC_CHECK(int2(1).x == 1);
STATIC_REQUIRE(int2(1).y == 1); STATIC_CHECK(int2(1).y == 1);
STATIC_REQUIRE(int2(1,2).x == 1); STATIC_CHECK(int2(1,2).x == 1);
STATIC_REQUIRE(int2(1,2).y == 2); STATIC_CHECK(int2(1,2).y == 2);
} }
{ {
constexpr int2 v(1,2); constexpr int2 v(1,2);
constexpr int2 v2 = v; constexpr int2 v2 = v;
STATIC_REQUIRE(v2 == int2(1,2)); STATIC_CHECK(v2 == int2(1,2));
} }
{ {
constexpr int2 v(1,2); constexpr int2 v(1,2);
constexpr int2 v2 = std::move(v); 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_CHECK(int2(1) == int2(1,1));
STATIC_REQUIRE(int2(1,2) == int2(1,2)); STATIC_CHECK(int2(1,2) == int2(1,2));
STATIC_REQUIRE(int2(int2(1,2)) == int2(1,2)); STATIC_CHECK(int2(int2(1,2)) == int2(1,2));
STATIC_REQUIRE(int2(int3(1,2,3)) == int2(1,2)); STATIC_CHECK(int2(int3(1,2,3)) == int2(1,2));
STATIC_REQUIRE(int2(int4(1,2,3,4)) == int2(1,2)); STATIC_CHECK(int2(int4(1,2,3,4)) == int2(1,2));
STATIC_REQUIRE(int3(1) == int3(1,1,1)); STATIC_CHECK(int3(1) == int3(1,1,1));
STATIC_REQUIRE(int3(1,2,3) == int3(1,2,3)); STATIC_CHECK(int3(1,2,3) == int3(1,2,3));
STATIC_REQUIRE(int3(int2(1,2),3) == int3(1,2,3)); STATIC_CHECK(int3(int2(1,2),3) == int3(1,2,3));
STATIC_REQUIRE(int3(1,int2(2,3)) == int3(1,2,3)); STATIC_CHECK(int3(1,int2(2,3)) == int3(1,2,3));
STATIC_REQUIRE(int3(int3(1,2,3)) == int3(1,2,3)); STATIC_CHECK(int3(int3(1,2,3)) == int3(1,2,3));
STATIC_REQUIRE(int3(int4(1,2,3,4)) == 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_CHECK(int4(1) == int4(1,1,1,1));
STATIC_REQUIRE(int4(1,2,3,4) == int4(1,2,3,4)); STATIC_CHECK(int4(1,2,3,4) == int4(1,2,3,4));
STATIC_REQUIRE(int4(int2(1,2),3,4) == int4(1,2,3,4)); STATIC_CHECK(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_CHECK(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_CHECK(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_CHECK(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_CHECK(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,int3(2,3,4)) == int4(1,2,3,4));
} }
} }
@@ -90,13 +90,13 @@ TEST_CASE("vmath/vec") {
int2 v(1,2); int2 v(1,2);
int2 v2; int2 v2;
v2 = v; v2 = v;
REQUIRE(v2 == int2(1,2)); CHECK(v2 == int2(1,2));
} }
{ {
int2 v(1,2); int2 v(1,2);
int2 v2; int2 v2;
v2 = std::move(v); 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 v1(1,2);
int2 v2(4,5); int2 v2(4,5);
v1.swap(v2); v1.swap(v2);
REQUIRE(v1 == int2(4,5)); CHECK(v1 == int2(4,5));
REQUIRE(v2 == int2(1,2)); CHECK(v2 == int2(1,2));
} }
{ {
int2 v1(1,2); int2 v1(1,2);
int2 v2(4,5); int2 v2(4,5);
swap(v1, v2); swap(v1, v2);
REQUIRE(v1 == int2(4,5)); CHECK(v1 == int2(4,5));
REQUIRE(v2 == int2(1,2)); CHECK(v2 == int2(1,2));
} }
} }
@@ -121,125 +121,125 @@ TEST_CASE("vmath/vec") {
{ {
int2 v{1,2}; int2 v{1,2};
REQUIRE(*v.begin() == 1); CHECK(*v.begin() == 1);
REQUIRE(*(v.begin() + 1) == 2); CHECK(*(v.begin() + 1) == 2);
REQUIRE(*(v.end() - 1) == 2); CHECK(*(v.end() - 1) == 2);
REQUIRE(*(v.end() - 2) == 1); CHECK(*(v.end() - 2) == 1);
REQUIRE(v.begin() + 2 == v.end()); CHECK(v.begin() + 2 == v.end());
REQUIRE(v.end() - 2 == v.begin()); CHECK(v.end() - 2 == v.begin());
REQUIRE(*v.cbegin() == 1); CHECK(*v.cbegin() == 1);
REQUIRE(*(v.cbegin() + 1) == 2); CHECK(*(v.cbegin() + 1) == 2);
REQUIRE(*(v.cend() - 1) == 2); CHECK(*(v.cend() - 1) == 2);
REQUIRE(*(v.cend() - 2) == 1); CHECK(*(v.cend() - 2) == 1);
REQUIRE(v.cbegin() + 2 == v.cend()); CHECK(v.cbegin() + 2 == v.cend());
REQUIRE(v.cend() - 2 == v.cbegin()); CHECK(v.cend() - 2 == v.cbegin());
REQUIRE(*v.rbegin() == 2); CHECK(*v.rbegin() == 2);
REQUIRE(*(v.rbegin() + 1) == 1); CHECK(*(v.rbegin() + 1) == 1);
REQUIRE(*(v.rend() - 1) == 1); CHECK(*(v.rend() - 1) == 1);
REQUIRE(*(v.rend() - 2) == 2); CHECK(*(v.rend() - 2) == 2);
REQUIRE(v.rbegin() + 2 == v.rend()); CHECK(v.rbegin() + 2 == v.rend());
REQUIRE(v.rend() - 2 == v.rbegin()); CHECK(v.rend() - 2 == v.rbegin());
REQUIRE(*v.crbegin() == 2); CHECK(*v.crbegin() == 2);
REQUIRE(*(v.crbegin() + 1) == 1); CHECK(*(v.crbegin() + 1) == 1);
REQUIRE(*(v.crend() - 1) == 1); CHECK(*(v.crend() - 1) == 1);
REQUIRE(*(v.crend() - 2) == 2); CHECK(*(v.crend() - 2) == 2);
REQUIRE(v.crbegin() + 2 == v.crend()); CHECK(v.crbegin() + 2 == v.crend());
REQUIRE(v.crend() - 2 == v.crbegin()); CHECK(v.crend() - 2 == v.crbegin());
*v.begin() = 3; *v.begin() = 3;
REQUIRE(v == int2{3,2}); CHECK(v == int2{3,2});
*v.rbegin() = 4; *v.rbegin() = 4;
REQUIRE(v == int2{3,4}); CHECK(v == int2{3,4});
} }
{ {
const int2 v{1,2}; const int2 v{1,2};
REQUIRE(*v.begin() == 1); CHECK(*v.begin() == 1);
REQUIRE(*(v.begin() + 1) == 2); CHECK(*(v.begin() + 1) == 2);
REQUIRE(*(v.end() - 1) == 2); CHECK(*(v.end() - 1) == 2);
REQUIRE(*(v.end() - 2) == 1); CHECK(*(v.end() - 2) == 1);
REQUIRE(v.begin() + 2 == v.end()); CHECK(v.begin() + 2 == v.end());
REQUIRE(v.end() - 2 == v.begin()); CHECK(v.end() - 2 == v.begin());
REQUIRE(*v.cbegin() == 1); CHECK(*v.cbegin() == 1);
REQUIRE(*(v.cbegin() + 1) == 2); CHECK(*(v.cbegin() + 1) == 2);
REQUIRE(*(v.cend() - 1) == 2); CHECK(*(v.cend() - 1) == 2);
REQUIRE(*(v.cend() - 2) == 1); CHECK(*(v.cend() - 2) == 1);
REQUIRE(v.cbegin() + 2 == v.cend()); CHECK(v.cbegin() + 2 == v.cend());
REQUIRE(v.cend() - 2 == v.cbegin()); CHECK(v.cend() - 2 == v.cbegin());
REQUIRE(*v.rbegin() == 2); CHECK(*v.rbegin() == 2);
REQUIRE(*(v.rbegin() + 1) == 1); CHECK(*(v.rbegin() + 1) == 1);
REQUIRE(*(v.rend() - 1) == 1); CHECK(*(v.rend() - 1) == 1);
REQUIRE(*(v.rend() - 2) == 2); CHECK(*(v.rend() - 2) == 2);
REQUIRE(v.rbegin() + 2 == v.rend()); CHECK(v.rbegin() + 2 == v.rend());
REQUIRE(v.rend() - 2 == v.rbegin()); CHECK(v.rend() - 2 == v.rbegin());
REQUIRE(*v.crbegin() == 2); CHECK(*v.crbegin() == 2);
REQUIRE(*(v.crbegin() + 1) == 1); CHECK(*(v.crbegin() + 1) == 1);
REQUIRE(*(v.crend() - 1) == 1); CHECK(*(v.crend() - 1) == 1);
REQUIRE(*(v.crend() - 2) == 2); CHECK(*(v.crend() - 2) == 2);
REQUIRE(v.crbegin() + 2 == v.crend()); CHECK(v.crbegin() + 2 == v.crend());
REQUIRE(v.crend() - 2 == v.crbegin()); CHECK(v.crend() - 2 == v.crbegin());
} }
} }
SUBCASE("data") { SUBCASE("data") {
{ {
int2 i2; int2 i2;
REQUIRE(i2.data() == &i2[0]); CHECK(i2.data() == &i2[0]);
int3 i3; int3 i3;
REQUIRE(i3.data() == &i3[0]); CHECK(i3.data() == &i3[0]);
int4 i4; int4 i4;
REQUIRE(i4.data() == &i4[0]); CHECK(i4.data() == &i4[0]);
} }
{ {
const int2 i2; const int2 i2;
REQUIRE(i2.data() == &i2[0]); CHECK(i2.data() == &i2[0]);
const int3 i3; const int3 i3;
REQUIRE(i3.data() == &i3[0]); CHECK(i3.data() == &i3[0]);
const int4 i4; const int4 i4;
REQUIRE(i4.data() == &i4[0]); CHECK(i4.data() == &i4[0]);
} }
} }
SUBCASE("operator[]") { SUBCASE("operator[]") {
{ {
STATIC_REQUIRE(int2(1,2).x == 1); STATIC_CHECK(int2(1,2).x == 1);
STATIC_REQUIRE(int2(1,2).y == 2); STATIC_CHECK(int2(1,2).y == 2);
STATIC_REQUIRE(int3(1,2,3).x == 1); STATIC_CHECK(int3(1,2,3).x == 1);
STATIC_REQUIRE(int3(1,2,3).y == 2); STATIC_CHECK(int3(1,2,3).y == 2);
STATIC_REQUIRE(int3(1,2,3).z == 3); STATIC_CHECK(int3(1,2,3).z == 3);
STATIC_REQUIRE(int4(1,2,3,4).x == 1); STATIC_CHECK(int4(1,2,3,4).x == 1);
STATIC_REQUIRE(int4(1,2,3,4).y == 2); STATIC_CHECK(int4(1,2,3,4).y == 2);
STATIC_REQUIRE(int4(1,2,3,4).z == 3); STATIC_CHECK(int4(1,2,3,4).z == 3);
STATIC_REQUIRE(int4(1,2,3,4).w == 4); STATIC_CHECK(int4(1,2,3,4).w == 4);
} }
{ {
STATIC_REQUIRE(int2(1,2)[0] == 1); STATIC_CHECK(int2(1,2)[0] == 1);
STATIC_REQUIRE(int2(1,2)[1] == 2); STATIC_CHECK(int2(1,2)[1] == 2);
} }
{ {
int2 v; int2 v;
v.x = 1; v.x = 1;
v.y = 2; v.y = 2;
REQUIRE(v == int2(1,2)); CHECK(v == int2(1,2));
} }
{ {
int3 v; int3 v;
v.x = 1; v.x = 1;
v.y = 2; v.y = 2;
v.z = 3; v.z = 3;
REQUIRE(v == int3(1,2,3)); CHECK(v == int3(1,2,3));
} }
{ {
int4 v; int4 v;
@@ -247,33 +247,35 @@ TEST_CASE("vmath/vec") {
v.y = 2; v.y = 2;
v.z = 3; v.z = 3;
v.w = 4; v.w = 4;
REQUIRE(v == int4(1,2,3,4)); CHECK(v == int4(1,2,3,4));
} }
} }
SUBCASE("at") { SUBCASE("at") {
STATIC_REQUIRE(int2(1,2).at(0) == 1); STATIC_CHECK(int2(1,2).at(0) == 1);
STATIC_REQUIRE(int2(1,2).at(1) == 2); STATIC_CHECK(int2(1,2).at(1) == 2);
REQUIRE_THROWS_AS((void)int2(1,2).at(2), std::out_of_range); #ifndef VMATH_HPP_NO_EXCEPTIONS
CHECK_THROWS_AS((void)int2(1,2).at(2), std::out_of_range);
#endif
} }
SUBCASE("operator==/operator!=") { SUBCASE("operator==/operator!=") {
STATIC_REQUIRE(int2(1,2) == int2(1,2)); STATIC_CHECK(int2(1,2) == int2(1,2));
STATIC_REQUIRE_FALSE(int2(1,2) == int2(2,2)); STATIC_CHECK_FALSE(int2(1,2) == int2(2,2));
STATIC_REQUIRE_FALSE(int2(1,2) == int2(1,3)); STATIC_CHECK_FALSE(int2(1,2) == int2(1,3));
STATIC_REQUIRE_FALSE(int2(1,2) != int2(1,2)); STATIC_CHECK_FALSE(int2(1,2) != int2(1,2));
STATIC_REQUIRE(int2(1,2) != int2(2,2)); STATIC_CHECK(int2(1,2) != int2(2,2));
STATIC_REQUIRE(int2(1,2) != int2(1,3)); STATIC_CHECK(int2(1,2) != int2(1,3));
} }
SUBCASE("operator<") { 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_CHECK(int2(1,1) < int2(1,2));
STATIC_REQUIRE_FALSE(int2(1,2) < int2(1,1)); STATIC_CHECK_FALSE(int2(1,2) < int2(1,1));
STATIC_REQUIRE(int2(0,3) < int2(1,2)); STATIC_CHECK(int2(0,3) < int2(1,2));
STATIC_REQUIRE_FALSE(int2(1,2) < int2(0,3)); STATIC_CHECK_FALSE(int2(1,2) < int2(0,3));
} }
} }