Skip to content

Commit

Permalink
Vec -> native_type
Browse files Browse the repository at this point in the history
  • Loading branch information
Dan Smith committed Feb 8, 2024
1 parent d291b9e commit 133cdf3
Show file tree
Hide file tree
Showing 4 changed files with 23 additions and 23 deletions.
26 changes: 13 additions & 13 deletions six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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<N, VecNt>; // e.g., Vec4ib
using native_type = details::Boolean_vector_class<N, VecNt>; // e.g., Vec4ib

static constexpr auto size = basic_simd<details::integer_from<Bytes>, Abi>::size;
static_assert(size == Vec::size());
static_assert(size == native_type::size());

constexpr basic_simd_mask() noexcept = default;

Expand All @@ -45,8 +45,8 @@ namespace simd
constexpr explicit basic_simd_mask(const basic_simd_mask<UBytes, UAbi>& other) noexcept : v_(other.v_) {}
template<typename G> 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
Expand All @@ -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<typename T, details::size_type N = basic_simd_mask<sizeof(T)>::size()>
Expand All @@ -67,10 +67,10 @@ namespace simd
using mask_type = basic_simd_mask<sizeof(T), Abi>;
using abi_type = Abi;

using Vec = typename details::VecNt<abi_type::N, T>::Vector_class; // e.g., Vec4i
using native_type = typename details::VecNt<abi_type::N, T>::Vector_class; // e.g., Vec4i

static constexpr std::integral_constant<details::size_type, Vec::size()> size = -1;
//static_assert(size() == Vec::size());
static constexpr std::integral_constant<details::size_type, native_type::size()> size = -1;
//static_assert(size() == native_type::size());

constexpr basic_simd() noexcept = default;

Expand All @@ -97,8 +97,8 @@ namespace simd
//constexpr basic_simd(It first, const mask_type& mask, simd_flags<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<typename It>
Expand Down Expand Up @@ -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<Vec_b>(c), static_cast<Vec>(a), static_cast<Vec>(b));
using Vec_b = typename mask_type::native_type;
return select(static_cast<Vec_b>(c), static_cast<native_type>(a), static_cast<native_type>(b));
}

//private:
Vec v_;
native_type v_;
};

template<typename T, details::size_type N = basic_simd<T>::size()>
Expand Down
4 changes: 2 additions & 2 deletions six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd_alg.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -34,14 +34,14 @@ namespace simd
template<size_t Bytes, typename Abi>
constexpr bool any_of(const basic_simd_mask<Bytes, Abi>& m) noexcept
{
using Vec_b = basic_simd_mask<Bytes, Abi>::Vec;
using Vec_b = basic_simd_mask<Bytes, Abi>::native_type;
return horizontal_or(static_cast<Vec_b>(m));
}

template<size_t Bytes, typename Abi>
constexpr bool all_of(const basic_simd_mask<Bytes, Abi>& m) noexcept
{
using Vec_b = basic_simd_mask<Bytes, Abi>::Vec;
using Vec_b = basic_simd_mask<Bytes, Abi>::native_type;
return horizontal_and(static_cast<Vec_b>(m));
}
}
Expand Down
10 changes: 5 additions & 5 deletions six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd_builtin.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -69,9 +69,9 @@ namespace simd

#define VECTORCLASS_basic_simd_binary(OPERATOR_) \
template<typename T, typename Abi> constexpr basic_simd<T, Abi> operator OPERATOR_(const basic_simd<T, Abi>& lhs, const basic_simd<T, Abi>& rhs) noexcept { \
using Vec = basic_simd<T, Abi>::Vec; return static_cast<Vec>(lhs) OPERATOR_ static_cast<Vec>(rhs); } \
using Vec = basic_simd<T, Abi>::native_type; return static_cast<Vec>(lhs) OPERATOR_ static_cast<Vec>(rhs); } \
template<typename T, typename Abi, typename U> constexpr basic_simd<T, Abi> operator OPERATOR_(const basic_simd<T, Abi>& lhs, const U& rhs) noexcept { \
using Vec = basic_simd<T, Abi>::Vec; return static_cast<Vec>(lhs) OPERATOR_ rhs; }
using Vec = basic_simd<T, Abi>::native_type; return static_cast<Vec>(lhs) OPERATOR_ rhs; }
VECTORCLASS_basic_simd_binary(+);
VECTORCLASS_basic_simd_binary(-);
VECTORCLASS_basic_simd_binary(*);
Expand Down Expand Up @@ -125,10 +125,10 @@ namespace simd

#define VECTORCLASS_basic_simd_comparison(OPERATOR_) \
template<typename T, typename Abi> constexpr basic_simd<T, Abi>::mask_type operator OPERATOR_(const basic_simd<T, Abi>& lhs, const basic_simd<T, Abi>& rhs) noexcept { \
using Vec = basic_simd<T, Abi>::Vec; \
using Vec = basic_simd<T, Abi>::native_type; \
return static_cast<Vec>(lhs) OPERATOR_ static_cast<Vec>(rhs); } \
template<typename T, typename Abi, typename U> constexpr basic_simd<T, Abi>::mask_type operator OPERATOR_(const basic_simd<T, Abi>& lhs, const U& rhs) noexcept { \
using Vec = basic_simd<T, Abi>::Vec; \
using Vec = basic_simd<T, Abi>::native_type; \
return static_cast<Vec>(lhs) OPERATOR_ rhs; }
VECTORCLASS_basic_simd_comparison(==);
VECTORCLASS_basic_simd_comparison(!=);
Expand All @@ -142,7 +142,7 @@ namespace simd
#define VECTORCLASS_basic_simd_mask_binary(OPERATOR_) \
template<size_t Bytes, typename Abi> constexpr basic_simd_mask<Bytes, Abi> \
operator OPERATOR_(const basic_simd_mask<Bytes, Abi>& lhs, const basic_simd_mask<Bytes, Abi>& rhs) noexcept { \
using Vec = basic_simd_mask<Bytes, Abi>::Vec; return static_cast<Vec>(lhs) OPERATOR_ static_cast<Vec>(rhs); }
using Vec = basic_simd_mask<Bytes, Abi>::native_type; return static_cast<Vec>(lhs) OPERATOR_ static_cast<Vec>(rhs); }
VECTORCLASS_basic_simd_mask_binary(&&);
VECTORCLASS_basic_simd_mask_binary(||);
VECTORCLASS_basic_simd_mask_binary(&);
Expand Down
6 changes: 3 additions & 3 deletions six/modules/c++/six.sicd/include/six/sicd/vectorclass/simd/simd_math.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -36,21 +36,21 @@ namespace simd
template<typename T, typename Abi>
inline basic_simd<T, Abi> round(const basic_simd<T, Abi>& v)
{
using Vec = basic_simd<T, Abi>::Vec;
using Vec = basic_simd<T, Abi>::native_type;
return round(static_cast<Vec>(v));
}

template<typename T, typename Abi>
inline basic_simd<int, Abi> lround(const basic_simd<T, Abi>& v)
{
using Vec = basic_simd<T, Abi>::Vec;
using Vec = basic_simd<T, Abi>::native_type;
return roundi(static_cast<Vec>(v));
}

template<typename T, typename Abi>
inline basic_simd<T, Abi> atan2(const basic_simd<T, Abi>& y, const basic_simd<T, Abi>& x)
{
using Vec = basic_simd<T, Abi>::Vec;
using Vec = basic_simd<T, Abi>::native_type;
return atan2(static_cast<Vec>(y), static_cast<Vec>(x));
}
}
Expand Down

0 comments on commit 133cdf3

Please sign in to comment.