fix compilation random issues

jfalcou · Dec 10, 2023 · a543ec8 · a543ec8
1 parent 66a3507
commit a543ec8
Show file tree

Hide file tree

Showing 10 changed files with 32 additions and 26 deletions.
diff --git a/include/eve/detail/shuffle_v2/idxm.hpp b/include/eve/detail/shuffle_v2/idxm.hpp
@@ -285,8 +285,7 @@ most_repeated_pattern_impl()
 template<std::ptrdiff_t... I>
 constexpr auto most_repeated_pattern = most_repeated_pattern_impl<std::array {I...}>();
 
-template<auto arr>
-constexpr auto most_repeated_pattern_a = most_repeated_pattern_impl<arr>();
+template<auto arr> constexpr auto most_repeated_pattern_a = most_repeated_pattern_impl<arr>();
 
 template<std::size_t target, auto idxs>
 constexpr auto
@@ -321,7 +320,7 @@ template<std::size_t Times, std::size_t N>
 constexpr std::array<std::ptrdiff_t, Times * N>
 repeat(std::span<const std::ptrdiff_t, N> in)
 {
-  std::array<std::ptrdiff_t, Times *N> res = {};
+  std::array<std::ptrdiff_t, Times * N> res = {};
 
   const auto *f = in.data();
   const auto *l = in.data() + in.size();
@@ -687,7 +686,7 @@ template<std::ptrdiff_t G, std::size_t N>
 constexpr std::array<std::ptrdiff_t, N * G>
 expand_group(std::span<const std::ptrdiff_t, N> idxs)
 {
-  std::array<std::ptrdiff_t, N *G> res = {};
+  std::array<std::ptrdiff_t, N * G> res = {};
 
   std::ptrdiff_t *o = res.data();
 
@@ -876,16 +875,20 @@ template<std::size_t G, std::size_t N>
 constexpr auto
 put_bigger_groups_in_position(std::span<const std::ptrdiff_t, N> idxs)
 {
-  constexpr std::size_t group_count = (G == 0 || G >= N) ? 1 : N / G;
+  if constexpr( G == 0 || G > N )
+  {
+    return std::optional<
+        kumi::tuple<std::array<std::ptrdiff_t, 1>, std::array<std::ptrdiff_t, N>>> {};
+  }
+  else
+  {
+    constexpr std::size_t group_count = (G == 0 || G >= N) ? 1 : N / G;
 
-  using group_pattern_t   = std::array<std::ptrdiff_t, group_count>;
-  using withing_pattern_t = std::array<std::ptrdiff_t, N>;
+    using group_pattern_t   = std::array<std::ptrdiff_t, group_count>;
+    using withing_pattern_t = std::array<std::ptrdiff_t, N>;
 
-  std::optional<kumi::tuple<group_pattern_t, withing_pattern_t>> res;
+    std::optional<kumi::tuple<group_pattern_t, withing_pattern_t>> res;
 
-  if constexpr( G == 0 || G > N ) { return res; }
-  else
-  {
     group_pattern_t   groups_pattern        = {};
     withing_pattern_t within_groups_pattern = {};
 
@@ -914,7 +917,10 @@ put_bigger_groups_in_position(std::span<const std::ptrdiff_t, N> idxs)
       if( group_index < 0 )
       {
         groups_pattern[i] = we_;
-        for( std::size_t j = group_start; j != group_end; ++j ) { within_groups_pattern[j] = group_index; }
+        for( std::size_t j = group_start; j != group_end; ++j )
+        {
+          within_groups_pattern[j] = group_index;
+        }
         continue;
       }
 

diff --git a/include/eve/forward.hpp b/include/eve/forward.hpp
@@ -40,4 +40,10 @@ template<relative_conditional_expr C, simd_value T> auto to_logical(C c, eve::as
 
 template<relative_conditional_expr C, simd_value T>
 auto EVE_FORCEINLINE to_logical(C c, eve::as<T>) noexcept requires(current_api >= avx512);
+
+template<conditional_expr C, typename Op, typename Arg0, typename... Args>
+EVE_FORCEINLINE auto mask_op(C const&                     c,
+                             [[maybe_unused]] Op          f,
+                             [[maybe_unused]] Arg0 const& a0,
+                             [[maybe_unused]] Args const&...as);
 }
diff --git a/include/eve/module/core/constant/simd/common/iota.hpp b/include/eve/module/core/constant/simd/common/iota.hpp
@@ -10,6 +10,7 @@
 #include <eve/concept/value.hpp>
 #include <eve/detail/abi.hpp>
 #include <eve/forward.hpp>
+#include <eve/module/core/constant/zero.hpp>
 
 namespace eve::detail
 {
@@ -23,12 +24,6 @@ iota_(EVE_REQUIRES(cpu_), eve::callable_options auto const& opts, eve::as<T> tgt
 
   if constexpr( C::is_complete && C::is_inverted ) return T {[](int i, int) { return i; }};
   else if constexpr( !C::has_alternative ) return iota[cx.else_(eve::zero(tgt))](tgt);
-  else if constexpr( C::is_complete && !C::is_inverted ) return T {cx.alternative};
-  else
-  {
-    T x = iota(tgt);
-    if constexpr( !C::is_complete ) x = eve::if_else(cx, x, cx.alternative);
-    return x;
-  }
+  else return mask_op(cx, iota, tgt);
 }
 }
diff --git a/include/eve/module/core/regular/impl/bit_flip.hpp b/include/eve/module/core/regular/impl/bit_flip.hpp
@@ -21,7 +21,7 @@ namespace eve::detail
   EVE_FORCEINLINE T
   bit_flip_(EVE_SUPPORTS(cpu_), T a, I i) noexcept
   {
-    [[maybe_unused]] constexpr size_t S8 = sizeof(element_type_t<T>)*8;
+    [[maybe_unused]] constexpr std::ptrdiff_t S8 = sizeof(element_type_t<T>)*8;
     EVE_ASSERT(eve::all(i >= 0 && i < S8), "some index elements are out or range");
     return bit_xor(a, bit_shl(one(as(a)), i));
   }

diff --git a/include/eve/module/core/regular/impl/bit_set.hpp b/include/eve/module/core/regular/impl/bit_set.hpp
@@ -21,7 +21,7 @@ namespace eve::detail
   EVE_FORCEINLINE T
   bit_set_(EVE_SUPPORTS(cpu_), T a, I i) noexcept
   {
-    [[maybe_unused]] constexpr size_t S8 = sizeof(element_type_t<T>)*8;
+    [[maybe_unused]] constexpr std::ptrdiff_t S8 = sizeof(element_type_t<T>)*8;
     EVE_ASSERT(eve::all(i >= 0 && i < S8), "indexis out or range");
     return bit_or(a, bit_shl(one(as(a)), i));
   }

diff --git a/include/eve/module/core/regular/impl/bit_swap_pairs.hpp b/include/eve/module/core/regular/impl/bit_swap_pairs.hpp
@@ -21,7 +21,7 @@ namespace eve::detail
   EVE_FORCEINLINE T
   bit_swap_pairs_(EVE_SUPPORTS(cpu_), T a, I0 i0,  I1 i1) noexcept
   {
-    [[maybe_unused]] constexpr size_t S8 = sizeof(element_type_t<T>)*8;
+    [[maybe_unused]] constexpr std::ptrdiff_t S8 = sizeof(element_type_t<T>)*8;
     EVE_ASSERT(eve::all(i0 < S8 && i1 < S8), "some indexes are out or range");
     auto x = bit_and(bit_xor(bit_shr(a, i0), bit_shr(a, i1)), one(as(a)));
     a ^= bit_shl(x, i1);

diff --git a/include/eve/module/core/regular/impl/bit_unset.hpp b/include/eve/module/core/regular/impl/bit_unset.hpp
@@ -20,7 +20,7 @@ namespace eve::detail
   EVE_FORCEINLINE T
   bit_unset_(EVE_SUPPORTS(cpu_), T a, I i) noexcept
   {
-    [[maybe_unused]] constexpr size_t S8 = sizeof(element_type_t<T>)*8;
+    [[maybe_unused]] constexpr std::ptrdiff_t S8 = sizeof(element_type_t<T>)*8;
     EVE_ASSERT(eve::all(i >= 0 && i < S8), "some index elements are out or range");
     return bit_andnot(a, bit_shl(one(as(a)), i));
   }

diff --git a/include/eve/traits/overload/default_behaviors.hpp b/include/eve/traits/overload/default_behaviors.hpp
@@ -9,7 +9,6 @@
 
 #include <eve/concept/value.hpp>
 #include <eve/detail/skeleton.hpp>
-#include <eve/detail/function/conditional.hpp>
 
 namespace eve
 {

diff --git a/test/doc/core/regular/bit_reverse.cpp b/test/doc/core/regular/bit_reverse.cpp
@@ -1,4 +1,4 @@
-#include <eve/wide.hpp>
+#include <eve/module/core.hpp>
 #include <iostream>
 #include <bit>
 

diff --git a/test/doc/core/regular/byte_reverse.cpp b/test/doc/core/regular/byte_reverse.cpp
@@ -1,4 +1,4 @@
-#include <eve/wide.hpp>
+#include <eve/module/core.hpp>
 #include <iostream>
 
 using wide_it = eve::wide<std::uint32_t, eve::fixed<4>>;