WIP

Author: DiamonDinoia

test/test_batch_bool.cpp

@@ -12,14 +12,94 @@
 #include "xsimd/xsimd.hpp"
 #ifndef XSIMD_NO_SUPPORTED_ARCHITECTURE
 
+#include <array>
 #include <functional>
+#include <type_traits>
 #include <vector>
 
 #include "test_utils.hpp"
 
 namespace xsimd
 {
 
+    namespace test_detail
+    {
+        template <class T, std::size_t N>
+        struct ct_mask_arch
+        {
+            static constexpr bool supported() noexcept { return true; }
+            static constexpr bool available() noexcept { return true; }
+            static constexpr std::size_t alignment() noexcept { return 0; }
+            static constexpr bool requires_alignment() noexcept { return false; }
+            static constexpr char const* name() noexcept { return "ct_mask_arch"; }
+        };
+
+        template <class T, std::size_t N>
+        struct ct_mask_register
+        {
+            std::array<T, N> data {};
+        };
+
+        struct mask_all_false
+        {
+            static constexpr bool get(std::size_t, std::size_t) { return false; }
+        };
+
+        struct mask_all_true
+        {
+            static constexpr bool get(std::size_t, std::size_t) { return true; }
+        };
+
+        struct mask_prefix1
+        {
+            static constexpr bool get(std::size_t i, std::size_t) { return i < 1; }
+        };
+
+        struct mask_suffix1
+        {
+            static constexpr bool get(std::size_t i, std::size_t n) { return i >= (n - 1); }
+        };
+
+        struct mask_ends
+        {
+            static constexpr bool get(std::size_t i, std::size_t n)
+            {
+                return (i < 1) || (i >= (n - 1));
+            }
+        };
+
+        struct mask_interleaved
+        {
+            static constexpr bool get(std::size_t i, std::size_t) { return (i % 2) == 0; }
+        };
+
+        template <class T>
+        struct alternating_numeric
+        {
+            static constexpr T get(std::size_t i, std::size_t)
+            {
+                return (i % 2) ? T(2) : T(1);
+            }
+        };
+    }
+
+    namespace types
+    {
+        template <class T, std::size_t N>
+        struct simd_register<T, test_detail::ct_mask_arch<T, N>>
+        {
+            using register_type = test_detail::ct_mask_register<T, N>;
+            register_type data;
+            constexpr operator register_type() const noexcept { return data; }
+        };
+
+        template <class T, std::size_t N>
+        struct has_simd_register<T, test_detail::ct_mask_arch<T, N>> : std::true_type
+        {
+        };
+    }
+
+
     int popcount(int v)
     {
         // from https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan
@@ -154,6 +234,26 @@ namespace xsimd
 
 }
 
+template <class ValueType, class Arch, std::size_t Size, bool Integral = std::is_integral<ValueType>::value>
+struct numeric_constant_helper
+{
+    static void fill(std::array<ValueType, Size>&)
+    {
+    }
+};
+
+template <class ValueType, class Arch, std::size_t Size>
+struct numeric_constant_helper<ValueType, Arch, Size, true>
+{
+    static void fill(std::array<ValueType, Size>& out)
+    {
+        constexpr auto numeric_constant = xsimd::make_batch_constant<ValueType,
+                                                                      xsimd::test_detail::alternating_numeric<ValueType>,
+                                                                      Arch>();
+        numeric_constant.as_batch().store_unaligned(out.data());
+    }
+};
+
 template <class T>
 struct batch_bool_test
 {
@@ -179,42 +279,108 @@ struct batch_bool_test
                 : ((bits & 1u ? index : 0u) + sum_indices(bits >> 1, index + 1, remaining - 1));
         }
 
-        struct ct_false
+        static constexpr uint32_t low_mask_bits(std::size_t width)
         {
-            static constexpr bool get(std::size_t, std::size_t) { return false; }
-        };
-        struct ct_true
+            return width == 0 ? 0u : (static_cast<uint32_t>(1u << width) - 1u);
+        }
+
+        template <class Mask, class ValueType, bool Enable>
+        struct splice_checker
         {
-            static constexpr bool get(std::size_t, std::size_t) { return true; }
+            static void run()
+            {
+            }
         };
