Added broadcast overload for bool (#1089)

* Added broadcast overload for bool

* Improved documentation

---------

Co-authored-by: serge-sans-paille <[email protected]>

Author: JohanMabille

include/xsimd/arch/generic/xsimd_generic_memory.hpp

@@ -32,6 +32,32 @@ namespace xsimd
 
         using namespace types;
 
+        // broadcast
+        namespace detail
+        {
+            template <class T, class A>
+            struct broadcaster
+            {
+                using return_type = batch<T, A>;
+
+                static XSIMD_INLINE return_type run(T v) noexcept
+                {
+                    return return_type::broadcast(v);
+                }
+            };
+
+            template <class A>
+            struct broadcaster<bool, A>
+            {
+                using return_type = batch_bool<xsimd::as_unsigned_integer_t<bool>, A>;
+
+                static XSIMD_INLINE return_type run(bool b) noexcept
+                {
+                    return return_type(b);
+                }
+            };
+        }
+
         // compress
         namespace detail
         {

include/xsimd/types/xsimd_api.hpp

@@ -486,15 +486,17 @@ namespace xsimd
     /**
      * @ingroup batch_data_transfer
      *
-     * Creates a batch from the single value \c v.
+     * Creates a batch from the single value \c v. If \c v is a boolean,
+     * this function returns a batch_bool<uint8_t>. If you need another type
+     * of batch_bool, please use \c broadcast_as instead.
      * @param v the value used to initialize the batch
      * @return a new batch instance
      */
     template <class T, class A = default_arch>
-    XSIMD_INLINE batch<T, A> broadcast(T v) noexcept
+    XSIMD_INLINE typename kernel::detail::broadcaster<T, A>::return_type broadcast(T v) noexcept
     {
         detail::static_check_supported_config<T, A>();
-        return batch<T, A>::broadcast(v);
+        return kernel::detail::broadcaster<T, A>::run(v);
     }
 
     /**

include/xsimd/types/xsimd_traits.hpp

@@ -77,6 +77,11 @@ namespace xsimd
                           "usage of batch type with unsupported type");
         };
 
+        template <class A>
+        struct static_check_supported_config_emitter<bool, A> : static_check_supported_config_emitter<xsimd::as_unsigned_integer_t<bool>, A>
+        {
+        };
+
         template <class T, class A>
         struct static_check_supported_config_emitter<std::complex<T>, A> : static_check_supported_config_emitter<T, A>
         {

include/xsimd/types/xsimd_utils.hpp

@@ -77,6 +77,12 @@ namespace xsimd
     {
     };
 
+    template <>
+    struct as_unsigned_integer<bool>
+    {
+        using type = uint8_t;
+    };
+
     template <>
     struct as_unsigned_integer<float>
     {

test/test_api.cpp

@@ -23,6 +23,7 @@ struct xsimd_api_test
 {
     using batch_type = B;
     using batch_bool_type = typename B::batch_bool_type;
+    using arch_type = typename B::arch_type;
     using value_type = typename B::value_type;
     static constexpr size_t size = B::size;
     using array_type = std::array<value_type, size>;
@@ -100,6 +101,7 @@ struct xsimd_api_test
 
     void test_set()
     {
+        test_set_bool("set bool");
         test_set_impl<int8_t>("set int8_t");
         test_set_impl<uint8_t>("set uint8_t");
         test_set_impl<int16_t>("set int16_t");
@@ -171,6 +173,15 @@ struct xsimd_api_test
         CHECK_BATCH_EQ(res, expected);
     }
 
+    void test_set_bool(const std::string& name)
+    {
+        bool v = true;
+        xsimd::batch_bool<uint8_t, arch_type> expected(v);
+        xsimd::batch_bool<uint8_t, arch_type> res = xsimd::broadcast(v);
+        INFO(name);
+        CHECK_BATCH_EQ(res, expected);
+    }
+
     template <class V>
     void init_test_vector(V& vec)
     {