Move self_logand to the logical_and callable

include/eve/arch/cpu/logical.hpp

@@ -10,6 +10,7 @@
 #include <eve/concept/vectorizable.hpp>
 #include <eve/detail/abi.hpp>
 #include <eve/traits/as_integer.hpp>
+#include <eve/traits/common_value.hpp>
 
 #include <bitset>
 #include <cstring>
@@ -87,35 +88,35 @@ namespace eve
     EVE_FORCEINLINE constexpr logical operator!() const noexcept { return {!value_}; }
 
     template<arithmetic_scalar_value U>
-    friend EVE_FORCEINLINE logical operator&&(logical const& v, logical<U> const& w) noexcept
+    friend EVE_FORCEINLINE common_logical_t<T, U> operator&&(logical const& v, logical<U> const& w) noexcept
     {
-      return logical{v.value() && w.value()};
+      return common_logical_t<T, U>{v.value() && w.value()};
     }
 
     friend EVE_FORCEINLINE logical operator&&(logical const& v, bool const& w) noexcept
     {
-      return logical{v.value() && w};
+      return w ? v : logical{false};
     }
 
     friend EVE_FORCEINLINE logical operator&&(bool const& v, logical const& w) noexcept
     {
-      return logical{v && w.value()};
+      return v ? w : logical{false};
     }
 
     template<arithmetic_scalar_value U>
-    friend EVE_FORCEINLINE logical operator||(logical const& v, logical<U> const& w) noexcept
+    friend EVE_FORCEINLINE common_logical_t<T, U> operator||(logical const& v, logical<U> const& w) noexcept
     {
-      return logical{v.value() || w.value()};
+      return common_logical_t<T, U>{v.value() || w.value()};
     }
 
     friend EVE_FORCEINLINE logical operator||(logical const& v, bool const& w) noexcept
     {
-      return logical{v.value() || w};
+      return w ? logical{true} : v;
     }
 
     friend EVE_FORCEINLINE logical operator||(bool const& v, logical const& w) noexcept
     {
-      return logical{v || w.value()};
+      return v ? logical{true} : w;
     }
 
     //==============================================================================================
@@ -139,9 +140,9 @@ namespace eve
     // Comparison operators
     //==============================================================================================
     template<scalar_value U>
-    friend EVE_FORCEINLINE logical operator==(logical const& v, logical<U> const& w) noexcept
+    friend EVE_FORCEINLINE common_logical_t<T, U> operator==(logical const& v, logical<U> const& w) noexcept
     {
-      return v.value() == w.value();
+      return common_logical_t<T, U>{v.value() == w.value()};
     }
 
     friend EVE_FORCEINLINE logical operator==(logical const& v, bool w) noexcept
@@ -155,9 +156,9 @@ namespace eve
     }
 
     template<scalar_value U>
-    friend EVE_FORCEINLINE logical operator!=(logical const& v, logical<U> const& w) noexcept
+    friend EVE_FORCEINLINE common_logical_t<T, U> operator!=(logical const& v, logical<U> const& w) noexcept
     {
-      return v.value() != w.value();
+      return common_logical_t<T, U>{v.value() != w.value()};
     }
 
     friend EVE_FORCEINLINE logical operator!=(logical const& v, bool w) noexcept

include/eve/arch/cpu/logical_wide.hpp

@@ -26,6 +26,8 @@
 #include <eve/detail/function/make.hpp>
 #include <eve/detail/function/slice.hpp>
 #include <eve/detail/function/subscript.hpp>
+#include <eve/module/core/regular/logical_and.hpp>
+#include <eve/module/core/regular/logical_or.hpp>
 
 #include <cstring>
 #include <concepts>
@@ -274,42 +276,46 @@ namespace eve
     //==============================================================================================
     //! Perform a logical and operation between two eve::logical
     template<typename U>
