custom is_arithmetic

Author: pjessesco

include/Peanut/impl/binary_expr/matrix_div_scalar.h

@@ -41,7 +41,7 @@ namespace Peanut::Impl {
      * @tparam T Right hand side scalar type.
      */
     template<typename E, typename T>
-        requires is_matrix_v<E> && std::is_arithmetic_v<T>
+        requires is_matrix_v<E> && is_arithmetic<T>
     struct MatrixDivScalar : public MatrixExpr<MatrixDivScalar<E, T>> {
         using Type = Float;
         MatrixDivScalar(const E &x, T y) : x{x}, y{y} {
@@ -80,7 +80,7 @@ namespace Peanut {
      * @return Constructed `Impl::MatrixDivScalar` instance
      */
     template<typename E, typename T>
-        requires is_matrix_v<E> && std::is_arithmetic_v<T>
+        requires is_matrix_v<E> && is_arithmetic<T>
     Impl::MatrixDivScalar<E, T> operator/(const MatrixExpr<E> &x, const T &y) {
         return Impl::MatrixDivScalar<E, T>(static_cast<const E &>(x), y);
     }

include/Peanut/impl/binary_expr/matrix_mult_scalar.h

@@ -39,7 +39,7 @@ namespace Peanut::Impl {
      * @tparam T Scalar type operand.
      */
     template<typename E, typename T>
-        requires is_matrix_v<E> && std::is_arithmetic_v<T>
+        requires is_matrix_v<E> && is_arithmetic<T>
     struct MatrixMultScalar : public MatrixExpr<MatrixMultScalar<E, T>> {
         using Type = typename std::conditional<
                 std::is_floating_point_v<typename E::Type> || std::is_floating_point_v<T>,
@@ -76,7 +76,7 @@ namespace Peanut {
      * @return Constructed `Impl::MatrixMultScalar` instance
      */
     template<typename E, typename T>
-        requires is_matrix_v<E> && std::is_arithmetic_v<T>
+        requires is_matrix_v<E> && is_arithmetic<T>
     Impl::MatrixMultScalar<E, T> operator*(const MatrixExpr<E> &x, const T &y) {
         return Impl::MatrixMultScalar<E, T>(static_cast<const E &>(x), y);
     }
@@ -88,7 +88,7 @@ namespace Peanut {
      * @return Constructed `Impl::MatrixMultScalar` instance
      */
     template<typename E, typename T>
-        requires is_matrix_v<E> && std::is_arithmetic_v<T>
+        requires is_matrix_v<E> && is_arithmetic<T>
     Impl::MatrixMultScalar<E, T> operator*(const T x, const MatrixExpr<E> &y) {
         return Impl::MatrixMultScalar<E, T>(static_cast<const E &>(y), x);
     }

include/Peanut/impl/common.h

@@ -26,11 +26,12 @@
 
 // Standard headers
 #include <cmath>
+#include <iostream>
 #include <limits>
 #include <utility>
-#include <iostream>
 
 // Peanut headers
+#include <Peanut/impl/matrix_type_traits.h>
 
 // Dependencies headers
 
@@ -52,7 +53,7 @@ namespace Peanut {
      *         If \p T is not a floating point type, returns true if \p val is zero, false if not.
      */
     template<typename T>
-    bool is_zero(T val) requires std::is_arithmetic_v<T>{
+    bool is_zero(T val) requires is_arithmetic<T>{
         if constexpr (std::is_floating_point_v<T>){
             return std::fabs(val-static_cast<T>(0)) <= std::numeric_limits<T>::epsilon() ||
                    std::fabs(val-static_cast<T>(0)) < std::numeric_limits<T>::min();

include/Peanut/impl/matrix.h

@@ -77,7 +77,7 @@ namespace Peanut {
      * @tparam R Row size.
      * @tparam C Column size.
      */
-    template<typename T, Index R, Index C> requires std::is_arithmetic_v<T> && (R > 0) && (C > 0)
+    template<typename T, Index R, Index C> requires is_arithmetic<T> && (R > 0) && (C > 0)
     struct Matrix : public MatrixExpr<Matrix<T, R, C>>{
 
         /**

include/Peanut/impl/matrix_type_traits.h

@@ -137,4 +137,9 @@ namespace Peanut {
      */
     template <typename E1, typename E2>
     constexpr bool is_equal_type_size_v = is_equal_type_size<E1, E2>::value;
+
+    // =========================================================================
+
+    template<typename T>
+    concept is_arithmetic = std::is_arithmetic_v<T>; // || simd || gpu || etc
 }

include/Peanut/impl/unary_expr/cast.h

@@ -38,7 +38,7 @@ namespace Peanut::Impl {
      * @tparam E Matrix expression type.
      */
     template<typename T, typename E>
-        requires std::is_arithmetic_v<T> && is_matrix_v<E>
+        requires is_arithmetic<T> && is_matrix_v<E>
     struct MatrixCastType : public MatrixExpr<MatrixCastType<T, E>> {
         using Type = T;
         MatrixCastType(const E &x) : x{x} {}
@@ -77,7 +77,7 @@ namespace Peanut {
      *
      */
     template<typename T, typename E>
-        requires std::is_arithmetic_v<T> && is_matrix_v<E>
+        requires is_arithmetic<T> && is_matrix_v<E>
     Impl::MatrixCastType<T, E> Cast(const MatrixExpr<E> &x) {
         return Impl::MatrixCastType<T, E>(static_cast<const E &>(x));
     }