LinearAlgebra/LinearAlgebra-cpp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases Activity

Fix tests for windows execution
Some checks failed
Build and Run C++ Unit Tests / build-and-test (push) Failing after 29s
Details

Browse Source
This commit is contained in:
Pascal Serrarens 2025-12-23 15:02:48 +01:00
parent b555fb5d6a
commit 9b76dfd094
6 changed files with 37 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
CMakeLists.txt
View File

@ -18,6 +18,15 @@ else()
URL https://github.com/google/googletest/archive/refs/heads/main.zip URL https://github.com/google/googletest/archive/refs/heads/main.zip
) )
# Enable coverage
option(CODE_COVERAGE "Enable coverage reporting" ON)
if(CODE_COVERAGE)
message(STATUS "Code coverage enabled")
add_compile_options(/PROFILE) # MSVC flag for coverage
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zi /Od") # Debug info
endif()
# For Windows: Prevent overriding the parent project's compiler/linker settings # For Windows: Prevent overriding the parent project's compiler/linker settings
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE) set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
FetchContent_MakeAvailable(googletest) FetchContent_MakeAvailable(googletest)

6
Spherical.h
View File

@ -179,12 +179,6 @@ using SphericalSingle = SphericalOf<float>;
/// hardware /// hardware
using Spherical16 = SphericalOf<signed short>; using Spherical16 = SphericalOf<signed short>;
#if defined(ARDUINO)
using Spherical = Spherical16;
#else
using Spherical = SphericalSingle;
#endif
} // namespace LinearAlgebra } // namespace LinearAlgebra
#include "Polar.h" #include "Polar.h"

6
SwingTwist.h
View File

@ -73,12 +73,6 @@ class SwingTwistOf {
using SwingTwistSingle = SwingTwistOf<float>; using SwingTwistSingle = SwingTwistOf<float>;
using SwingTwist16 = SwingTwistOf<signed short>; using SwingTwist16 = SwingTwistOf<signed short>;
#if defined(ARDUINO)
using SwingTwist = SwingTwist16;
#else
using SwingTwist = SwingTwistSingle;
#endif
} // namespace LinearAlgebra } // namespace LinearAlgebra
using namespace LinearAlgebra; using namespace LinearAlgebra;

8
Vector3.h
View File

