Implement Exponentiation via Associative Iteration

.gitignore

@@ -5,3 +5,5 @@
 test/.vscode
 build
 .cache
+.idea
+**cmake-build**

inc/zoo/meta/BitmaskMaker.h

@@ -42,6 +42,7 @@ struct BitmaskMaker {
 
 static_assert(0xF0F0 == BitmaskMaker<uint16_t, 0xF0, 8>::value);
 static_assert(0xEDFEDFED == BitmaskMaker<uint32_t, 0xFED, 12>::value);
+static_assert(0b0001'0001 == BitmaskMaker<unsigned char, 1, 4>::value);
 
 }} // zoo::meta
 

inc/zoo/swar/SWAR.h

@@ -5,6 +5,7 @@
 #include "zoo/meta/log.h"
 
 #include <type_traits>
+#include <initializer_list>
 
 #ifdef _MSC_VER
 #include <iso646.h>
@@ -70,6 +71,19 @@ struct SWAR {
 
     constexpr T value() const noexcept { return m_v; }
 
+   constexpr static T baseFromLaneLiterals(std::initializer_list<T> args) noexcept {
+       T result = 0;
+       for (auto arg: args) {
+           result = (result << NBits) | arg;
+       }
+       return result;
+   }
+
+   constexpr static SWAR fromLaneLiterals(std::initializer_list<T> args) noexcept {
+       return SWAR(baseFromLaneLiterals(args));
+   }
+
+
     #define SWAR_UNARY_OPERATORS_X_LIST \
         X(SWAR, ~)
     //constexpr SWAR operator~() const noexcept { return SWAR{~m_v}; }

inc/zoo/swar/associative_iteration.h

@@ -69,7 +69,7 @@ template<int NB, typename B>
 constexpr auto makeLaneMaskFromMSB(SWAR<NB, B> input) {
     using S = SWAR<NB, B>;
     auto msb = input & S{S::MostSignificantBit};
-    auto msbCopiedToLSB = S{msb.value() >> (NB - 1)};
+    auto msbCopiedToLSB = S{static_cast<B>(msb.value() >> (NB - 1))};
     return impl::makeLaneMaskFromMSB_and_LSB(msb, msbCopiedToLSB);
 }
 
@@ -191,8 +191,13 @@ template<
     typename CountHalver
 >
 constexpr auto associativeOperatorIterated_regressive(
-    Base base, Base neutral, IterationCount count, IterationCount forSquaring,
-    Operator op, unsigned log2Count, CountHalver ch
+    const Base base,
+    const Base neutral,
+    IterationCount count,
+    const IterationCount forSquaring,
+    const Operator op,
+    unsigned log2Count,
+    const CountHalver ch
 ) {
     auto result = neutral;
     if(!log2Count) { return result; }
@@ -205,6 +210,36 @@ constexpr auto associativeOperatorIterated_regressive(
     return result;
 }
 
+
+// What I don't understand is why this doesn't work?
+template <typename T>
+constexpr auto multiply(T a , T b) {
+    auto operation = [](auto left, auto right, auto count) {
+      if (count) {
+        return left + right;
+      } else {
+        return left;
+      }
+    };
+
+    auto updateCount = [](auto count) {
+      return count << 1;
+    };
+
+    constexpr auto numBits = sizeof(T) * 8;
+    return associativeOperatorIterated_regressive(
+        a,          // base
+        0,          // neutral
+        b,          // count
+        1,          // forSquaring, pretty sure this is where i am not understanding
+        operation,  // operation
+        numBits,    // log2Count
+        updateCount // halver
+    );
+}
+
+// static_assert(multiply(3, 4) == 12, "multiply failed");
+
 template<int ActualBits, int NB, typename T>
 constexpr auto multiplication_OverflowUnsafe_SpecificBitCount(
     SWAR<NB, T> multiplicand, SWAR<NB, T> multiplier
@@ -218,17 +253,54 @@ constexpr auto multiplication_OverflowUnsafe_SpecificBitCount(
 
     auto halver = [](auto counts) {
         auto msbCleared = counts & ~S{S::MostSignificantBit};
-        return S{msbCleared.value() << 1};
+        return S{static_cast<T>(msbCleared.value() << 1)};
     };
 
-    multiplier = S{multiplier.value() << (NB - ActualBits)};
+    multiplier = S{static_cast<T>(multiplier.value() << (NB - ActualBits))};
     return associativeOperatorIterated_regressive(
-        multiplicand, S{0}, multiplier, S{S::MostSignificantBit}, operation,
-        ActualBits, halver
+        multiplicand,
+        S{0},
+        multiplier,
+        S{S::MostSignificantBit},
+        operation,
+        ActualBits,
+        halver
     );
 }
 
-/// \note Not removed yet because it is an example of "progressive" associative exponentiation
+template<int ActualBits, int NB, typename T>
+constexpr auto exponentiation_OverflowUnsafe_SpecificBitCount(
+    SWAR<NB, T> x,
+    SWAR<NB, T> exponent
+) {
+    using S = SWAR<NB, T>;
+
+    auto operation = [](auto left, auto right, auto counts) {
+      const auto mask = makeLaneMaskFromMSB(counts);
+      const auto product =
+        multiplication_OverflowUnsafe_SpecificBitCount<ActualBits>(left, right);
+      return (product & mask) | (left & ~mask);
+    };
+
+    // halver should work same as multiplication... i think...
+    auto halver = [](auto counts) {
+        auto msbCleared = counts & ~S{S::MostSignificantBit};
+        return S{static_cast<T>(msbCleared.value() << 1)};
+    };
+
+    exponent = S{static_cast<T>(exponent.value() << (NB - ActualBits))};
+    return associativeOperatorIterated_regressive(
+        x,
+        S{meta::BitmaskMaker<T, 1, NB>().value}, // neutral is lane wise..
+        exponent,
+        S{S::MostSignificantBit},
+        operation,
+        ActualBits,
+        halver
+    );
+}
+
+// \note Not removed yet because it is an example of "progressive" associative exponentiation
 template<int ActualBits, int NB, typename T>
 constexpr auto multiplication_OverflowUnsafe_SpecificBitCount_deprecated(
     SWAR<NB, T> multiplicand,
@@ -261,6 +333,17 @@ constexpr auto multiplication_OverflowUnsafe(
         );
 }
 
+template<int NB, typename T>
+constexpr auto exponentiation_OverflowUnsafe(
+    SWAR<NB, T> base,
+    SWAR<NB, T> exponent
+) {
+    return
+       exponentiation_OverflowUnsafe_SpecificBitCount<NB>(
+            base, exponent
+        );
+}
+
 template<int NB, typename T>
 struct SWAR_Pair{
     SWAR<NB, T> even, odd;

test/swar/BasicOperations.cpp

@@ -41,6 +41,17 @@ static_assert(
     multiplication_OverflowUnsafe_SpecificBitCount<3>(Micand, Mplier).value()
 );
 
+static_assert(0b00000010000000110000010100000110 == 0x02'03'05'06);
+
+TEST_CASE("Jamie's totally working exponentiation :D") {
+    constexpr auto base     = SWAR<8, u32>::fromLaneLiterals({2, 3, 5, 6}); // {(2 << 24) + (3 << 16) + (5 << 8) + (6)};
+    constexpr auto exponent = SWAR<8, u32>::fromLaneLiterals({7, 0, 2, 3}); //   7 | 0 |  2 |   3
+    constexpr auto expected = SWAR<8, u32>::fromLaneLiterals({128, 1, 25, 216}); // 128 | 1 | 25 | 216
+    constexpr auto actual = exponentiation_OverflowUnsafe(base, exponent);
+    static_assert(expected.value() == actual.value());
+    CHECK(expected.value() == actual.value());
+}
+
 }
 
 #define HE(nbits, t, v0, v1) \