Implement Exponentiation via Associative Iteration

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);
 }
 
@@ -218,16 +218,69 @@ 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
     );
 }
 
+
+/*
+     // extended from mathematics to generic programming
+     // see https://github.com/jamierpond/fmtgp/blob/main/2_first_algo/main.cpp
+
+      template <typename T> constexpr T exp_acc(T r, T a, T n) {
+        for (;;) {
+          if (is_odd(n)) {
+            r = multiply(r, a);
+            if (n == 1) {
+              return r;
+            }
+          }
+          n = half(n);
+          a = multiply(a, a);
+        }
+      }
+*/
+
+template<int ActualBits, int NB, typename T>
+constexpr auto expo_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 antiMask = ~mask;
+      const auto product =
+        multiplication_OverflowUnsafe_SpecificBitCount<ActualBits>(left, right);
+      /*
+       * if (count)
+       *    return product;
+       * else
+       *    return left;
+       */
+      return (product & mask) | (left & antiMask);
+    };
+
+    // 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{1}, 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(
@@ -261,6 +314,17 @@ constexpr auto multiplication_OverflowUnsafe(
         );
 }
 
+template<int NB, typename T>
+constexpr auto expo_OverflowUnsafe(
+    SWAR<NB, T> base,
+    SWAR<NB, T> exponent
+) {
+    return
+       expo_OverflowUnsafe_SpecificBitCount<NB>(
+            base, exponent
+        );
+}
+
 template<int NB, typename T>
 struct SWAR_Pair{
     SWAR<NB, T> even, odd;

test/swar/BasicOperations.cpp

@@ -41,8 +41,24 @@ static_assert(
     multiplication_OverflowUnsafe_SpecificBitCount<3>(Micand, Mplier).value()
 );
 
+TEST_CASE("Jamie's wip expo") {
+    // the LSB lanes seem to be correct, but the MSB lanes are not...
+    constexpr auto base     = SWAR<8, u32>{0b0001'0011}; // 2 | 3
+    constexpr auto exponent = SWAR<8, u32>{0b0001'0010}; // 3 | 2
+    constexpr auto expected = SWAR<8, u32>{0b0001'1001}; // 8 | 9
+    // static_assert(
+    //     expected.value() == expo_OverflowUnsafe(base, exponent).value()
+    // );
+    auto actual = expo_OverflowUnsafe(base, exponent);
+    CHECK(expected.value() == actual.value());
+    auto expected_as_bits = std::bitset<32>(expected.value());
+    auto actual_as_bits = std::bitset<32>(actual.value());
+    printf("expected: %s\n", expected_as_bits.to_string().c_str());
+    printf("actual:   %s\n", actual_as_bits.to_string().c_str());
 }
 
+} // namespace Multiplication
+
 #define HE(nbits, t, v0, v1) \
     static_assert(horizontalEquality<nbits, t>(\
         SWAR<nbits, t>(v0),\