Skip to content

Commit 6b140ea

Browse files
serge-sans-pailleserge-sans-paille
committed
Move to C++14: use std::index_sequence and cie
1 parent a7f0344 commit 6b140ea

File tree

11 files changed

+87
-146
lines changed

11 files changed

+87
-146
lines changed

‎include/xsimd/arch/common/xsimd_common_math.hpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -613,15 +613,15 @@ namespace xsimd
613613
}
614614

615615
template <size_t... Is, class Tuple>
616-
XSIMD_INLINE B eval(::xsimd::detail::index_sequence<Is...>, const Tuple& tuple)
616+
XSIMD_INLINE B eval(std::index_sequence<Is...>, const Tuple& tuple)
617617
{
618618
return estrin { x * x }(std::get<Is>(tuple)...);
619619
}
620620

621621
template <class... Args>
622622
XSIMD_INLINE B eval(const std::tuple<Args...>& tuple) noexcept
623623
{
624-
return eval(::xsimd::detail::make_index_sequence<sizeof...(Args)>(), tuple);
624+
return eval(std::make_index_sequence<sizeof...(Args)>(), tuple);
625625
}
626626

627627
template <class... Args>

‎include/xsimd/arch/common/xsimd_common_memory.hpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -63,7 +63,7 @@ namespace xsimd
6363
namespace detail
6464
{
6565
template <class IT, class A, class I, size_t... Is>
66-
XSIMD_INLINE batch<IT, A> create_compress_swizzle_mask(I bitmask, ::xsimd::detail::index_sequence<Is...>)
66+
XSIMD_INLINE batch<IT, A> create_compress_swizzle_mask(I bitmask, std::index_sequence<Is...>)
6767
{
6868
batch<IT, A> swizzle_mask(IT(0));
6969
alignas(A::alignment()) IT mask_buffer[batch<IT, A>::size] = { Is... };
@@ -84,7 +84,7 @@ namespace xsimd
8484
constexpr std::size_t size = batch_bool<T, A>::size;
8585
auto bitmask = mask.mask();
8686
auto z = select(mask, x, batch<T, A>((T)0));
87-
auto compress_mask = detail::create_compress_swizzle_mask<IT, A>(bitmask, ::xsimd::detail::make_index_sequence<size>());
87+
auto compress_mask = detail::create_compress_swizzle_mask<IT, A>(bitmask, std::make_index_sequence<size>());
8888
return swizzle(z, compress_mask);
8989
}
9090

‎include/xsimd/arch/xsimd_avx2.hpp‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1287,15 +1287,15 @@ namespace xsimd
12871287
}
12881288

12891289
template <typename T, typename A, T... Vals, std::size_t... Ids>
1290-
constexpr auto swizzle_make_self_batch_impl(::xsimd::detail::index_sequence<Ids...>)
1290+
constexpr auto swizzle_make_self_batch_impl(std::index_sequence<Ids...>)
12911291
-> batch_constant<T, A, swizzle_self_val(Vals, T(Ids), static_cast<T>(sizeof...(Vals)))...>
12921292
{
12931293
return {};
12941294
}
12951295

12961296
template <typename T, typename A, T... Vals>
12971297
constexpr auto swizzle_make_self_batch()
1298-
-> decltype(swizzle_make_self_batch_impl<T, A, Vals...>(::xsimd::detail::make_index_sequence<sizeof...(Vals)>()))
1298+
-> decltype(swizzle_make_self_batch_impl<T, A, Vals...>(std::make_index_sequence<sizeof...(Vals)>()))
12991299
{
13001300
return {};
13011301
}
@@ -1309,15 +1309,15 @@ namespace xsimd
13091309
}
13101310

13111311
template <typename T, typename A, T... Vals, std::size_t... Ids>
1312-
constexpr auto swizzle_make_cross_batch_impl(::xsimd::detail::index_sequence<Ids...>)
1312+
constexpr auto swizzle_make_cross_batch_impl(std::index_sequence<Ids...>)
13131313
-> batch_constant<T, A, swizzle_cross_val(Vals, T(Ids), static_cast<T>(sizeof...(Vals)))...>
13141314
{
13151315
return {};
13161316
}
13171317