@ -354,10 +354,10 @@ class Vector3Of {
/// @return The scaled vector /// @return The scaled vector
/// @remark Each component of the vector will be multipled with the same /// @remark Each component of the vector will be multipled with the same
/// factor f. /// factor f.
friend Vector3Of<T> operator*(const Vector3Of& v, float f) { friend Vector3Of<T> operator*(const Vector3Of& v, T f) {
return Vector3Of<T>(v.horizontal * f, v.vertical * f, v.depth * f); return Vector3Of<T>(v.horizontal * f, v.vertical * f, v.depth * f);
} }
friend Vector3Of<T> operator*(float f, const Vector3Of& v) { friend Vector3Of<T> operator*(T f, const Vector3Of& v) {
return Vector3Of<T>(f * v.horizontal, f * v.vertical, f * v.depth); return Vector3Of<T>(f * v.horizontal, f * v.vertical, f * v.depth);
// return Vector3Of<T>(v.horizontal * f, v.vertical * f, v.depth * f); // return Vector3Of<T>(v.horizontal * f, v.vertical * f, v.depth * f);
} }
@ -367,10 +367,10 @@ class Vector3Of {
/// @param f The scaling factor /// @param f The scaling factor
/// @return The scaled vector /// @return The scaled vector
/// @remark Each componet of the vector will be divided by the same factor. /// @remark Each componet of the vector will be divided by the same factor.
friend Vector3Of<T> operator/(const Vector3Of& v, float f) { friend Vector3Of<T> operator/(const Vector3Of& v, T f) {
return Vector3Of<T>(v.horizontal / f, v.vertical / f, v.depth / f); return Vector3Of<T>(v.horizontal / f, v.vertical / f, v.depth / f);
} }
friend Vector3Of<T> operator/(float f, const Vector3Of& v) { friend Vector3Of<T> operator/(T f, const Vector3Of& v) {
return Vector3Of<T>(f / v.horizontal, f / v.vertical, f / v.depth); return Vector3Of<T>(f / v.horizontal, f / v.vertical, f / v.depth);
// return Vector3Of<T>(v.horizontal / f, v.vertical / f, v.depth / f); // return Vector3Of<T>(v.horizontal / f, v.vertical / f, v.depth / f);
} }

23
test/Vector2_test.cc
View File

@ -133,7 +133,6 @@ TYPED_TEST(Vector2Tests, Normalize) {
using T = TypeParam; using T = TypeParam;
using Vector2 = Vector2Of<T>; using Vector2 = Vector2Of<T>;
bool r = false;
Vector2 v1 = Vector2(0, 2); Vector2 v1 = Vector2(0, 2);
Vector2 v = Vector2::zero; Vector2 v = Vector2::zero;
@ -401,11 +400,11 @@ TYPED_TEST(Vector2Tests, Divide) {
Vector2 v = Vector2::zero; Vector2 v = Vector2::zero;
v = v1 / f; v = v1 / f;
EXPECT_TRUE(v == Vector2(2, 2.5F)) << "4 5 / 3"; EXPECT_TRUE(v == Vector2((T)2, (T)2.5)) << "4 5 / 3";
f = -2; f = -2;
v = v1 / f; v = v1 / f;
EXPECT_TRUE(v == Vector2(-2, -2.5F)) << "4 5 / -3"; EXPECT_TRUE(v == Vector2((T)-2, (T)-2.5)) << "4 5 / -3";
} }
TYPED_TEST(Vector2FpTests, Divide) { TYPED_TEST(Vector2FpTests, Divide) {
@ -437,18 +436,18 @@ TYPED_TEST(Vector2Tests, Dot) {
Vector2 v1 = Vector2(4, 5); Vector2 v1 = Vector2(4, 5);
Vector2 v2 = Vector2(1, 2); Vector2 v2 = Vector2(1, 2);
float f = 0; T f = 0;
f = Vector2::Dot(v1, v2); f = Vector2::Dot(v1, v2);
EXPECT_FLOAT_EQ(f, 14) << "Dot(4 5, 1 2)"; EXPECT_FLOAT_EQ((float)f, 14) << "Dot(4 5, 1 2)";
v2 = Vector2(-1, -2); v2 = Vector2(-1, -2);
f = Vector2::Dot(v1, v2); f = Vector2::Dot(v1, v2);
EXPECT_FLOAT_EQ(f, -14) << "Dot(4 5, -1 -2)"; EXPECT_FLOAT_EQ((float)f, -14) << "Dot(4 5, -1 -2)";
v2 = Vector2(0, 0); v2 = Vector2(0, 0);
f = Vector2::Dot(v1, v2); f = Vector2::Dot(v1, v2);
EXPECT_FLOAT_EQ(f, 0) << "Dot(4 5, 0 0)"; EXPECT_FLOAT_EQ((float)f, 0) << "Dot(4 5, 0 0)";
} }
TYPED_TEST(Vector2FpTests, Dot) { TYPED_TEST(Vector2FpTests, Dot) {
@ -457,7 +456,7 @@ TYPED_TEST(Vector2FpTests, Dot) {
Vector2 v2; Vector2 v2;
Vector2 v1 = Vector2(4, 5); Vector2 v1 = Vector2(4, 5);
float f; T f;
if (std::numeric_limits<float>::is_iec559) { if (std::numeric_limits<float>::is_iec559) {
v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY); v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
@ -552,7 +551,6 @@ TYPED_TEST(Vector2Tests, Angle) {
Vector2 v1 = Vector2(4, 5); Vector2 v1 = Vector2(4, 5);
Vector2 v2 = Vector2(1, 2); Vector2 v2 = Vector2(1, 2);
Angle f = Angle::zero; Angle f = Angle::zero;
bool r = false;
f = Vector2::UnsignedAngle(v1, v2); f = Vector2::UnsignedAngle(v1, v2);
EXPECT_FLOAT_EQ(f.InDegrees(), 12.09476F) << "Angle(4 5, 1 2)"; EXPECT_FLOAT_EQ(f.InDegrees(), 12.09476F) << "Angle(4 5, 1 2)";
@ -598,7 +596,6 @@ TYPED_TEST(Vector2Tests, SignedAngle) {
Vector2 v1 = Vector2(4, 5); Vector2 v1 = Vector2(4, 5);
Vector2 v2 = Vector2(1, 2); Vector2 v2 = Vector2(1, 2);
Angle f = Angle::zero; Angle f = Angle::zero;
bool r = false;
f = Vector2::SignedAngle(v1, v2); f = Vector2::SignedAngle(v1, v2);
EXPECT_FLOAT_EQ(f.InDegrees(), -12.09476F) << "SignedAngle(4 5, 1 2)"; EXPECT_FLOAT_EQ(f.InDegrees(), -12.09476F) << "SignedAngle(4 5, 1 2)";
@ -682,13 +679,13 @@ TYPED_TEST(Vector2Tests, Lerp) {
EXPECT_FLOAT_EQ(Vector2::Distance(r, v2), 0); EXPECT_FLOAT_EQ(Vector2::Distance(r, v2), 0);
r = Vector2::Lerp(v1, v2, 0.5f); r = Vector2::Lerp(v1, v2, 0.5f);
EXPECT_FLOAT_EQ(Vector2::Distance(r, Vector2(2.5f, 3.5f)), 0); EXPECT_FLOAT_EQ(Vector2::Distance(r, Vector2((T)2.5, (T)3.5)), 0);
r = Vector2::Lerp(v1, v2, -1); r = Vector2::Lerp(v1, v2, -1);
EXPECT_FLOAT_EQ(Vector2::Distance(r, Vector2(7.0f, 8.0f)), 0); EXPECT_FLOAT_EQ(Vector2::Distance(r, Vector2((T)7.0, (T)8.0f)), 0);
r = Vector2::Lerp(v1, v2, 2); r = Vector2::Lerp(v1, v2, 2);
EXPECT_FLOAT_EQ(Vector2::Distance(r, Vector2(-2.0, -1.0f)), 0); EXPECT_FLOAT_EQ(Vector2::Distance(r, Vector2((T)-2.0, (T)-1.0)), 0);
} }
#endif #endif

32
test/Vector3_test.cc
View File

@ -135,8 +135,6 @@ TYPED_TEST(Vector3Tests, Normalize) {
using T = TypeParam; using T = TypeParam;
using Vector3 = Vector3Of<T>; using Vector3 = Vector3Of<T>;
bool r = false;
Vector3 v1 = Vector3(0, 2, 0); Vector3 v1 = Vector3(0, 2, 0);
Vector3 v = Vector3::zero; Vector3 v = Vector3::zero;
@ -350,7 +348,7 @@ TYPED_TEST(Vector3Tests, Multiply) {
using Vector3 = Vector3Of<T>; using Vector3 = Vector3Of<T>;
Vector3 v1 = Vector3(4, 5, 6); Vector3 v1 = Vector3(4, 5, 6);
float f = 3; T f = 3;
Vector3 v = Vector3::zero; Vector3 v = Vector3::zero;
v = v1 * f; v = v1 * f;
@ -391,15 +389,15 @@ TYPED_TEST(Vector3Tests, Divide) {
using Vector3 = Vector3Of<T>; using Vector3 = Vector3Of<T>;
Vector3 v1 = Vector3(4, 5, 6); Vector3 v1 = Vector3(4, 5, 6);
float f = 2; T f = 2;
Vector3 v = Vector3::zero; Vector3 v = Vector3::zero;
v = v1 / f; v = v1 / f;
EXPECT_TRUE(v == Vector3(2, 2.5F, 3)) << "4 5 6 / 3"; EXPECT_TRUE(v == Vector3((T)2, (T)2.5, (T)3)) << "4 5 6 / 3";
f = -2; f = -2;
v = v1 / f; v = v1 / f;
EXPECT_TRUE(v == Vector3(-2, -2.5F, -3)) << "4 5 6 / -3"; EXPECT_TRUE(v == Vector3((T)-2, (T)-2.5, (T)-3)) << "4 5 6 / -3";
} }
TYPED_TEST(Vector3FpTests, Divide) { TYPED_TEST(Vector3FpTests, Divide) {
@ -433,18 +431,18 @@ TYPED_TEST(Vector3Tests, Dot) {
Vector3 v1 = Vector3(4, 5, 6); Vector3 v1 = Vector3(4, 5, 6);
Vector3 v2 = Vector3(1, 2, 3); Vector3 v2 = Vector3(1, 2, 3);
float f = 0; T f = 0;
f = Vector3::Dot(v1, v2); f = Vector3::Dot(v1, v2);
EXPECT_FLOAT_EQ(f, 32) << "Dot(4 5 6, 1 2 3)"; EXPECT_FLOAT_EQ((float)f, 32) << "Dot(4 5 6, 1 2 3)";
v2 = Vector3(-1, -2, -3); v2 = Vector3(-1, -2, -3);
f = Vector3::Dot(v1, v2); f = Vector3::Dot(v1, v2);
EXPECT_FLOAT_EQ(f, -32) << "Dot(4 5 6, -1 -2 -3)"; EXPECT_FLOAT_EQ((float)f, -32) << "Dot(4 5 6, -1 -2 -3)";
v2 = Vector3(0, 0, 0); v2 = Vector3(0, 0, 0);
f = Vector3::Dot(v1, v2); f = Vector3::Dot(v1, v2);
EXPECT_FLOAT_EQ(f, 0) << "Dot(4 5 6, 0 0 0)"; EXPECT_FLOAT_EQ((float)f, 0) << "Dot(4 5 6, 0 0 0)";
} }
TYPED_TEST(Vector3FpTests, Dot) { TYPED_TEST(Vector3FpTests, Dot) {
@ -453,7 +451,7 @@ TYPED_TEST(Vector3FpTests, Dot) {
Vector3 v1 = Vector3(4, 5, 6); Vector3 v1 = Vector3(4, 5, 6);
Vector3 v2 = Vector3(1, 2, 3); Vector3 v2 = Vector3(1, 2, 3);
float f = 0; T f = 0;
if (std::numeric_limits<float>::is_iec559) { if (std::numeric_limits<float>::is_iec559) {
v2 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY); v2 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
@ -601,12 +599,12 @@ TYPED_TEST(Vector3Tests, Project) {
bool r = false; bool r = false;
v = Vector3::Project(v1, v2); v = Vector3::Project(v1, v2);
r = v == Vector3(2.28571439F, 4.57142878F, 6.85714293F); r = v == Vector3((T)2.28571439F, (T)4.57142878F, (T)6.85714293F);
EXPECT_TRUE(r) << "Project(4 5 6, 1 2 3)"; EXPECT_TRUE(r) << "Project(4 5 6, 1 2 3)";
v2 = Vector3(-1, -2, -3); v2 = Vector3(-1, -2, -3);
v = Vector3::Project(v1, v2); v = Vector3::Project(v1, v2);
r = v == Vector3(2.28571439F, 4.57142878F, 6.85714293F); r = v == Vector3((T)2.28571439F, (T)4.57142878F, (T)6.85714293F);
EXPECT_TRUE(r) << "Project(4 5 6, -1 -2 -3)"; EXPECT_TRUE(r) << "Project(4 5 6, -1 -2 -3)";
v2 = Vector3(0, 0, 0); v2 = Vector3(0, 0, 0);
@ -691,7 +689,6 @@ TYPED_TEST(Vector3Tests, Angle) {
Vector3 v1 = Vector3(4, 5, 6); Vector3 v1 = Vector3(4, 5, 6);
Vector3 v2 = Vector3(1, 2, 3); Vector3 v2 = Vector3(1, 2, 3);
AngleOf<float> f = AngleOf<float>::Degrees(0); AngleOf<float> f = AngleOf<float>::Degrees(0);
bool r = false;
f = Vector3::UnsignedAngle(v1, v2); f = Vector3::UnsignedAngle(v1, v2);
EXPECT_FLOAT_EQ(f.InDegrees(), 12.9331388F) << "Angle(4 5 6, 1 2 3)"; EXPECT_FLOAT_EQ(f.InDegrees(), 12.9331388F) << "Angle(4 5 6, 1 2 3)";
@ -735,7 +732,6 @@ TYPED_TEST(Vector3Tests, SignedAngle) {
Vector3 v2 = Vector3(1, 2, 3); Vector3 v2 = Vector3(1, 2, 3);
Vector3 v3 = Vector3(7, 8, -9); Vector3 v3 = Vector3(7, 8, -9);
AngleOf<float> f = AngleOf<float>::Degrees(0); AngleOf<float> f = AngleOf<float>::Degrees(0);
bool r = false;
f = Vector3::SignedAngle(v1, v2, v3); f = Vector3::SignedAngle(v1, v2, v3);
EXPECT_FLOAT_EQ(f.InDegrees(), -12.9331388F) EXPECT_FLOAT_EQ(f.InDegrees(), -12.9331388F)
@ -801,13 +797,13 @@ TYPED_TEST(Vector3Tests, Lerp) {
EXPECT_FLOAT_EQ(Vector3::Distance(r, v2), 0); EXPECT_FLOAT_EQ(Vector3::Distance(r, v2), 0);
r = Vector3::Lerp(v1, v2, 0.5f); r = Vector3::Lerp(v1, v2, 0.5f);
EXPECT_FLOAT_EQ(Vector3::Distance(r, Vector3(2.5f, 3.5f, 4.5f)), 0); EXPECT_FLOAT_EQ(Vector3::Distance(r, Vector3((T)2.5, (T)3.5, (T)4.5)), 0);
r = Vector3::Lerp(v1, v2, -1); r = Vector3::Lerp(v1, v2, -1);
EXPECT_FLOAT_EQ(Vector3::Distance(r, Vector3(7.0f, 8.0f, 9.0f)), 0); EXPECT_FLOAT_EQ(Vector3::Distance(r, Vector3((T)7.0, (T)8.0, (T)9.0)), 0);
r = Vector3::Lerp(v1, v2, 2); r = Vector3::Lerp(v1, v2, 2);
EXPECT_FLOAT_EQ(Vector3::Distance(r, Vector3(-2.0, -1.0f, 0.0f)), 0); EXPECT_FLOAT_EQ(Vector3::Distance(r, Vector3((T)-2.0, (T)-1.0, (T)0.0)), 0);
} }
#endif #endif