-    friend EVE_FORCEINLINE auto operator&&(logical const& v, logical<wide<U, Cardinal>> const& w) noexcept
+    friend EVE_FORCEINLINE common_logical_t<logical, logical<wide<U, Cardinal>>>
+    operator&&(logical const& a, logical<wide<U, Cardinal>> const& b) noexcept
     {
-      return detail::self_logand(eve::current_api,v,w);
+      return logical_and(a, b);
     }
 
     //! Perform a logical and operation between a eve::logical and a scalar
     template<scalar_value S>
-    friend EVE_FORCEINLINE auto operator&&(logical const& v, S w) noexcept
+    friend EVE_FORCEINLINE common_logical_t<logical, S> operator&&(logical const& w, S s) noexcept
     {
-      return v && logical{w};
+      return logical_and(w, s);
     }
 
     //! Perform a logical and operation between a scalar and a eve::logical
     template<scalar_value S>
-    friend EVE_FORCEINLINE auto operator&&(S v, logical const& w) noexcept
+    friend EVE_FORCEINLINE common_logical_t<S, logical> operator&&(S s, logical const& w) noexcept
     {
-      return w && v;
+      return logical_and(s, w);
     }
 
     //! Perform a logical or operation between two eve::logical
     template<typename U>
-    friend EVE_FORCEINLINE auto operator||(logical const& v, logical<wide<U, Cardinal>> const& w) noexcept
+    friend EVE_FORCEINLINE common_logical_t<logical, logical<wide<U, Cardinal>>>
+    operator||(logical const& a, logical<wide<U, Cardinal>> const& b) noexcept
     {
-      return detail::self_logor(eve::current_api,v,w);
+      return logical_or(a, b);
     }
 
     //! Perform a logical or operation between a eve::logical and a scalar
-    friend EVE_FORCEINLINE auto operator||(logical const& v, scalar_value auto w) noexcept
+    template<scalar_value S>
+    friend EVE_FORCEINLINE common_logical_t<logical, S> operator||(logical const& w, S s) noexcept
     {
-      return v || logical{w};
+      return logical_or(w, s);
     }
 
     //! Perform a logical or operation between a scalar and a eve::logical
-    friend EVE_FORCEINLINE auto operator||(scalar_value auto v, logical const& w) noexcept
+    template<scalar_value S>
+    friend EVE_FORCEINLINE common_logical_t<S, logical> operator||(S s, logical const& w) noexcept
     {
-      return w || v;
+      return logical_or(s, w);
     }
 
     //! Computes the logical complement of its parameter

include/eve/arch/cpu/wide.hpp

@@ -30,6 +30,8 @@
 #include <eve/module/core/regular/mul.hpp>
 #include <eve/module/core/regular/div.hpp>
 #include <eve/module/core/regular/minus.hpp>
+#include <eve/module/core/regular/shl.hpp>
+#include <eve/module/core/regular/shr.hpp>
 #include <eve/memory/soa_ptr.hpp>
 #include <eve/traits/product_type.hpp>
 

include/eve/concept/scalar.hpp

@@ -133,4 +133,22 @@ concept arithmetic_scalar_value = plain_scalar_value<T> || product_scalar_value<
 //================================================================================================
 template<typename T>
 concept scalar_value = arithmetic_scalar_value<T> || logical_scalar_value<T>;
+
+//================================================================================================
+//! @ingroup simd_concepts
+//! @{
+//! @concept relaxed_logical_scalar_value
+//! @brief The concept `relaxed_logical_scalar_value<T>` is satisfied if and only if T is a
+//! boolean value or satisfies the `eve::scalar_value` concept.
+//!
+//! @groupheader{Examples}
+//! - `eve::logical<char>`
+//! - `float`
+//! - `bool`
+//================================================================================================
+template <typename T>
+concept relaxed_logical_scalar_value = scalar_value<T> || std::same_as<T, bool>;
+//================================================================================================
+//! @}
+//================================================================================================
 }

include/eve/deps/kumi/tuple.hpp