13181318
template <typename T, typename A, T... Vals>
13191319
constexpr auto swizzle_make_cross_batch()
1320-
-> decltype(swizzle_make_cross_batch_impl<T, A, Vals...>(::xsimd::detail::make_index_sequence<sizeof...(Vals)>()))
1320+
-> decltype(swizzle_make_cross_batch_impl<T, A, Vals...>(std::make_index_sequence<sizeof...(Vals)>()))
13211321
{
13221322
return {};
13231323
}

‎include/xsimd/arch/xsimd_emulated.hpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -52,15 +52,15 @@ namespace xsimd
5252
}
5353

5454
template <class F, class B, class... Bs, size_t... Is>
55-
auto emulated_apply(F func, ::xsimd::detail::index_sequence<Is...>, B const& b, Bs const&... bs) -> std::array<decltype(func(b.data[0], bs.data[0]...)), B::size>
55+
auto emulated_apply(F func, std::index_sequence<Is...>, B const& b, Bs const&... bs) -> std::array<decltype(func(b.data[0], bs.data[0]...)), B::size>
5656
{
5757
return { emulated_apply<Is>(func, b, bs...)... };
5858
}
5959

6060
template <class B, class F, class... Bs>
6161
auto emulated_apply(F func, B const& b, Bs const&... bs) -> std::array<decltype(func(b.data[0], bs.data[0]...)), B::size>
6262
{
63-
return emulated_apply(func, ::xsimd::detail::make_index_sequence<B::size>(), b, bs...);
63+
return emulated_apply(func, std::make_index_sequence<B::size>(), b, bs...);
6464
}
6565
}
6666

‎include/xsimd/arch/xsimd_neon.hpp‎

Lines changed: 22 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -2097,139 +2097,139 @@ namespace xsimd
20972097
namespace detail
20982098
{
20992099
template <class A, class T>
2100-
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const&, batch<T, A> const& /*rhs*/, std::size_t, ::xsimd::detail::index_sequence<>) noexcept
2100+
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const&, batch<T, A> const& /*rhs*/, std::size_t, std::index_sequence<>) noexcept
21012101
{
21022102
assert(false && "extract_pair out of bounds");
21032103
return batch<T, A> {};
21042104
}
21052105

21062106
template <class A, class T, size_t I, size_t... Is, detail::enable_sized_unsigned_t<T, 1> = 0>
2107-
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
2107+
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
21082108
{
21092109
if (n == I)
21102110
{
21112111
return vextq_u8(rhs, lhs, I);
21122112
}
21132113
else
21142114
{
2115-
return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
2115+
return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
21162116
}
21172117
}
21182118

21192119
template <class A, class T, size_t I, size_t... Is, detail::enable_sized_signed_t<T, 1> = 0>
2120-
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
2120+
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
21212121
{
21222122
if (n == I)
21232123
{
21242124
return vextq_s8(rhs, lhs, I);
21252125
}
21262126
else
21272127
{
2128-
return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
2128+
return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
21292129
}
21302130
}
21312131

21322132
template <class A, class T, size_t I, size_t... Is, detail::enable_sized_unsigned_t<T, 2> = 0>
2133-
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
2133+
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
21342134
{
21352135
if (n == I)
21362136
{
21372137
return vextq_u16(rhs, lhs, I);
21382138
}
21392139
else
21402140
{
2141-
return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
2141+
return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
21422142
}
21432143
}
21442144

21452145
template <class A, class T, size_t I, size_t... Is, detail::enable_sized_signed_t<T, 2> = 0>
2146-
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
2146+
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
21472147
{
21482148
if (n == I)
21492149
{
21502150
return vextq_s16(rhs, lhs, I);
21512151
}
21522152
else
21532153
{
2154-
return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
2154+
return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
21552155
}
21562156
}
21572157

