Assertions updated #3

Author: nemothenoone

include/nil/algebra/matrix/math.hpp

@@ -151,8 +151,8 @@ namespace nil {
         template <typename T, std::size_t M, std::size_t N>
         constexpr std::tuple<matrix<T, M, N>, std::size_t, T>
         gauss_jordan_impl(matrix<T, M, N> m, T tolerance) {
-            COTILA_DETAIL_ASSERT_FLOATING_POINT(T)
-            COTILA_DETAIL_ASSERT_REAL(T)
+            CRYPTO3_DETAIL_ASSERT_FLOATING_POINT(T)
+            CRYPTO3_DETAIL_ASSERT_REAL(T)
 
             // Define function for determining if an element is negligible
             auto negligible = [&tolerance](const T &v) { return abs(v) < tolerance; };

include/nil/algebra/matrix/matrix.hpp

@@ -17,8 +17,6 @@
 #include <nil/algebra/vector/utility.hpp>
 #include <nil/algebra/vector/vector.hpp>
 
-#include <nil/algebra/detail/assert.hpp>
-
 namespace nil {
     namespace algebra {
 
@@ -34,7 +32,7 @@ namespace nil {
         template <typename T, std::size_t N, std::size_t M> struct matrix {
             static_assert(N != 0 && M != 0,
                                         "matrix must have have positive dimensions");
-            COTILA_DETAIL_ASSERT_ARITHMETIC(T)
+            CRYPTO3_DETAIL_ASSERT_ARITHMETIC(T)
 
             using value_type = T;
             using size_type = std::size_t;

include/nil/algebra/matrix/utility.hpp

@@ -17,6 +17,34 @@
 
 namespace nil {
     namespace algebra {
+        namespace detail {
+
+#define CRYPTO3_DETAIL_ASSERT_FLOATING_POINT(T)                                 \
+  static_assert(std::is_floating_point<typename cotila::detail::remove_complex<T>::type>::value,  \
+                "argument must be a (real or complex) floating point type");
+
+#define CRYPTO3_DETAIL_ASSERT_INTEGRAL(T)                                       \
+  static_assert(std::is_integral<T>::value, "argument must be a real integral type");
+
+#define CRYPTO3_DETAIL_ASSERT_VALID_COMPLEX(T)                                  \
+  static_assert(!cotila::detail::is_complex<T>::value ||                                 \
+          std::is_floating_point<typename cotila::detail::remove_complex<T>::type>::value,        \
+      "invalid complex type argument (valid types are "                        \
+      "complex<float>, complex<double>, and complex<long double>)");
+
+#define CRYPTO3_DETAIL_ASSERT_ARITHMETIC(T)                                     \
+  CRYPTO3_DETAIL_ASSERT_VALID_COMPLEX(T)                                        \
+  static_assert(std::is_arithmetic<typename cotila::detail::remove_complex<T>::type>::value,  \
+                "argument must be a (real or complex) arithmetic type");
+
+#define CRYPTO3_DETAIL_ASSERT_REAL(T)                                           \
+  static_assert(std::is_arithmetic<T>::value, "argument must be a real arithmetic type");
+
+#define CRYPTO3_DETAIL_ASSERT_COMPLEX(T)                                        \
+  CRYPTO3_DETAIL_ASSERT_VALID_COMPLEX(T)                                        \
+  static_assert(cotila::detail::is_complex<T>::value, "argument must be a complex type");
+        }
+
 
         /** \addtogroup matrix
          *    @{

include/nil/algebra/vector/vector.hpp

@@ -29,7 +29,7 @@ namespace nil {
          */
         template <typename T, std::size_t N> struct vector {
             static_assert(N != 0, "vector must contain at least one element");
-            COTILA_DETAIL_ASSERT_ARITHMETIC(T)
+            CRYPTO3_DETAIL_ASSERT_ARITHMETIC(T)
 
             using value_type = T;
             using size_type = std::size_t;