Merge pull request #75 from bevanwsjones/70-template-data-types

70 template data types

CMakePresets.json

@@ -0,0 +1,34 @@
+{
+  "version": 3,
+  "cmakeMinimumRequired": {
+    "major": 3,
+    "minor": 15,
+    "patch": 1
+  },
+  "configurePresets": [
+    {
+      "name": "debug",
+      "description": "Debug preset, including testing",
+      "hidden": false,
+      "generator": "Unix Makefiles",
+      "binaryDir": "${sourceDir}/build",
+      "cacheVariables": {
+        "CMAKE_EXPORT_COMPILE_COMMANDS": "YES",
+        "CMAKE_BUILD_TYPE": "Debug",
+        "CMAKE_CXX_STANDARD": "20"
+      }
+    },
+    {
+      "name": "release",
+      "description": "Release preset",
+      "hidden": false,
+      "generator": "Unix Makefiles",
+      "binaryDir": "${sourceDir}/build",
+      "cacheVariables": {
+        "CMAKE_EXPORT_COMPILE_COMMANDS": "YES",
+        "CMAKE_BUILD_TYPE": "Release",
+        "CMAKE_CXX_STANDARD": "20"
+      }
+    }
+  ]
+}

libs/core/macros.h

@@ -120,7 +120,7 @@ inline std::basic_string<char> console_format(const Log_Level level, const std::
 // Types
 // ---------------------------------------------------------------------------------------------------------------------
 
-typedef std::make_signed<std::size_t>::type s_size_t;    //!< Signed type for size type, used for conversion.
+using s_size_t = std::make_signed<std::size_t>::type;    //!< Used for static casting where needed, and to prevent compile warnings (if you are using a signed type for size_t, you are doing something wrong).
 
 // ---------------------------------------------------------------------------------------------------------------------
 // Looping Macros

libs/core/matrix_sparse.h

@@ -1101,12 +1101,12 @@ inline Matrix_Sparse operator/(Matrix_Sparse matrix, const Scalar& scalar) {
  * @note at present for static vectors the matrix must be square.
  */
 template<std::size_t _size>
-Vector_Dense<_size> operator*(const Matrix_Sparse& matrix, const Vector_Dense<_size>& vector) {
+Vector_Dense<Scalar, _size> operator*(const Matrix_Sparse& matrix, const Vector_Dense<Scalar, _size>& vector) {
   ASSERT_DEBUG(matrix.size_column() == vector.size(),
                "Incompatible vector-matrix dimensions, " + std::to_string(matrix.size_row()) + "," +
                std::to_string(matrix.size_column()) + " vs. " + std::to_string(vector.size()) + ".");
   ASSERT_DEBUG(!_size || matrix.size_row() == vector.size(), "For static vectors the matrix must be square.");
-  return Vector_Dense<_size>([&](const std::size_t i_row, Scalar value = 0) {
+  return Vector_Dense<Scalar, _size>([&](const std::size_t i_row, Scalar value = 0) {
     FOR_ITER(iter, *(matrix.begin() + i_row)) value += *iter*vector[iter.i_column()];
     return value; }, matrix.size_row());
 }

libs/core/tests/test_matrix_sparse.cpp

@@ -664,23 +664,23 @@ TEST(test_matrix_sparse, scalar_matrix_division) {
 
 TEST(test_matrix_sparse, matrix_vector_multiplication) {
   Matrix_Sparse matrix({0, 1, 4}, {1, 0, 1, 2}, {3.0, -4.0, 5.0, -2.0}, 3);
-  Vector_Dense<0> dynamic_vector = {-1.0, 2.0, 3.0};
-  Vector_Dense<3> static_vector = {-10.0, 20.0, -30};
+  Vector_Dense<Scalar, 0> dynamic_vector = {-1.0, 2.0, 3.0};
+  Vector_Dense<Scalar, 3> static_vector = {-10.0, 20.0, -30};
 
-  Vector_Dense<0> result_dynamic = matrix*dynamic_vector;
+  Vector_Dense<Scalar, 0> result_dynamic = matrix*dynamic_vector;
   EXPECT_EQ(result_dynamic.size(), 2);
   EXPECT_DOUBLE_EQ(result_dynamic[0], 6.0);
   EXPECT_DOUBLE_EQ(result_dynamic[1], 8.0);
 
   matrix.resize(3, 3);
-  Vector_Dense<3> result_static = matrix*static_vector;
+  Vector_Dense<Scalar, 3> result_static = matrix*static_vector;
   EXPECT_DOUBLE_EQ(result_static[0], 60.0);
   EXPECT_DOUBLE_EQ(result_static[1], 200.0);
   EXPECT_DOUBLE_EQ(result_static[2], 0.0);
 
   Matrix_Sparse dynamic_matrix_incorrect;
-  Vector_Dense<0> dynamic_vector_incorrect;
-  Vector_Dense<2> static_vector_incorrect;
+  Vector_Dense<Scalar, 0> dynamic_vector_incorrect;
+  Vector_Dense<Scalar, 2> static_vector_incorrect;
   EXPECT_DEATH(dynamic_matrix_incorrect*dynamic_vector, "./*");
   EXPECT_DEATH(dynamic_matrix_incorrect*static_vector_incorrect, "./*");
   dynamic_matrix_incorrect.resize(4, 2);

libs/core/tests/test_vector_dense.cpp

@@ -31,33 +31,33 @@ using namespace Disa;
 // -------------------------------------------------------------------------------------------------------------------
 
 TEST(test_vector_dense, constructors_initialiser_lists) {
-  Vector_Dense<0> dynamic_vector = {1.0, 3.0, 4.0, -8.0};
+  Vector_Dense<Scalar, 0> dynamic_vector = {1.0, 3.0, 4.0, -8.0};
   EXPECT_EQ(dynamic_vector.size(), 4);
   EXPECT_DOUBLE_EQ(dynamic_vector[0], 1.0);
   EXPECT_DOUBLE_EQ(dynamic_vector[1], 3.0);
   EXPECT_DOUBLE_EQ(dynamic_vector[2], 4.0);
   EXPECT_DOUBLE_EQ(dynamic_vector[3], -8.0);
 
-  Vector_Dense<3> static_vector = {-34.0, 56.0, 23.0};
+  Vector_Dense<Scalar, 3> static_vector = {-34.0, 56.0, 23.0};
   EXPECT_DOUBLE_EQ(static_vector[0], -34.0);
   EXPECT_DOUBLE_EQ(static_vector[1], 56.0);
   EXPECT_DOUBLE_EQ(static_vector[2], 23.0);
 
-  EXPECT_DEATH(Vector_Dense<4>({-34.0, 56.0, 23.0}), "./*");
+  EXPECT_DEATH((Vector_Dense<Scalar, 4>({-34.0, 56.0, 23.0})), "./*");
 }
 
 TEST(test_vector_dense, constructors_lambda) {
-  Vector_Dense<0> dynamic_vector([](const std::size_t index) { return 2.0*static_cast<double>(index); }, 3);
+  Vector_Dense<Scalar, 0> dynamic_vector([](const std::size_t index) { return 2.0*static_cast<Scalar>(index); }, 3);
   EXPECT_EQ(dynamic_vector.size(), 3);
   EXPECT_DOUBLE_EQ(dynamic_vector[0], 0.0);
   EXPECT_DOUBLE_EQ(dynamic_vector[1], 2.0);
   EXPECT_DOUBLE_EQ(dynamic_vector[2], 4.0);
 
-  Vector_Dense<3> static_vector([](const std::size_t index) { return -3.0*static_cast<double>(index); });
+  Vector_Dense<Scalar, 3> static_vector([](const std::size_t index) { return -3.0*static_cast<Scalar>(index); });
   EXPECT_DOUBLE_EQ(static_vector[0], -0);
   EXPECT_DOUBLE_EQ(static_vector[1], -3);
   EXPECT_DOUBLE_EQ(static_vector[2], -6);
-  EXPECT_DEATH(Vector_Dense<3>([](const std::size_t index) { return -3.0*static_cast<double>(index); }, 2),
+  EXPECT_DEATH((Vector_Dense<Scalar, 3>([](const std::size_t index) { return -3.0*static_cast<Scalar>(index); }, 2)),
                "./*");
 }
 
@@ -66,36 +66,36 @@ TEST(test_vector_dense, constructors_lambda) {
 // -------------------------------------------------------------------------------------------------------------------
 
 TEST(test_vector_dense, scalar_multiplication_assignment) {
-  Vector_Dense<0> dynamic_vector = {1.0, 2.0, 3.0};
+  Vector_Dense<Scalar, 0> dynamic_vector = {1.0, 2.0, 3.0};
   dynamic_vector *= -3.0;
   EXPECT_DOUBLE_EQ(dynamic_vector[0], -3.0);
   EXPECT_DOUBLE_EQ(dynamic_vector[1], -6.0);
   EXPECT_DOUBLE_EQ(dynamic_vector[2], -9.0);
 
-  Vector_Dense<2> static_vector = {3.0, -5.0};
+  Vector_Dense<Scalar, 2> static_vector = {3.0, -5.0};
   static_vector *= 4.0;
   EXPECT_DOUBLE_EQ(static_vector[0], 12.0);
   EXPECT_DOUBLE_EQ(static_vector[1], -20.0);
 }
 
 TEST(test_vector_dense, scalar_division_assignment) {
-  Vector_Dense<0> dynamic_vector = {3.0, 6.0, -5.0};
+  Vector_Dense<Scalar, 0> dynamic_vector = {3.0, 6.0, -5.0};
   dynamic_vector /= 3.0;
   EXPECT_DOUBLE_EQ(dynamic_vector[0], 1.0);
   EXPECT_DOUBLE_EQ(dynamic_vector[1], 2.0);
   EXPECT_DOUBLE_EQ(dynamic_vector[2], -5.0/3.0);
 
-  Vector_Dense<2> static_vector = {3.0, -5.0};
+  Vector_Dense<Scalar, 2> static_vector = {3.0, -5.0};
   static_vector /= 4.0;
   EXPECT_DOUBLE_EQ(static_vector[0], 3.0/4.0);
   EXPECT_DOUBLE_EQ(static_vector[1], -5.0/4.0);
 }
 
 TEST(test_vector_dense, vector_addition_assignment) {
-  Vector_Dense<0> dynamic_vector_0 = {1.0, 2.0, 3.0};
-  Vector_Dense<0> dynamic_vector_1 = {-1.0, -2.0, -3.0};
-  Vector_Dense<3> static_vector_0 = {4.0, 5.0, 6.0};
-  Vector_Dense<3> static_vector_1 = {-4.0, -5.0, -6.0};
+  Vector_Dense<Scalar, 0> dynamic_vector_0 = {1.0, 2.0, 3.0};
+  Vector_Dense<Scalar, 0> dynamic_vector_1 = {-1.0, -2.0, -3.0};
+  Vector_Dense<Scalar, 3> static_vector_0 = {4.0, 5.0, 6.0};
+  Vector_Dense<Scalar, 3> static_vector_1 = {-4.0, -5.0, -6.0};
 
   // assignment of dynamic vectors
   dynamic_vector_0 += dynamic_vector_1;
@@ -111,19 +111,19 @@ TEST(test_vector_dense, vector_addition_assignment) {
   FOR_EACH(element, dynamic_vector_0) EXPECT_DOUBLE_EQ(element, -3.0);
   FOR_EACH(element, static_vector_0) EXPECT_DOUBLE_EQ(element, 0.0);
 
-  Vector_Dense<0> dynamic_vector_2;
-  Vector_Dense<2> static_vector_2;
+  Vector_Dense<Scalar, 0> dynamic_vector_2;
+  Vector_Dense<Scalar, 2> static_vector_2;
   EXPECT_DEATH(dynamic_vector_0 += dynamic_vector_2, "./*");
   EXPECT_DEATH(static_vector_0 += dynamic_vector_2, "./*");
   EXPECT_DEATH(dynamic_vector_0 += static_vector_2, "./*");
   EXPECT_DEATH(static_vector_0 += static_vector_2, "./*");
 }
 
 TEST(test_vector_dense, vector_subtraction_assignment) {
-  Vector_Dense<0> dynamic_vector_0 = {-1.0, -2.0, -3.0};
-  Vector_Dense<0> dynamic_vector_1 = {-1.0, -2.0, -3.0};
-  Vector_Dense<3> static_vector_0 = {-4.0, -5.0, -6.0};
-  Vector_Dense<3> static_vector_1 = {-4.0, -5.0, -6.0};
+  Vector_Dense<Scalar, 0> dynamic_vector_0 = {-1.0, -2.0, -3.0};
+  Vector_Dense<Scalar, 0> dynamic_vector_1 = {-1.0, -2.0, -3.0};
+  Vector_Dense<Scalar, 3> static_vector_0 = {-4.0, -5.0, -6.0};
+  Vector_Dense<Scalar, 3> static_vector_1 = {-4.0, -5.0, -6.0};
 
   // assignment of dynamic vectors
   dynamic_vector_0 -= dynamic_vector_1;
@@ -139,8 +139,8 @@ TEST(test_vector_dense, vector_subtraction_assignment) {
   FOR_EACH(element, dynamic_vector_0) EXPECT_DOUBLE_EQ(element, 3.0);
   FOR_EACH(element, static_vector_0) EXPECT_DOUBLE_EQ(element, 0.0);
 
-  Vector_Dense<0> dynamic_vector_2;
-  Vector_Dense<2> static_vector_2;
+  Vector_Dense<Scalar, 0> dynamic_vector_2;
+  Vector_Dense<Scalar, 2> static_vector_2;
   EXPECT_DEATH(dynamic_vector_0 -= dynamic_vector_2, "./*");
   EXPECT_DEATH(static_vector_0 -= dynamic_vector_2, "./*");
   EXPECT_DEATH(dynamic_vector_0 -= static_vector_2, "./*");
@@ -152,71 +152,71 @@ TEST(test_vector_dense, vector_subtraction_assignment) {
 // ---------------------------------------------------------------------------------------------------------------------
 
 TEST(test_vector_dense, scalar_multiplication) {
-  Vector_Dense<0> dynamic_vector = {1.0, 2.0, 3.0};
+  Vector_Dense<Scalar, 0> dynamic_vector = {1.0, 2.0, 3.0};
   dynamic_vector = -3.0*dynamic_vector;
   EXPECT_DOUBLE_EQ(dynamic_vector[0], -3.0);
   EXPECT_DOUBLE_EQ(dynamic_vector[1], -6.0);
   EXPECT_DOUBLE_EQ(dynamic_vector[2], -9.0);
 
-  Vector_Dense<2> static_vector = {3.0, -5.0};
+  Vector_Dense<Scalar, 2> static_vector = {3.0, -5.0};
   static_vector = 4.0*static_vector;
   EXPECT_DOUBLE_EQ(static_vector[0], 12.0);
   EXPECT_DOUBLE_EQ(static_vector[1], -20.0);
 }
 
 TEST(test_vector_dense, scalar_division) {
-  Vector_Dense<0> dynamic_vector = {3.0, 6.0, -5.0};
+  Vector_Dense<Scalar, 0> dynamic_vector = {3.0, 6.0, -5.0};
   dynamic_vector = dynamic_vector/3.0;
   EXPECT_DOUBLE_EQ(dynamic_vector[0], 1.0);
   EXPECT_DOUBLE_EQ(dynamic_vector[1], 2.0);
   EXPECT_DOUBLE_EQ(dynamic_vector[2], -5.0/3.0);
 
-  Vector_Dense<2> static_vector = {3.0, -5.0};
+  Vector_Dense<Scalar, 2> static_vector = {3.0, -5.0};
   static_vector = static_vector/4.0;
   EXPECT_DOUBLE_EQ(static_vector[0], 3.0/4.0);
   EXPECT_DOUBLE_EQ(static_vector[1], -5.0/4.0);
 }
 
 TEST(test_vector_dense, vector_addition) {
-  Vector_Dense<0> dynamic_vector_0 = {1.0, 2.0, 3.0};
-  Vector_Dense<0> dynamic_vector_1 = {-1.0, -2.0, -3.0};
-  Vector_Dense<3> static_vector_0 = {4.0, 5.0, 6.0};
-  Vector_Dense<3> static_vector_1 = {-4.0, -5.0, -6.0};
-
-  Vector_Dense<0> result_0 = dynamic_vector_0 + dynamic_vector_1;
-  Vector_Dense<3> result_1 = static_vector_0 + dynamic_vector_1;
-  Vector_Dense<3> result_2 = dynamic_vector_0 + static_vector_1;
-  Vector_Dense<3> result_3 = static_vector_0 + static_vector_1;
+  Vector_Dense<Scalar, 0> dynamic_vector_0 = {1.0, 2.0, 3.0};
+  Vector_Dense<Scalar, 0> dynamic_vector_1 = {-1.0, -2.0, -3.0};
+  Vector_Dense<Scalar, 3> static_vector_0 = {4.0, 5.0, 6.0};
+  Vector_Dense<Scalar, 3> static_vector_1 = {-4.0, -5.0, -6.0};
+
+  Vector_Dense<Scalar, 0> result_0 = dynamic_vector_0 + dynamic_vector_1;
+  Vector_Dense<Scalar, 3> result_1 = static_vector_0 + dynamic_vector_1;
+  Vector_Dense<Scalar, 3> result_2 = dynamic_vector_0 + static_vector_1;
+  Vector_Dense<Scalar, 3> result_3 = static_vector_0 + static_vector_1;
   FOR_EACH(element, result_0) EXPECT_DOUBLE_EQ(element, 0.0);
   FOR_EACH(element, result_1) EXPECT_DOUBLE_EQ(element, 3.0);
   FOR_EACH(element, result_2) EXPECT_DOUBLE_EQ(element, -3.0);
   FOR_EACH(element, result_3) EXPECT_DOUBLE_EQ(element, 0.0);
 
-  Vector_Dense<0> dynamic_vector_2;
-  Vector_Dense<2> static_vector_2;
+  Vector_Dense<Scalar, 0> dynamic_vector_2;
+  Vector_Dense<Scalar, 2> static_vector_2;
   EXPECT_DEATH(dynamic_vector_0 + dynamic_vector_2, "./*");
   EXPECT_DEATH(static_vector_0 + dynamic_vector_2, "./*");
   EXPECT_DEATH(dynamic_vector_0 + static_vector_2, "./*");
   EXPECT_DEATH(static_vector_0 + static_vector_2, "./*");
 }
 
 TEST(test_vector_dense, vector_subtraction) {
-  Vector_Dense<0> dynamic_vector_0 = {-1.0, -2.0, -3.0};
-  Vector_Dense<0> dynamic_vector_1 = {-1.0, -2.0, -3.0};
-  Vector_Dense<3> static_vector_0 = {-4.0, -5.0, -6.0};
-  Vector_Dense<3> static_vector_1 = {-4.0, -5.0, -6.0};
-
-  Vector_Dense<0> result_0 = dynamic_vector_0 - dynamic_vector_1;
-  Vector_Dense<3> result_1 = static_vector_0 - dynamic_vector_1;
-  Vector_Dense<3> result_2 = dynamic_vector_0 - static_vector_1;
-  Vector_Dense<3> result_3 = static_vector_0 - static_vector_1;
+  Vector_Dense<Scalar, 0> dynamic_vector_0 = {-1.0, -2.0, -3.0};
+  Vector_Dense<Scalar, 0> dynamic_vector_1 = {-1.0, -2.0, -3.0};
+  Vector_Dense<Scalar, 3> static_vector_0 = {-4.0, -5.0, -6.0};
+  Vector_Dense<Scalar, 3> static_vector_1 = {-4.0, -5.0, -6.0};
+
+  Vector_Dense<Scalar, 0> result_0 = dynamic_vector_0 - dynamic_vector_1;
+  Vector_Dense<Scalar, 3> result_1 = static_vector_0 - dynamic_vector_1;
+  Vector_Dense<Scalar, 3> result_2 = dynamic_vector_0 - static_vector_1;
+  Vector_Dense<Scalar, 3> result_3 = static_vector_0 - static_vector_1;
   FOR_EACH(element, result_0) EXPECT_DOUBLE_EQ(element, 0.0);
   FOR_EACH(element, result_1) EXPECT_DOUBLE_EQ(element, -3.0);
   FOR_EACH(element, result_2) EXPECT_DOUBLE_EQ(element, 3.0);
   FOR_EACH(element, result_3) EXPECT_DOUBLE_EQ(element, 0.0);
 
-  Vector_Dense<0> dynamic_vector_2;
-  Vector_Dense<2> static_vector_2;
+  Vector_Dense<Scalar, 0> dynamic_vector_2;
+  Vector_Dense<Scalar, 2> static_vector_2;
   EXPECT_DEATH(dynamic_vector_0 - dynamic_vector_2, "./*");
   EXPECT_DEATH(static_vector_0 - dynamic_vector_2, "./*");
   EXPECT_DEATH(dynamic_vector_0 - static_vector_2, "./*");