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
)
# 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
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
FetchContent_MakeAvailable(googletest)

6
Spherical.h
View File

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

6
SwingTwist.h
View File

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

8
Vector3.h
View File

@ -354,10 +354,10 @@ class Vector3Of {
/// @return The scaled vector
/// @remark Each component of the vector will be multipled with the same
/// 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);
}
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>(v.horizontal * f, v.vertical * f, v.depth * f);
}
@ -367,10 +367,10 @@ class Vector3Of {
/// @param f The scaling factor
/// @return The scaled vector
/// @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);
}
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>(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 Vector2 = Vector2Of<T>;
bool r = false;
Vector2 v1 = Vector2(0, 2);
Vector2 v = Vector2::zero;
@ -401,11 +400,11 @@ TYPED_TEST(Vector2Tests, Divide) {
Vector2 v = Vector2::zero;
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;
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) {
@ -437,18 +436,18 @@ TYPED_TEST(Vector2Tests, Dot) {
Vector2 v1 = Vector2(4, 5);
Vector2 v2 = Vector2(1, 2);
float f = 0;
T f = 0;
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);
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);
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) {
@ -457,7 +456,7 @@ TYPED_TEST(Vector2FpTests, Dot) {
Vector2 v2;
Vector2 v1 = Vector2(4, 5);
float f;
T f;
if (std::numeric_limits<float>::is_iec559) {
v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
@ -552,7 +551,6 @@ TYPED_TEST(Vector2Tests, Angle) {
Vector2 v1 = Vector2(4, 5);
Vector2 v2 = Vector2(1, 2);
Angle f = Angle::zero;
bool r = false;
f = Vector2::UnsignedAngle(v1, v2);
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 v2 = Vector2(1, 2);
Angle f = Angle::zero;
bool r = false;
f = Vector2::SignedAngle(v1, v2);
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);
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);
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);
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

32
test/Vector3_test.cc
View File

@ -135,8 +135,6 @@ TYPED_TEST(Vector3Tests, Normalize) {
using T = TypeParam;
using Vector3 = Vector3Of<T>;
bool r = false;
Vector3 v1 = Vector3(0, 2, 0);
Vector3 v = Vector3::zero;
@ -350,7 +348,7 @@ TYPED_TEST(Vector3Tests, Multiply) {
using Vector3 = Vector3Of<T>;
Vector3 v1 = Vector3(4, 5, 6);
float f = 3;
T f = 3;
Vector3 v = Vector3::zero;
v = v1 * f;
@ -391,15 +389,15 @@ TYPED_TEST(Vector3Tests, Divide) {
using Vector3 = Vector3Of<T>;
Vector3 v1 = Vector3(4, 5, 6);
float f = 2;
T f = 2;
Vector3 v = Vector3::zero;
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;
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) {
@ -433,18 +431,18 @@ TYPED_TEST(Vector3Tests, Dot) {
Vector3 v1 = Vector3(4, 5, 6);
Vector3 v2 = Vector3(1, 2, 3);
float f = 0;
T f = 0;
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);
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);
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) {
@ -453,7 +451,7 @@ TYPED_TEST(Vector3FpTests, Dot) {
Vector3 v1 = Vector3(4, 5, 6);
Vector3 v2 = Vector3(1, 2, 3);
float f = 0;
T f = 0;
if (std::numeric_limits<float>::is_iec559) {
v2 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
@ -601,12 +599,12 @@ TYPED_TEST(Vector3Tests, Project) {
bool r = false;
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)";
v2 = Vector3(-1, -2, -3);
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)";
v2 = Vector3(0, 0, 0);
@ -691,7 +689,6 @@ TYPED_TEST(Vector3Tests, Angle) {
Vector3 v1 = Vector3(4, 5, 6);
Vector3 v2 = Vector3(1, 2, 3);
AngleOf<float> f = AngleOf<float>::Degrees(0);
bool r = false;
f = Vector3::UnsignedAngle(v1, v2);
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 v3 = Vector3(7, 8, -9);
AngleOf<float> f = AngleOf<float>::Degrees(0);
bool r = false;
f = Vector3::SignedAngle(v1, v2, v3);
EXPECT_FLOAT_EQ(f.InDegrees(), -12.9331388F)
@ -801,13 +797,13 @@ TYPED_TEST(Vector3Tests, Lerp) {
EXPECT_FLOAT_EQ(Vector3::Distance(r, v2), 0);
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);
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);
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