-        struct ct_prefix1
+
+        template <class Mask, class ValueType>
+        struct splice_checker<Mask, ValueType, true>
         {
-            static constexpr bool get(std::size_t i, std::size_t) { return i < 1; }
+            static void run()
+            {
+                constexpr std::size_t begin = 1;
+                constexpr std::size_t end = (Mask::size > 3 ? 3 : Mask::size);
+                constexpr std::size_t length = (end > begin) ? (end - begin) : 0;
+                using slice_arch = xsimd::test_detail::ct_mask_arch<ValueType, length>;
+                constexpr auto slice = Mask::template splice<slice_arch, begin, end>();
+                constexpr uint32_t src_mask = static_cast<uint32_t>(Mask::mask());
+                constexpr uint32_t expected = (src_mask >> begin) & low_mask_bits(length);
+                static_assert(static_cast<uint32_t>(slice.mask()) == expected, "splice mask expected");
+                constexpr uint32_t slice_bits = static_cast<uint32_t>(slice.mask());
+                constexpr uint32_t shifted_source = src_mask >> begin;
+                static_assert((length == 0) || ((slice_bits & 1u) == (shifted_source & 1u)), "slice first bit matches");
+                static_assert((length <= 1) || (((slice_bits >> (length - 1)) & 1u)
+                                                == ((shifted_source >> (length - 1)) & 1u)),
+                              "slice last bit matches");
+            }
         };
-        struct ct_suffix1
+
+        template <class Mask, class ValueType, bool Enable>
+        struct half_checker
         {
-            static constexpr bool get(std::size_t i, std::size_t n) { return i >= (n - 1); }
+            static void run()
+            {
+            }
         };