@@ -707,18 +707,19 @@ namespace kumi
     requires(sizeof...(Ts) == sizeof...(Us) && _::piecewise_ordered<tuple, tuple<Us...>>)
     {
       auto res = get<0>(lhs) < get<0>(rhs);
+
       auto const order = [&]<typename Index>(Index i)
       {
         auto y_less_x_prev  = rhs[i]  < lhs[i];
         auto x_less_y       = lhs[index_t<Index::value+1>{}] < rhs[index_t<Index::value+1>{}];
-        res                 = res || (x_less_y && !y_less_x_prev);
+        return (x_less_y && !y_less_x_prev);
       };
-      [&]<std::size_t... I>(std::index_sequence<I...>)
+
+      return [&]<std::size_t... I>(std::index_sequence<I...>)
       {
-        (order(index_t<I>{}),...);
+        return (res || ... || order(index_t<I>{}));
       }
-      (std::make_index_sequence<sizeof...(Ts)-1>());
-      return res;
+      (std::make_index_sequence<sizeof...(Us)-1>());
     }
     template<typename... Us>
     KUMI_TRIVIAL friend constexpr auto operator<=(tuple const &lhs, tuple<Us...> const &rhs) noexcept

include/eve/detail/function/simd/arm/sve/friends.hpp

@@ -42,43 +42,6 @@ EVE_FORCEINLINE auto
 self_geq(wide<T, N> v, wide<T, N> w) noexcept -> as_logical_t<wide<T, N>>
 requires sve_abi<abi_t<T, N>> { return svcmpge(sve_true<T>(), v, w); }
 
-
-// ---------------------------------------------------------
-
-template<typename T, typename U, typename N>
-EVE_FORCEINLINE auto
-self_logand(sve_ const&, logical<wide<T,N>> v, logical<wide<U,N>> w) noexcept -> logical<wide<T, N>>
-requires(sve_abi<abi_t<T, N>> || sve_abi<abi_t<U, N>>)
-{
-  if constexpr(!is_aggregated_v<abi_t<T, N>>)
-  {
-    return svmov_z(v, convert(w, as<logical<T>>{}));
-  }
-  else
-  {
-    auto[lv,hv] = v.slice();
-    auto[lw,hw] = w.slice();
-    return logical<wide<T, N>>{ lv && lw, hv && hw};
-  }
-}
-
-template<typename T, typename U, typename N>
-EVE_FORCEINLINE auto
-self_logor(sve_ const&, logical<wide<T,N>> v, logical<wide<U,N>> w) noexcept -> logical<wide<T, N>>
-requires(sve_abi<abi_t<T, N>> || sve_abi<abi_t<U, N>>)
-{
-  if constexpr(!is_aggregated_v<abi_t<T, N>>)
-  {
-    return svorr_z(sve_true<T>(), v, convert(w, as<logical<T>>{}));
-  }
-  else
-  {
-    auto[lv,hv] = v.slice();
-    auto[lw,hw] = w.slice();
-    return logical<wide<T, N>>{ lv || lw, hv || hw};
-  }
-}
-
 template<arithmetic_scalar_value T, typename N>
 EVE_FORCEINLINE auto
 self_lognot(logical<wide<T, N>> v) noexcept -> logical<wide<T, N>>

include/eve/detail/function/simd/common/friends.hpp

@@ -16,6 +16,7 @@
 #include <eve/detail/function/bit_cast.hpp>
 #include <eve/detail/is_native.hpp>
 #include <eve/traits/product_type.hpp>
+#include <eve/as_element.hpp>
 #include <eve/forward.hpp>
 
 // Register tag here so we can use them in tagged_dispatch situation
@@ -50,64 +51,6 @@ namespace eve::detail
     }
   }
 
