11#include <xvec/detail/config.hpp>
20#include <xvec/detail/utilities.hpp>
21#include <xvec/detail/core.hpp>
23namespace _XVEC_NAMESPACE::simd::detail
27template<vec_or_mask_type _Vp,
typename _Op>
29 auto t = value.to_builtin();
33#if __clang_major__ > 14
35 [[clang::always_inline]] r = op(t);
42 else return _Vp::from_builtin(r);
51template<vec_or_mask_type _Vp,
typename _Op>
53 auto lhsd = lhs.to_builtin();
54 auto rhsd = rhs.to_builtin();
55 decltype(op(lhsd, rhsd)) r;
58#if __clang_major__ > 14
60 [[clang::always_inline]] r = op(lhsd, rhsd);
66 if constexpr (
mask_operator<_Op>)
return _Vp::mask_type::from_builtin(
typename _Vp::mask_type::builtin_type(r));
67 else return _Vp::from_builtin(r);
73template<vec_
integral _Vp,
typename _Op>
74requires (any_same_v<_Op, std::divides<>, std::modulus<>>)
76 {
return _Vp([=](
auto i) ->
typename _Vp::value_type {
return _Op{}(lhs[i], rhs[i]); }); }
79template<vec_complex _Vp>
81 {
return fma(lhs, rhs, _Vp{});}
85template<vec_type _Vp, mask_operator _Op>
87 {
return typename _Vp::mask_type{[=](
auto i) ->
bool {
return _Op{}(x[i], y[i]); }}; }
92template<vec_complex _Vp, mask_operator _Op>
93constexpr typename _Vp::mask_type builtin_operator(
generic_tag, _Vp lhs, _Vp rhs, _Op) {
94 using _Tp =
typename _Vp::value_type::value_type;
96 static_assert(
sizeof(_Tp) <= 8,
"Can't deal with 128-bit elements like complex<double> yet");
98 using binop_type = std::remove_cvref_t<_Op>;
99 constexpr bool isEqualOp = std::is_same_v<binop_type, std::equal_to<>>;
100 constexpr bool isNotEqualOp = std::is_same_v<binop_type, std::not_equal_to<>>;
101 static_assert(isEqualOp || isNotEqualOp,
"Complex values only allow equality comparisons");
104 const auto compareElements = _Op{}(simd_bit_cast<_Tp>(lhs), simd_bit_cast<_Tp>(rhs));
107 const auto cmplxMask = simd_bit_cast<container_for_type<typename _Vp::value_type>>(-compareElements);
110 if constexpr (isEqualOp)
111 return typename _Vp::mask_type(cmplxMask == cw<-1>);
113 return typename _Vp::mask_type(cmplxMask != cw<0>);
120template<
typename FN, vec_type _Vp,
typename... Args>
121 requires (std::same_as<Args, _Vp> && ...)
123 using _UnsignedMask =
typename _Vp::mask_type::traits::unsigned_vec_for_mask;
124 using _ME =
typename _UnsignedMask::value_type;
125 auto m = _UnsignedMask{[=](
auto i) -> _ME {
126 return FN{}(first[i], (args[i])...) ? ~_ME() : _ME();
128 return typename _Vp::mask_type(m != _UnsignedMask());
136constexpr auto do_operator(
const _Vp& first,
const _Vps&... rest)
noexcept {
138 using _Rp = std::conditional_t<mask_operator<FN>,
typename _Vp::mask_type, _Vp>;
140 if (std::is_constant_evaluated())
142 return _Rp{[=](
auto i) {
return typename _Rp::value_type(FN{}(first[i], rest[i]...)); }};
146 else if constexpr (
requires { {simd_operator(first, rest..., FN{})}; })
149 return simd_operator(first, rest..., FN{});
158 return _Rp{[=](
auto i) {
return static_cast<typename _Vp::value_type
>(FN{}(first[i], rest[i]...)); }};
162template<vec_type _To, vec_type _From>
164 using _Tp =
typename _To::value_type;
166 return _To::from_builtin(__builtin_convertvector(v.to_builtin(),
typename _To::builtin_type));
167 else if constexpr (
requires {
168 { simd_convert(v, _XVEC_NAMESPACE::simd::convert_to<_Tp>) } -> std::convertible_to<_To>;
170 return simd_convert(v, _XVEC_NAMESPACE::simd::convert_to<_Tp>);
172 return _To([=](
auto i) {
return static_cast<_Tp
>(v[i]); });
constexpr auto do_operator(const _Vp &first, const _Vps &... rest) noexcept
Definition operators.hpp:136
constexpr auto builtin_operator(generic_tag, _Vp value, _Op op)
General purpose unary operator. Passes through to the compiler's own builtin.
Definition operators.hpp:28
constexpr auto make_mask_from_op(const _Vp &first, const Args &... args) noexcept
Definition operators.hpp:122
constexpr _To convert_operator(const _From &v) noexcept
Conversion operator for basic_vec. All gate-keeping has been done, just do the convert.
Definition operators.hpp:163
Definition target_config.hpp:161
Definition target_config.hpp:23