Implement lane-wise modulo.

inc/zoo/meta/BitmaskMaker.h

@@ -43,6 +43,8 @@ struct BitmaskMaker {
 static_assert(0xF0F0 == BitmaskMaker<uint16_t, 0xF0, 8>::value);
 static_assert(0xEDFEDFED == BitmaskMaker<uint32_t, 0xFED, 12>::value);
 
+
+
 }} // zoo::meta
 
 #endif

inc/zoo/swar/SWAR.h

@@ -4,6 +4,7 @@
 
 #include "zoo/meta/log.h"
 
+#include <array>
 #include <type_traits>
 
 #ifdef _MSC_VER
@@ -12,6 +13,16 @@
 
 namespace zoo { namespace swar {
 
+template <int NBits, typename T>
+struct SWAR;
+
+template <int NumBits, typename BaseType> struct Literals_t {
+    constexpr static void (SWAR<NumBits, BaseType>::*value)() = nullptr;
+};
+
+template <int NumBits, typename BaseType>
+constexpr Literals_t<NumBits, BaseType> Literals{};
+
 using u64 = uint64_t;
 using u32 = uint32_t;
 using u16 = uint16_t;
@@ -52,6 +63,7 @@ constexpr std::make_unsigned_t<T> lsbIndex(T v) noexcept {
 template<int NBits_, typename T = uint64_t>
 struct SWAR {
     using type = std::make_unsigned_t<T>;
+    constexpr static auto Literal = Literals<NBits_, T>;
     constexpr static inline type
         NBits = NBits_,
         BitWidth = sizeof(T) * 8,
@@ -62,13 +74,53 @@ struct SWAR {
         AllOnes = ~std::make_unsigned_t<T>{0} >> PaddingBitsCount, // Also constructed in RobinHood utils: possible bug?
         LeastSignificantBit = meta::BitmaskMaker<T, std::make_unsigned_t<T>{1}, NBits>::value,
         MostSignificantBit = LeastSignificantBit << (NBits - 1),
-        LeastSignificantLaneMask =
-            sizeof(T) * 8 == NBits ? // needed to avoid shifting all bits
-                ~T(0) :
-                ~(~T(0) << NBits),
+        LeastSignificantLaneMask = []() {
+            if constexpr (NBits < sizeof(T) * 8) {
+                return (T(1) << NBits) - 1;
+            } else {
+                return ~T(0);
+            }
+        }(),
         // Use LowerBits in favor of ~MostSignificantBit to not pollute
         // "don't care" bits when non-power-of-two bit lane sizes are supported
-        LowerBits = MostSignificantBit - LeastSignificantBit;
+        LowerBits = MostSignificantBit - LeastSignificantBit,
+        MaxUnsignedLaneValue = LeastSignificantLaneMask;
+
+    template <typename InputIt>
+    constexpr static auto from_range(InputIt first, InputIt last) noexcept {
+        auto result = T{0};
+        for (; first != last; ++first) {
+            result = (result << NBits) | *first;
+        }
+        return result;
+    }
+
+    template <typename U>
+    constexpr static auto from_array(const U (&values)[Lanes]) noexcept {
+        using std::begin; using std::end;
+        return SWAR{from_range(begin(values), end(values))};
+    }
+
+    template <typename U>
+    constexpr static auto from_array(const std::array<T, Lanes> &values) noexcept {
+        using std::begin; using std::end;
+        return SWAR{from_range(begin(values), end(values))};
+    }
+
+    constexpr SWAR(const std::array<T, Lanes> &array) : m_v{from_range(array.begin(), array.end())} {}
+
+    template <typename Arg, std::size_t N, typename = std::enable_if_t<N == Lanes, int>>
+    constexpr
+    SWAR(Literals_t<NBits, T>, const Arg (&values)[N]) : m_v{from_array(values)} {}
+
+    constexpr std::array<T, Lanes> to_array() const noexcept {
+        std::array<T, Lanes> result = {};
+        for (int i = 0; i < Lanes; ++i) {
+            auto otherEnd = Lanes - i - 1;
+            result[otherEnd] = at(i);
+        }
+        return result;
+    }
 
     SWAR() = default;
     constexpr explicit SWAR(T v): m_v(v) {}
@@ -161,6 +213,12 @@ struct SWAR {
     T m_v;
 };
 
+template <int NBits, typename T, typename Arg>
+SWAR(Literals_t<NBits, T>, const Arg (&values)[SWAR<NBits, T>::Lanes]) -> SWAR<NBits, T>;
+
+template <int NBits, typename T>
+SWAR(Literals_t<NBits, T>, const std::array<T, SWAR<NBits, T>::Lanes>&) -> SWAR<NBits, T>;
+
 /// Defining operator== on base SWAR types is entirely too error prone. Force a verbose invocation.
 template<int NBits, typename T = uint64_t>
 constexpr auto horizontalEquality(SWAR<NBits, T> left, SWAR<NBits, T> right) {
@@ -231,6 +289,10 @@ template<int NBits, typename T>
 struct BooleanSWAR: SWAR<NBits, T> {
     using Base = SWAR<NBits, T>;
 
+    template <std::size_t N>
+    constexpr BooleanSWAR(Literals_t<NBits, T>, const bool (&values)[N])
+    : Base(Literals<NBits, T>, values) { this->m_v <<= (NBits - 1); }
+
     // Booleanness is stored in the MSBs
     static constexpr auto MaskMSB =
         broadcast<NBits, T>(Base(T(1) << (NBits -1)));
@@ -240,7 +302,7 @@ struct BooleanSWAR: SWAR<NBits, T> {
     static constexpr auto MaskNonLSB = ~MaskLSB;
     static constexpr auto MaskNonMSB = ~MaskMSB;
     constexpr explicit BooleanSWAR(T v): Base(v) {}
-  
+
     constexpr BooleanSWAR clear(int bit) const noexcept {
         constexpr auto Bit = T(1) << (NBits - 1);
         return this->m_v ^ (Bit << (NBits * bit)); }
@@ -256,7 +318,7 @@ struct BooleanSWAR: SWAR<NBits, T> {
     constexpr auto operator ~() const noexcept {
         return BooleanSWAR(Base{Base::MostSignificantBit} ^ *this);
     }
-  
+
     constexpr auto operator not() const noexcept {
         return BooleanSWAR(MaskMSB ^ *this);
     }
@@ -305,6 +367,12 @@ struct BooleanSWAR: SWAR<NBits, T> {
     convertToBooleanSWAR(SWAR<NB, TT> arg) noexcept;
 };
 
+template <int NBits, typename T>
+BooleanSWAR(
+    Literals_t<NBits, T>,
+    const bool (&values)[BooleanSWAR<NBits, T>::Lanes])
+  -> BooleanSWAR<NBits, T>;
+
 template<int NBits, typename T>
 constexpr BooleanSWAR<NBits, T>
 convertToBooleanSWAR(SWAR<NBits, T> arg) noexcept {
@@ -381,7 +449,7 @@ greaterEqual(SWAR<NBits, T> left, SWAR<NBits, T> right) noexcept {
     using S = swar::SWAR<NBits, T>;
     const auto h = S::MostSignificantBit, x = left.value(), y = right.value();  // x=left, y= right is x < y
     const auto z = (x|h) - (y&~h);
-    // bitwise ternary median! 
+    // bitwise ternary median!
     const auto t = h & ~median(x, ~y, z);
     return ~BooleanSWAR<NBits, T>{static_cast<T>(t)};  // ~(x<y) === x >= y
 }

inc/zoo/swar/math.h

@@ -0,0 +1,64 @@
+#pragma once
+#include "SWAR.h"
+
+namespace zoo::math {
+
+template <typename IntegerType = size_t>
+constexpr static
+std::enable_if_t<std::is_integral_v<IntegerType>, bool>
+isPowerOfTwo(IntegerType x) noexcept {
+    return x && (x & (x - 1)) == 0;
+}
+
+template <typename IntegerType = size_t, IntegerType X>
+constexpr static
+std::enable_if_t<std::is_integral_v<IntegerType>, bool>
+isPowerOfTwo() noexcept {
+    return isPowerOfTwo(X);
+}
+
+
+template <size_t N, typename IntegerType = size_t>
+constexpr static
+std::enable_if_t<
+    std::is_integral_v<IntegerType> &&
+    isPowerOfTwo<size_t, N>(), size_t>
+moduloPowerOfTwo(IntegerType x) noexcept {
+    return x & (N - 1);
+}
+
+}
+
+namespace zoo::swar {
+template <typename S>
+constexpr static auto subtractOneUnsafe(S x) noexcept {
+    constexpr auto Ones = S::LeastSignificantBit;
+    auto x_minus_1 = S{x.value() - Ones};
+    return x_minus_1;
+}
+// todo subtract K unsafe using BitmaskMaker
+// todo subtract K "saturated" using BitmaskMaker
+
+template <typename S>
+constexpr static auto isPowerOfTwo(S x) noexcept {
+    constexpr auto NBits = S::NBits;
+    using T = typename S::type;
+    auto greater_than_0 = greaterEqual(x, S{0});
+    auto x_minus_1 = subtractOneUnsafe(x);
+    auto zero = equals(S{x_minus_1.value() & x.value()}, S{0});
+    return greater_than_0 & zero;
+}
+
+template <size_t N, typename S>
+constexpr static
+std::enable_if_t<zoo::math::isPowerOfTwo<size_t, N>(), S>
+moduloPowerOfTwo(const S x) noexcept {
+    constexpr auto N_minus_1 = N - 1;
+    constexpr auto N_in_lanes = zoo::meta::BitmaskMaker<typename S::type, N_minus_1, S::NBits>::value;
+    auto y = x.value() & N_in_lanes;
+    return S{y};
+}
+
+
+} // namespace zoo::swar
+

test/CMakeLists.txt

@@ -122,7 +122,7 @@ else()
     set(
         ZOO_TEST_SOURCES
         ${CATCH2_MAIN_SOURCE} ${TYPE_ERASURE_SOURCES} ${ALGORITHM_SOURCES}
-        ${SWAR_SOURCES} 
+        ${SWAR_SOURCES}
         ${MISCELLANEA_SOURCES}
     )