-        struct ct_ends
+
+        template <class Mask, class ValueType>
+        struct half_checker<Mask, ValueType, true>
         {
-            static constexpr bool get(std::size_t i, std::size_t n) { return (i < 1) || (i >= (n - 1)); }
+            static void run()
+            {
+                constexpr std::size_t total = Mask::size;
+                constexpr std::size_t mid = total / 2;
+                using lower_arch = xsimd::test_detail::ct_mask_arch<ValueType, mid>;
+                using upper_arch = xsimd::test_detail::ct_mask_arch<ValueType, total - mid>;
+                constexpr auto lower = Mask::template lower_half<lower_arch>();
+                constexpr auto upper = Mask::template upper_half<upper_arch>();
+                constexpr uint32_t source_mask = static_cast<uint32_t>(Mask::mask());
+                static_assert(static_cast<uint32_t>(lower.mask()) == (source_mask & low_mask_bits(mid)),
+                              "lower_half mask matches");
+                static_assert(static_cast<uint32_t>(upper.mask()) == ((source_mask >> mid) & low_mask_bits(total - mid)),
+                              "upper_half mask matches");
+                constexpr auto lower_splice = Mask::template splice<lower_arch, 0, mid>();
+                constexpr auto upper_splice = Mask::template splice<upper_arch, mid, total>();
+                static_assert(lower.mask() == lower_splice.mask(), "lower_half equals splice");
+                static_assert(upper.mask() == upper_splice.mask(), "upper_half equals splice");
+                constexpr uint32_t lower_bits = static_cast<uint32_t>(lower.mask());
+                constexpr uint32_t upper_bits = static_cast<uint32_t>(upper.mask());
+                constexpr std::size_t upper_size = decltype(upper)::size;
+                static_assert((mid == 0) || ((lower_bits & 1u) == (source_mask & 1u)), "lower first element");
+                static_assert((mid <= 1) || (((lower_bits >> (mid - 1)) & 1u)
+                                             == ((source_mask >> (mid - 1)) & 1u)),
+                              "lower last element");
+                static_assert((upper_size == 0) || ((upper_bits & 1u) == ((source_mask >> mid) & 1u)),
+                              "upper first element");
+                static_assert((upper_size <= 1) || (((upper_bits >> (upper_size - 1)) & 1u)
+                                                    == ((source_mask >> (total - 1)) & 1u)),
+                              "upper last element");
+            }
         };
 
         static void run()
         {
             using value_type = typename B::value_type;
             using arch_type = typename B::arch_type;
-            constexpr auto m_zero = xsimd::make_batch_bool_constant<value_type, ct_false, arch_type>();
-            constexpr auto m_one = xsimd::make_batch_bool_constant<value_type, ct_true, arch_type>();
-            constexpr auto m_prefix = xsimd::make_batch_bool_constant<value_type, ct_prefix1, arch_type>();
-            constexpr auto m_suffix = xsimd::make_batch_bool_constant<value_type, ct_suffix1, arch_type>();
-            constexpr auto m_ends = xsimd::make_batch_bool_constant<value_type, ct_ends, arch_type>();
+            constexpr auto m_zero = xsimd::make_batch_bool_constant<value_type, xsimd::test_detail::mask_all_false, arch_type>();
+            constexpr auto m_one = xsimd::make_batch_bool_constant<value_type, xsimd::test_detail::mask_all_true, arch_type>();
+            constexpr auto m_prefix = xsimd::make_batch_bool_constant<value_type, xsimd::test_detail::mask_prefix1, arch_type>();
+            constexpr auto m_suffix = xsimd::make_batch_bool_constant<value_type, xsimd::test_detail::mask_suffix1, arch_type>();
+            constexpr auto m_ends = xsimd::make_batch_bool_constant<value_type, xsimd::test_detail::mask_ends, arch_type>();
+            constexpr auto m_interleaved = xsimd::make_batch_bool_constant<value_type, xsimd::test_detail::mask_interleaved, arch_type>();
 
             static_assert((m_zero | m_one).mask() == m_one.mask(), "0|1 == 1");
             static_assert((m_zero & m_one).mask() == m_zero.mask(), "0&1 == 0");
             static_assert((m_zero ^ m_zero).mask() == m_zero.mask(), "0^0 == 0");
             static_assert((m_one ^ m_one).mask() == m_zero.mask(), "1^1 == 0");
 
+            static_assert((!m_zero).mask() == m_one.mask(), "!0 == 1");
+            static_assert((~m_zero).mask() == m_one.mask(), "~0 == 1");
+            static_assert((!m_one).mask() == m_zero.mask(), "!1 == 0");
+            static_assert((~m_one).mask() == m_zero.mask(), "~1 == 0");
+
+            static_assert(((m_prefix && m_suffix).mask()) == (m_prefix & m_suffix).mask(), "&& consistent");
+            static_assert(((m_prefix || m_suffix).mask()) == (m_prefix | m_suffix).mask(), "|| consistent");
+
             static_assert((m_prefix | m_suffix).mask() == m_ends.mask(), "prefix|suffix == ends");
             static_assert(B::size == 1 || (m_prefix & m_suffix).mask() == m_zero.mask(), "prefix&suffix == 0 when size>1");
 
@@ -223,28 +389,54 @@ struct batch_bool_test
             static_assert(!m_zero.all(), "zero mask all");
             static_assert(m_zero.countr_zero() == B::size, "zero mask trailing zeros");
             static_assert(m_zero.countl_zero() == B::size, "zero mask leading zeros");
+            static_assert(m_zero.is_empty(), "zero mask empty");
+            static_assert(!m_zero.is_full(), "zero mask not full");
 
             static_assert(m_one.all(), "all mask all");
             static_assert(m_one.any(), "all mask any");
             static_assert(!m_one.none(), "all mask none");
             static_assert(m_one.countr_zero() == 0, "all mask trailing zeros");
             static_assert(m_one.countl_zero() == 0, "all mask leading zeros");
+            static_assert(!m_one.is_empty(), "all mask not empty");
+            static_assert(m_one.is_full(), "all mask full");
+
+            constexpr uint32_t prefix_bits = static_cast<uint32_t>(m_prefix.mask());
+            constexpr uint32_t suffix_bits = static_cast<uint32_t>(m_suffix.mask());
+            constexpr uint32_t ends_bits_mask = static_cast<uint32_t>(m_ends.mask());
+
+            static_assert((B::size == 0) || ((prefix_bits & 1u) != 0u), "prefix first element set");
+            static_assert((B::size <= 1) || ((prefix_bits & (1u << 1)) == 0u), "prefix second element cleared");
+
+            static_assert((B::size == 0) || (((suffix_bits >> (B::size - 1)) & 1u) != 0u), "suffix last element set");
+            static_assert((B::size <= 1) || ((suffix_bits & 1u) == 0u), "suffix first element cleared");
+
+            static_assert((B::size == 0) || ((ends_bits_mask & 1u) != 0u), "ends first element set");
+            static_assert((B::size == 0) || (((ends_bits_mask >> (B::size - 1)) & 1u) != 0u), "ends last element set");
+            static_assert((B::size <= 2) || (((ends_bits_mask >> 1) & 1u) == 0u), "ends interior element cleared");
+
+            static_assert(std::is_same<decltype(m_prefix.as_batch_bool()), typename B::batch_bool_type>::value,
+                          "as_batch_bool type");
+            static_assert(std::is_same<decltype(static_cast<typename B::batch_bool_type>(m_prefix)), typename B::batch_bool_type>::value,
+                          "conversion operator type");
 
             // splice API is validated indirectly via arch-specific masked implementations.
 
             constexpr std::size_t prefix_zero = m_prefix.countr_zero();
             constexpr std::size_t prefix_one = m_prefix.countr_one();
             static_assert(prefix_zero == 0, "prefix mask zero leading zeros from LSB");
-            static_assert(prefix_one == 1 || B::size == 0, "prefix mask trailing ones count");
+            static_assert((B::size == 0 ? prefix_one == 0 : prefix_one == 1), "prefix mask trailing ones count");
 
             constexpr std::size_t suffix_zero = m_suffix.countl_zero();
             constexpr std::size_t suffix_one = m_suffix.countl_one();
-            static_assert(suffix_zero == 0 || B::size == 0, "suffix mask leading zeros count");
-            static_assert(suffix_one == 1 || B::size == 0, "suffix mask trailing ones count");
+            static_assert(suffix_zero == 0, "suffix mask leading zeros count");
+            static_assert((B::size == 0 ? suffix_one == 0 : suffix_one == 1), "suffix mask trailing ones count");
+
+            splice_checker<decltype(m_interleaved), value_type, (B::size > 1)>::run();
+            half_checker<decltype(m_ends), value_type, (B::size > 0 && (B::size % 2 == 0))>::run();
 
             constexpr std::size_t ends_bits = m_ends.truncated_mask();
             constexpr std::size_t ends_sum = sum_indices(ends_bits, 0u, B::size);
-            static_assert((B::size <= 1 && ends_sum == 0) || (B::size > 1 && ends_sum == (B::size - 1)), "ends index sum coverage");
+            static_assert((B::size <= 1) ? (ends_sum == 0) : (ends_sum == (B::size - 1)), "ends index sum coverage");
         }
     };
 