-  //================================================================================================
-  template<typename T, typename U, typename N>
-  EVE_FORCEINLINE auto self_logand(cpu_ const&, logical<wide<T,N>> v, logical<wide<U,N>> w) noexcept
-  {
-    using abi_t = typename logical<wide<T,N>>::abi_type;
-    using abi_u = typename logical<wide<U,N>>::abi_type;
-
-    // Both arguments are aggregated, we can safely slice
-    if constexpr( is_aggregated_v<abi_t> && is_aggregated_v<abi_u> )
-    {
-      auto [vl, vh] = v.slice();
-      auto [wl, wh] = w.slice();
-      return logical<wide<T,N>> { self_logand(eve::current_api,vl, wl)
-                                , self_logand(eve::current_api,vh, wh)
-                                };
-    }
-    else
-    {
-      if constexpr( !is_aggregated_v<abi_t> && !is_aggregated_v<abi_u> && (sizeof(T) == sizeof(U)) )
-      {
-        return bit_cast ( v.bits() & w.bits(), as(v) );
-      }
-      else
-      {
-        return self_logand(cpu_{}, v, convert(w, as<logical<T>>()));
-      }
-    }
-  }
-
-  //================================================================================================
-  template<typename T, typename U, typename N>
-  EVE_FORCEINLINE auto self_logor(cpu_ const&, logical<wide<T,N>> v, logical<wide<U,N>> w) noexcept
-  {
-    using abi_t = typename logical<wide<T,N>>::abi_type;
-    using abi_u = typename logical<wide<U,N>>::abi_type;
-
-    // Both arguments are aggregated, we can safely slice
-    if constexpr( is_aggregated_v<abi_t> && is_aggregated_v<abi_u> )
-    {
-      auto [vl, vh] = v.slice();
-      auto [wl, wh] = w.slice();
-      return logical<wide<T,N>> { self_logor(eve::current_api,vl, wl)
-                                , self_logor(eve::current_api,vh, wh)
-                                };
-    }
-    else
-    {
-      if constexpr( !is_aggregated_v<abi_t> && !is_aggregated_v<abi_u> && (sizeof(T) == sizeof(U)) )
-      {
-        return bit_cast ( v.bits() | w.bits(), as(v) );
-      }
-      else
-      {
-        return self_logor(cpu_{}, v, convert(w, as<logical<T>>()));
-      }
-    }
-  }
-
   //================================================================================================
   template<simd_value Wide>
   EVE_FORCEINLINE auto self_lognot(Wide const& v) noexcept
@@ -134,7 +77,7 @@ namespace eve::detail
     }
     else
     {
-      return v.storage() == w.storage();
+      return convert(v.storage() == w.storage(), as_element<as_logical_t<Wide>>());
     }
   }
 
@@ -172,7 +115,7 @@ namespace eve::detail
     }
     else
     {
-      return v.storage() != w.storage();
+      return convert(v.storage() != w.storage(), as_element<as_logical_t<Wide>>());
     }
   }
 
@@ -199,7 +142,7 @@ namespace eve::detail
   {
     if constexpr( product_type<Wide> )
     {
-      return kumi::to_tuple(v) < kumi::to_tuple(w);
+      return convert(kumi::to_tuple(v) < kumi::to_tuple(w), as_element<as_logical_t<Wide>>());
     }
     else
     {
@@ -213,7 +156,7 @@ namespace eve::detail
   {
     if constexpr( product_type<Wide> )
     {
-      return kumi::to_tuple(v) <= kumi::to_tuple(w);
+      return convert(kumi::to_tuple(v) <= kumi::to_tuple(w), as_element<as_logical_t<Wide>>());
     }
     else
     {
@@ -227,7 +170,7 @@ namespace eve::detail
   {
     if constexpr( product_type<Wide> )
     {
-      return kumi::to_tuple(v) > kumi::to_tuple(w);
+      return convert(kumi::to_tuple(v) > kumi::to_tuple(w), as_element<as_logical_t<Wide>>());
     }
     else
     {
@@ -241,7 +184,7 @@ namespace eve::detail
   {
     if constexpr( product_type<Wide> )
     {
-      return kumi::to_tuple(v) >= kumi::to_tuple(w);
+      return convert(kumi::to_tuple(v) >= kumi::to_tuple(w), as_element<as_logical_t<Wide>>());
     }
     else
     {