21582158
template <class A, class T, size_t I, size_t... Is, detail::enable_sized_unsigned_t<T, 4> = 0>
2159-
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
2159+
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
21602160
{
21612161
if (n == I)
21622162
{
21632163
return vextq_u32(rhs, lhs, I);
21642164
}
21652165
else
21662166
{
2167-
return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
2167+
return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
21682168
}
21692169
}
21702170

21712171
template <class A, class T, size_t I, size_t... Is, detail::enable_sized_signed_t<T, 4> = 0>
2172-
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
2172+
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
21732173
{
21742174
if (n == I)
21752175
{
21762176
return vextq_s32(rhs, lhs, I);
21772177
}
21782178
else
21792179
{
2180-
return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
2180+
return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
21812181
}
21822182
}
21832183

21842184
template <class A, class T, size_t I, size_t... Is, detail::enable_sized_unsigned_t<T, 8> = 0>
2185-
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
2185+
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
21862186
{
21872187
if (n == I)
21882188
{
21892189
return vextq_u64(rhs, lhs, I);
21902190
}
21912191
else
21922192
{
2193-
return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
2193+
return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
21942194
}
21952195
}
21962196

21972197
template <class A, class T, size_t I, size_t... Is, detail::enable_sized_signed_t<T, 8> = 0>
2198-
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
2198+
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
21992199
{
22002200
if (n == I)
22012201
{
22022202
return vextq_s64(rhs, lhs, I);
22032203
}
22042204
else
22052205
{
2206-
return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
2206+
return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
22072207
}
22082208
}
22092209

