Add batch_constant comparison operators

Author: AntoinePrv

include/xsimd/types/xsimd_batch.hpp

@@ -296,6 +296,7 @@ namespace xsimd
         static constexpr std::size_t size = sizeof(types::simd_register<T, A>) / sizeof(T); ///< Number of scalar elements in this batch.
 
         using value_type = bool; ///< Type of the scalar elements within this batch.
+        using operand_type = T;
         using arch_type = A; ///< SIMD Architecture abstracted by this batch.
         using register_type = typename base_type::register_type; ///< SIMD register type abstracted by this batch.
         using batch_type = batch<T, A>; ///< Associated batch type this batch represents logical operations for.

include/xsimd/types/xsimd_batch_constant.hpp

@@ -31,6 +31,7 @@ namespace xsimd
         using batch_type = batch_bool<T, A>;
         static constexpr std::size_t size = sizeof...(Values);
         using value_type = bool;
+        using operand_type = T;
         static_assert(sizeof...(Values) == batch_type::size, "consistent batch size");
 
     public:
@@ -227,6 +228,63 @@ namespace xsimd
 
 #undef MAKE_BINARY_OP
 
+        struct boolean_eq
+        {
+            constexpr bool operator()(T x, T y) const { return x == y; }
+        };
+        struct boolean_ne
+        {
+            constexpr bool operator()(T x, T y) const { return x != y; }
+        };
+        struct boolean_gt
+        {
+            constexpr bool operator()(T x, T y) const { return x > y; }
+        };
+        struct boolean_ge
+        {
+            constexpr bool operator()(T x, T y) const { return x >= y; }
+        };
+        struct boolean_lt
+        {
+            constexpr bool operator()(T x, T y) const { return x < y; }
+        };
+        struct boolean_le
+        {
+            constexpr bool operator()(T x, T y) const { return x <= y; }
+        };
+
+        template <class F, class SelfPack, class OtherPack, size_t... Indices>
+        static constexpr batch_bool_constant<T, A, F()(std::tuple_element<Indices, SelfPack>::type::value, std::tuple_element<Indices, OtherPack>::type::value)...>
+        apply_bool(detail::index_sequence<Indices...>)
+        {
+            return {};
+        }
+
+        template <class F, T... OtherValues>
+        static constexpr auto apply_bool(batch_constant<T, A, Values...>, batch_constant<T, A, OtherValues...>)
+            -> decltype(apply_bool<F, std::tuple<std::integral_constant<T, Values>...>, std::tuple<std::integral_constant<T, OtherValues>...>>(detail::make_index_sequence<sizeof...(Values)>()))
+        {
+            static_assert(sizeof...(Values) == sizeof...(OtherValues), "compatible constant batches");
+            return {};
+        }
+
+#define MAKE_BINARY_BOOL_OP(OP, NAME)                                            \
+    template <T... OtherValues>                                                  \
+    constexpr auto operator OP(batch_constant<T, A, OtherValues...> other) const \
+        -> decltype(apply_bool<NAME>(*this, other))                              \
+    {                                                                            \
+        return {};                                                               \
+    }
+
+        MAKE_BINARY_BOOL_OP(==, boolean_eq)
+        MAKE_BINARY_BOOL_OP(!=, boolean_ne)
+        MAKE_BINARY_BOOL_OP(<, boolean_lt)
+        MAKE_BINARY_BOOL_OP(<=, boolean_le)
+        MAKE_BINARY_BOOL_OP(>, boolean_gt)
+        MAKE_BINARY_BOOL_OP(>=, boolean_ge)
+
+#undef MAKE_BINARY_BOOL_OP
+
         constexpr batch_constant<T, A, (T)-Values...> operator-() const
         {
             return {};

test/test_batch_constant.cpp

@@ -146,6 +146,30 @@ struct constant_batch_test
         constexpr auto n12_usub = -n12;
         constexpr auto n12_usub_ = xsimd::make_batch_constant<value_type, constant<(value_type)-12>, arch_type>();
         static_assert(std::is_same<decltype(n12_usub), decltype(n12_usub_)>::value, "-n12 == n12_usub");
+
+        // comparison operators
+        using true_batch_type = decltype(xsimd::make_batch_bool_constant<value_type, true, arch_type>());
+        using false_batch_type = decltype(xsimd::make_batch_bool_constant<value_type, false, arch_type>());
+
+        static_assert(std::is_same<typename decltype(n12 == n12)::operand_type, typename decltype(n12)::value_type>::value, "same type");
+
+        static_assert(std::is_same<decltype(n12 == n12), true_batch_type>::value, "n12 == n12");
+        static_assert(std::is_same<decltype(n12 == n3), false_batch_type>::value, "n12 == n3");
+
+        static_assert(std::is_same<decltype(n12 != n12), false_batch_type>::value, "n12 != n12");
+        static_assert(std::is_same<decltype(n12 != n3), true_batch_type>::value, "n12 != n3");
+
+        static_assert(std::is_same<decltype(n12 < n12), false_batch_type>::value, "n12 < n12");
+        static_assert(std::is_same<decltype(n12 < n3), false_batch_type>::value, "n12 < n3");
+
+        static_assert(std::is_same<decltype(n12 > n12), false_batch_type>::value, "n12 > n12");
+        static_assert(std::is_same<decltype(n12 > n3), true_batch_type>::value, "n12 > n3");
+
+        static_assert(std::is_same<decltype(n12 <= n12), true_batch_type>::value, "n12 <= n12");
+        static_assert(std::is_same<decltype(n12 <= n3), false_batch_type>::value, "n12 <= n3");
+
+        static_assert(std::is_same<decltype(n12 >= n12), true_batch_type>::value, "n12 >= n12");
+        static_assert(std::is_same<decltype(n12 >= n3), true_batch_type>::value, "n12 >= n3");
     }
 };