@@ -621,6 +813,7 @@ struct batch_bool_test
     {
         auto bool_g = xsimd::get_bool<typename T::batch_bool_type> {};
         using batch_t = typename T::batch_bool_type;
+        using arch_type = typename batch_type::arch_type;
 
         auto check_mask = [&](batch_t const& m, const char*)
         {
@@ -706,6 +899,82 @@ struct batch_bool_test
         check_mask(bool_g.half, "half");
         check_mask(bool_g.ihalf, "ihalf");
         check_mask(bool_g.interspersed, "interspersed");
+
+        {
+            constexpr auto zero_constant = xsimd::make_batch_bool_constant<value_type, xsimd::test_detail::mask_all_false, arch_type>();
+            constexpr auto full_constant = xsimd::make_batch_bool_constant<value_type, xsimd::test_detail::mask_all_true, arch_type>();
+            constexpr auto prefix_constant = xsimd::make_batch_bool_constant<value_type, xsimd::test_detail::mask_prefix1, arch_type>();
+            constexpr auto suffix_constant = xsimd::make_batch_bool_constant<value_type, xsimd::test_detail::mask_suffix1, arch_type>();
+            constexpr auto interleaved_constant = xsimd::make_batch_bool_constant<value_type, xsimd::test_detail::mask_interleaved, arch_type>();
+
+            CHECK(zero_constant.is_empty());
+            CHECK_FALSE(zero_constant.is_full());
+            CHECK(full_constant.is_full());
+            CHECK_FALSE(full_constant.is_empty());
+
+            for (std::size_t i = 0; i < size; ++i)
+            {
+                CHECK_EQ(zero_constant.get(i), false);
+                CHECK_EQ(full_constant.get(i), true);
+                CHECK_EQ(prefix_constant.get(i), i == 0);
+                CHECK_EQ(suffix_constant.get(i), (i + 1) == size);
+                CHECK_EQ(interleaved_constant.get(i), (i % 2) == 0);
+            }
+        }
+
+        {
+            constexpr auto ends_constant = xsimd::make_batch_bool_constant<value_type, xsimd::test_detail::mask_ends, arch_type>();
+            bool_array_type converted {};
+            ends_constant.as_batch_bool().store_unaligned(converted.data());
+            for (std::size_t i = 0; i < size; ++i)
+            {
+                CHECK_EQ(converted[i], ends_constant.get(i));
+            }
+
+            batch_bool_type via_conversion = ends_constant;
+            via_conversion.store_unaligned(converted.data());
+            for (std::size_t i = 0; i < size; ++i)
+            {
+                CHECK_EQ(converted[i], ends_constant.get(i));
+            }
+        }
+
+        {
+            constexpr auto interleaved_constant = xsimd::make_batch_bool_constant<value_type, xsimd::test_detail::mask_interleaved, arch_type>();
+            constexpr std::size_t begin = 1;
+            constexpr std::size_t end = (size > 3 ? 3 : size);
+            constexpr std::size_t length = (end > begin) ? (end - begin) : 0;
+            using slice_arch = xsimd::test_detail::ct_mask_arch<value_type, length>;
+            constexpr auto slice = interleaved_constant.template splice<slice_arch, begin, end>();
+            for (std::size_t i = 0; i < length; ++i)
+            {
+                CHECK_EQ(slice.get(i), interleaved_constant.get(begin + i));
+            }
+
+            constexpr std::size_t mid = size / 2;
+            using lower_arch = xsimd::test_detail::ct_mask_arch<value_type, mid>;
+            using upper_arch = xsimd::test_detail::ct_mask_arch<value_type, size - mid>;
+            constexpr auto lower = interleaved_constant.template lower_half<lower_arch>();
+            constexpr auto upper = interleaved_constant.template upper_half<upper_arch>();
+            for (std::size_t i = 0; i < mid; ++i)
+            {
+                CHECK_EQ(lower.get(i), interleaved_constant.get(i));
+            }
+            for (std::size_t i = 0; i < (size - mid); ++i)
+            {
+                CHECK_EQ(upper.get(i), interleaved_constant.get(mid + i));
+            }
+        }
+
+        array_type numeric_values {};
+        numeric_constant_helper<value_type, arch_type, size>::fill(numeric_values);
+        if (std::is_integral<value_type>::value)
+        {
+            for (std::size_t i = 0; i < size; ++i)
+            {
+                CHECK_EQ(numeric_values[i], static_cast<value_type>(xsimd::test_detail::alternating_numeric<value_type>::get(i, size)));
+            }
+        }
     }
 
 private: