add batch_bool kernel::load with requires_arch<avx512f>

Author: junparser

include/xsimd/arch/generic/xsimd_generic_memory.hpp

@@ -260,6 +260,19 @@ namespace xsimd
             return buffer[i];
         }
 
+        // load
+        template <class A, class T>
+        XSIMD_INLINE batch_bool<T, A> load(bool const* mem, batch_bool<T, A>, requires_arch<generic>) noexcept
+        {
+            using batch_type = batch<T, A>;
+            batch_type ref(0);
+            constexpr auto size = batch_bool<T, A>::size;
+            alignas(A::alignment()) T buffer[size];
+            for (std::size_t i = 0; i < size; ++i)
+                buffer[i] = mem[i] ? 1 : 0;
+            return ref != batch_type::load_aligned(&buffer[0]);
+        }
+
         // load_aligned
         namespace detail
         {

include/xsimd/arch/xsimd_avx512f.hpp

@@ -1118,6 +1118,19 @@ namespace xsimd
             return detail::compare_int_avx512f<A, T, _MM_CMPINT_LE>(self, other);
         }
 
+        // load
+        template <class A, class T>
+        XSIMD_INLINE batch_bool<T, A> load(bool const* mem, batch_bool<T, A>, requires_arch<avx512f>) noexcept
+        {
+            using register_type = typename batch_bool<T, A>::register_type;
+            constexpr auto size = batch_bool<T, A>::size;
+            register_type mask = 0;
+            for (std::size_t i = 0; i < size; ++i)
+                mask |= (register_type(mem[i] ? 1 : 0) << i);
+
+            return mask;
+        }
+
         // load_aligned
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
         XSIMD_INLINE batch<T, A> load_aligned(T const* mem, convert<T>, requires_arch<avx512f>) noexcept

include/xsimd/types/xsimd_batch.hpp

@@ -968,11 +968,7 @@ namespace xsimd
     template <class T, class A>
     XSIMD_INLINE batch_bool<T, A> batch_bool<T, A>::load_aligned(bool const* mem) noexcept
     {
-        batch_type ref(0);
-        alignas(A::alignment()) T buffer[size];
-        for (std::size_t i = 0; i < size; ++i)
-            buffer[i] = mem[i] ? 1 : 0;
-        return ref != batch_type::load_aligned(&buffer[0]);
+        return kernel::load<A>(mem, batch_bool<T, A>(), A {});
     }
 
     template <class T, class A>