From 133cdf3eb85ea8efb751418f0577e6018ad38318 Mon Sep 17 00:00:00 2001 From: Dan Smith Date: Thu, 8 Feb 2024 10:00:04 -0500 Subject: [PATCH] Vec -> native_type --- .../include/six/sicd/vectorclass/simd/simd.h | 26 +++++++++---------- .../six/sicd/vectorclass/simd/simd_alg.h | 4 +-- .../six/sicd/vectorclass/simd/simd_builtin.h | 10 +++---- .../six/sicd/vectorclass/simd/simd_math.h | 6 ++--- 4 files changed, 23 insertions(+), 23 deletions(-) diff --git a/six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd.h b/six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd.h index 5d9b2f52d..ac6ad9c1f 100644 --- a/six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd.h +++ b/six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd.h @@ -32,10 +32,10 @@ namespace simd using abi_type = Abi; static constexpr auto N = abi_type::N; using VecNt = typename abi_type::type; // e.g., Vec4i - using Vec = details::Boolean_vector_class; // e.g., Vec4ib + using native_type = details::Boolean_vector_class; // e.g., Vec4ib static constexpr auto size = basic_simd, Abi>::size; - static_assert(size == Vec::size()); + static_assert(size == native_type::size()); constexpr basic_simd_mask() noexcept = default; @@ -45,8 +45,8 @@ namespace simd constexpr explicit basic_simd_mask(const basic_simd_mask& other) noexcept : v_(other.v_) {} template constexpr explicit basic_simd_mask(G&& gen, std::nullptr_t /*TODO: remove*/) noexcept; // "Implementations should enable explicit conversion from and to implementation-defined types." - constexpr explicit operator Vec() const { return v_; } - constexpr explicit basic_simd_mask(const Vec& init) : v_(init) {} + constexpr explicit operator native_type() const { return v_; } + constexpr explicit basic_simd_mask(const native_type& init) : v_(init) {} // [simd.subscr] // §2.5 of https://github.com/vectorclass/manual/raw/master/vcl_manual.pdf @@ -55,7 +55,7 @@ namespace simd constexpr value_type operator[](details::size_type i) const& { return v_[i]; } private: - Vec v_; + native_type v_; }; template::size()> @@ -67,10 +67,10 @@ namespace simd using mask_type = basic_simd_mask; using abi_type = Abi; - using Vec = typename details::VecNt::Vector_class; // e.g., Vec4i + using native_type = typename details::VecNt::Vector_class; // e.g., Vec4i - static constexpr std::integral_constant size = -1; - //static_assert(size() == Vec::size()); + static constexpr std::integral_constant size = -1; + //static_assert(size() == native_type::size()); constexpr basic_simd() noexcept = default; @@ -97,8 +97,8 @@ namespace simd //constexpr basic_simd(It first, const mask_type& mask, simd_flags = {}); // "Implementations should enable explicit conversion from and to implementation-defined types." - constexpr explicit operator Vec() const { return v_; } - constexpr explicit basic_simd(const Vec& init) : v_(init) {} + constexpr explicit operator native_type() const { return v_; } + constexpr explicit basic_simd(const native_type& init) : v_(init) {} // [simd.copy] template @@ -148,12 +148,12 @@ namespace simd friend constexpr basic_simd simd_select_impl( const mask_type& c, const basic_simd& a, const basic_simd& b) noexcept { - using Vec_b = typename mask_type::Vec; - return select(static_cast(c), static_cast(a), static_cast(b)); + using Vec_b = typename mask_type::native_type; + return select(static_cast(c), static_cast(a), static_cast(b)); } //private: - Vec v_; + native_type v_; }; template::size()> diff --git a/six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd_alg.h b/six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd_alg.h index b8cc5e431..a837fee6a 100644 --- a/six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd_alg.h +++ b/six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd_alg.h @@ -34,14 +34,14 @@ namespace simd template constexpr bool any_of(const basic_simd_mask& m) noexcept { - using Vec_b = basic_simd_mask::Vec; + using Vec_b = basic_simd_mask::native_type; return horizontal_or(static_cast(m)); } template constexpr bool all_of(const basic_simd_mask& m) noexcept { - using Vec_b = basic_simd_mask::Vec; + using Vec_b = basic_simd_mask::native_type; return horizontal_and(static_cast(m)); } } diff --git a/six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd_builtin.h b/six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd_builtin.h index 7e12ba257..893810bd1 100644 --- a/six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd_builtin.h +++ b/six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd_builtin.h @@ -69,9 +69,9 @@ namespace simd #define VECTORCLASS_basic_simd_binary(OPERATOR_) \ template constexpr basic_simd operator OPERATOR_(const basic_simd& lhs, const basic_simd& rhs) noexcept { \ - using Vec = basic_simd::Vec; return static_cast(lhs) OPERATOR_ static_cast(rhs); } \ + using Vec = basic_simd::native_type; return static_cast(lhs) OPERATOR_ static_cast(rhs); } \ template constexpr basic_simd operator OPERATOR_(const basic_simd& lhs, const U& rhs) noexcept { \ - using Vec = basic_simd::Vec; return static_cast(lhs) OPERATOR_ rhs; } + using Vec = basic_simd::native_type; return static_cast(lhs) OPERATOR_ rhs; } VECTORCLASS_basic_simd_binary(+); VECTORCLASS_basic_simd_binary(-); VECTORCLASS_basic_simd_binary(*); @@ -125,10 +125,10 @@ namespace simd #define VECTORCLASS_basic_simd_comparison(OPERATOR_) \ template constexpr basic_simd::mask_type operator OPERATOR_(const basic_simd& lhs, const basic_simd& rhs) noexcept { \ - using Vec = basic_simd::Vec; \ + using Vec = basic_simd::native_type; \ return static_cast(lhs) OPERATOR_ static_cast(rhs); } \ template constexpr basic_simd::mask_type operator OPERATOR_(const basic_simd& lhs, const U& rhs) noexcept { \ - using Vec = basic_simd::Vec; \ + using Vec = basic_simd::native_type; \ return static_cast(lhs) OPERATOR_ rhs; } VECTORCLASS_basic_simd_comparison(==); VECTORCLASS_basic_simd_comparison(!=); @@ -142,7 +142,7 @@ namespace simd #define VECTORCLASS_basic_simd_mask_binary(OPERATOR_) \ template constexpr basic_simd_mask \ operator OPERATOR_(const basic_simd_mask& lhs, const basic_simd_mask& rhs) noexcept { \ - using Vec = basic_simd_mask::Vec; return static_cast(lhs) OPERATOR_ static_cast(rhs); } + using Vec = basic_simd_mask::native_type; return static_cast(lhs) OPERATOR_ static_cast(rhs); } VECTORCLASS_basic_simd_mask_binary(&&); VECTORCLASS_basic_simd_mask_binary(||); VECTORCLASS_basic_simd_mask_binary(&); diff --git a/six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd_math.h b/six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd_math.h index 31b64a0f7..7fcb64110 100644 --- a/six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd_math.h +++ b/six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd_math.h @@ -36,21 +36,21 @@ namespace simd template inline basic_simd round(const basic_simd& v) { - using Vec = basic_simd::Vec; + using Vec = basic_simd::native_type; return round(static_cast(v)); } template inline basic_simd lround(const basic_simd& v) { - using Vec = basic_simd::Vec; + using Vec = basic_simd::native_type; return roundi(static_cast(v)); } template inline basic_simd atan2(const basic_simd& y, const basic_simd& x) { - using Vec = basic_simd::Vec; + using Vec = basic_simd::native_type; return atan2(static_cast(y), static_cast(x)); } }