22102210
template <class A, size_t I, size_t... Is>
2211-
XSIMD_INLINE batch<float, A> extract_pair(batch<float, A> const& lhs, batch<float, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
2211+
XSIMD_INLINE batch<float, A> extract_pair(batch<float, A> const& lhs, batch<float, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
22122212
{
22132213
if (n == I)
22142214
{
22152215
return vextq_f32(rhs, lhs, I);
22162216
}
22172217
else
22182218
{
2219-
return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
2219+
return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
22202220
}
22212221
}
22222222

22232223
template <class A, class T, size_t... Is>
2224-
XSIMD_INLINE batch<T, A> extract_pair_impl(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<0, Is...>) noexcept
2224+
XSIMD_INLINE batch<T, A> extract_pair_impl(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<0, Is...>) noexcept
22252225
{
22262226
if (n == 0)
22272227
{
22282228
return rhs;
22292229
}
22302230
else
22312231
{
2232-
return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
2232+
return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
22332233
}
22342234
}
22352235
}
@@ -2239,7 +2239,7 @@ namespace xsimd
22392239
{
22402240
constexpr std::size_t size = batch<T, A>::size;
22412241
assert(n < size && "index in bounds");
2242-
return detail::extract_pair_impl(lhs, rhs, n, ::xsimd::detail::make_index_sequence<size>());
2242+
return detail::extract_pair_impl(lhs, rhs, n, std::make_index_sequence<size>());
22432243
}
22442244

22452245
/******************

‎include/xsimd/arch/xsimd_neon64.hpp‎

Lines changed: 8 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,7 @@
1515
#include <complex>
1616
#include <cstddef>
1717
#include <tuple>
18+
#include <utility>
1819

1920
#include "../types/xsimd_neon64_register.hpp"
2021
#include "../types/xsimd_utils.hpp"
@@ -1132,15 +1133,15 @@ namespace xsimd
11321133
{
11331134
template <class A, size_t I, size_t... Is>
11341135
XSIMD_INLINE batch<double, A> extract_pair(batch<double, A> const& lhs, batch<double, A> const& rhs, std::size_t n,
1135-
::xsimd::detail::index_sequence<I, Is...>) noexcept
1136+
std::index_sequence<I, Is...>) noexcept
11361137
{
11371138
if (n == I)
11381139
{
11391140
return vextq_f64(rhs, lhs, I);
11401141
}
11411142
else
11421143
{
1143-
return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
1144+
return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
11441145
}
11451146
}
11461147
}
@@ -1150,7 +1151,7 @@ namespace xsimd
11501151
{
11511152
constexpr std::size_t size = batch<double, A>::size;
11521153
assert(n < size && "index in bounds");
1153-
return detail::extract_pair(lhs, rhs, n, ::xsimd::detail::make_index_sequence<size>());
1154+
return detail::extract_pair(lhs, rhs, n, std::make_index_sequence<size>());
11541155
}
11551156

11561157
/******************
@@ -1396,28 +1397,26 @@ namespace xsimd
13961397
namespace detail
13971398
{
13981399
using ::xsimd::batch_constant;
1399-
using ::xsimd::detail::integer_sequence;
1400-
using ::xsimd::detail::make_integer_sequence;
14011400

14021401
template <class CB1, class CB2, class IS>
14031402
struct index_burst_impl;
14041403

14051404
template <typename T1, class A, typename T2, T2... V,
14061405
T2... incr>
14071406
struct index_burst_impl<batch_constant<T1, A>, batch_constant<T2, A, V...>,
1408-
integer_sequence<T2, incr...>>
1407+
std::integer_sequence<T2, incr...>>
14091408
{
14101409
using type = batch_constant<T2, A, V...>;
14111410
};
14121411

14131412
template <typename T1, class A, T1 V0, T1... V1,
14141413
typename T2, T2... V2, T2... incr>
14151414
struct index_burst_impl<batch_constant<T1, A, V0, V1...>, batch_constant<T2, A, V2...>,
1416-
integer_sequence<T2, incr...>>
1415+
std::integer_sequence<T2, incr...>>
14171416
{
14181417
using next_input = batch_constant<T1, A, V1...>;
14191418
using next_output = batch_constant<T2, A, V2..., (V0 + incr)...>;
1420-
using type = typename index_burst_impl<next_input, next_output, integer_sequence<T2, incr...>>::type;
1419+
using type = typename index_burst_impl<next_input, next_output, std::integer_sequence<T2, incr...>>::type;
14211420
};
14221421

14231422
template <class B, class T>
@@ -1429,7 +1428,7 @@ namespace xsimd
14291428
static constexpr size_t mul = sizeof(Tp) / sizeof(T);
14301429
using input = batch_constant<Tp, A, (mul * V)...>;
14311430
using output = batch_constant<T, A>;
1432-
using type = typename index_burst_impl<input, output, make_integer_sequence<T, mul>>::type;
1431+
using type = typename index_burst_impl<input, output, std::make_integer_sequence<T, mul>>::type;
14331432
};
14341433

14351434
template <class B, typename T>

‎include/xsimd/arch/xsimd_ssse3.hpp‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -57,20 +57,20 @@ namespace xsimd
5757
{
5858

5959
template <class T, class A>
60-
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const&, batch<T, A> const& other, std::size_t, ::xsimd::detail::index_sequence<>) noexcept
60+
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const&, batch<T, A> const& other, std::size_t, std::index_sequence<>) noexcept
6161
{
6262
return other;
6363
}
6464

6565
template <class T, class A, std::size_t I, std::size_t... Is>
66-
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& self, batch<T, A> const& other, std::size_t i, ::xsimd::detail::index_sequence<I, Is...>) noexcept
66+
XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& self, batch<T, A> const& other, std::size_t i, std::index_sequence<I, Is...>) noexcept
6767
{
6868
if (i == I)
6969
{
7070
return _mm_alignr_epi8(self, other, sizeof(T) * I);
7171
}
7272
else
73-
return extract_pair(self, other, i, ::xsimd::detail::index_sequence<Is...>());
73+
return extract_pair(self, other, i, std::index_sequence<Is...>());
7474
}
7575
}
7676

@@ -79,7 +79,7 @@ namespace xsimd
7979
{
8080
constexpr std::size_t size = batch<T, A>::size;
8181
assert(i < size && "index in bounds");
82-
return detail::extract_pair(self, other, i, ::xsimd::detail::make_index_sequence<size>());
82+
return detail::extract_pair(self, other, i, std::make_index_sequence<size>());
8383
}
8484

8585
// reduce_add

0 commit comments

Comments
 (0)