Skip to content

Commit 78e7b23

Browse files
serge-sans-pailleserge-sans-paille
committed
Move to C++14: Use std::enable_if_t instead of typename std::enable_if<...>::type
1 parent 1637833 commit 78e7b23

36 files changed

+551
-557
lines changed

‎examples/pico_bench.hpp‎

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -202,16 +202,14 @@ namespace pico_bench
202202
}
203203

204204
template <typename Fn>
205-
typename std::enable_if<std::is_void<decltype(std::declval<Fn>()())>::value,
206-
stats_type>::type
205+
std::enable_if_t<std::is_void<decltype(std::declval<Fn>()())>::value, stats_type>
207206
operator()(Fn fn) const
208207
{
209208
return (*this)(BenchWrapper<Fn> { fn });
210209
}
211210

212211
template <typename Fn>
213-
typename std::enable_if<std::is_same<decltype(std::declval<Fn>()()), T>::value,
214-
stats_type>::type
212+
std::enable_if_t<std::is_same<decltype(std::declval<Fn>()()), T>::value, stats_type>
215213
operator()(Fn fn) const
216214
{
217215
// Do a single un-timed warm up run

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

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -28,14 +28,14 @@ namespace xsimd
2828
using namespace types;
2929

3030
// bitwise_lshift
31-
template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value>::type*/>
31+
template <class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
3232
XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
3333
{
3434
return detail::apply([](T x, T y) noexcept
3535
{ return x << y; },
3636
self, other);
3737
}
38-
template <size_t shift, class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value>::type*/>
38+
template <size_t shift, class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
3939
XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, requires_arch<common>) noexcept
4040
{
4141
constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
@@ -44,14 +44,14 @@ namespace xsimd
4444
}
4545

4646
// bitwise_rshift
47-
template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value>::type*/>
47+
template <class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
4848
XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
4949
{
5050
return detail::apply([](T x, T y) noexcept
5151
{ return x >> y; },
5252
self, other);
5353
}
54-
template <size_t shift, class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value>::type*/>
54+
template <size_t shift, class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
5555
XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, requires_arch<common>) noexcept
5656
{
5757
constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
@@ -74,7 +74,7 @@ namespace xsimd
7474
}
7575

7676
// div
77-
template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
77+
template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
7878
XSIMD_INLINE batch<T, A> div(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
7979
{
8080
return detail::apply([](T x, T y) noexcept -> T
@@ -169,7 +169,7 @@ namespace xsimd
169169
}
170170

171171
// mul
172-
template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value>::type*/>
172+
template <class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
173173
XSIMD_INLINE batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
174174
{
175175
return detail::apply([](T x, T y) noexcept -> T
@@ -213,7 +213,7 @@ namespace xsimd
213213
{
214214
return add(self, other); // no saturated arithmetic on floating point numbers
215215
}
216-
template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value>::type*/>
216+
template <class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
217217
XSIMD_INLINE batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
218218
{
219219
if (std::is_signed<T>::value)
@@ -241,7 +241,7 @@ namespace xsimd
241241
{
242242
return sub(self, other); // no saturated arithmetic on floating point numbers
243243
}
244-
template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value>::type*/>
244+
template <class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
245245
XSIMD_INLINE batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
246246
{
247247
if (std::is_signed<T>::value)

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -95,7 +95,7 @@ namespace xsimd
9595
template <class T, class A>
9696
XSIMD_INLINE batch<T, A> sqrt(batch<T, A> const& self) noexcept;
9797
template <class T, class A, class Vt, Vt... Values>
98-
XSIMD_INLINE typename std::enable_if<std::is_arithmetic<T>::value, batch<T, A>>::type
98+
XSIMD_INLINE std::enable_if_t<std::is_arithmetic<T>::value, batch<T, A>>
9999
swizzle(batch<T, A> const& x, batch_constant<Vt, A, Values...> mask) noexcept;
100100
template <class T, class A>
101101
XSIMD_INLINE batch<T, A> tan(batch<T, A> const& self) noexcept;

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

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -116,7 +116,7 @@ namespace xsimd
116116
}
117117

118118
// isinf
119-
template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
119+
template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
120120
XSIMD_INLINE batch_bool<T, A> isinf(batch<T, A> const&, requires_arch<common>) noexcept
121121
{
122122
return batch_bool<T, A>(false);
@@ -143,7 +143,7 @@ namespace xsimd
143143
}
144144

145145
// isfinite
146-
template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
146+
template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
147147
XSIMD_INLINE batch_bool<T, A> isfinite(batch<T, A> const&, requires_arch<common>) noexcept
148148
{
149149
return batch_bool<T, A>(true);
@@ -160,14 +160,14 @@ namespace xsimd
160160
}
161161

162162
// isnan
163-
template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
163+
template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
164164
XSIMD_INLINE batch_bool<T, A> isnan(batch<T, A> const&, requires_arch<common>) noexcept
165165
{
166166
return batch_bool<T, A>(false);
167167
}
168168

169169
// le
170-
template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
170+
template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
171171
XSIMD_INLINE batch_bool<T, A> le(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
172172
{
173173
return (self < other) || (self == other);
@@ -220,7 +220,7 @@ namespace xsimd
220220
using is_batch_bool_register_same = std::is_same<typename batch_bool<T, A>::register_type, typename batch<T, A>::register_type>;
221221
}
222222

223-
template <class A, class T, typename std::enable_if<detail::is_batch_bool_register_same<T, A>::value, int>::type = 3>
223+
template <class A, class T, std::enable_if_t<detail::is_batch_bool_register_same<T, A>::value, int> = 3>
224224
XSIMD_INLINE batch_bool<T, A> select(batch_bool<T, A> const& cond, batch_bool<T, A> const& true_br, batch_bool<T, A> const& false_br, requires_arch<common>)
225225
{
226226
using register_type = typename batch_bool<T, A>::register_type;
@@ -230,7 +230,7 @@ namespace xsimd
230230
return batch_bool<T, A> { select(cond, true_v, false_v) };
231231
}
232232

233-
template <class A, class T, typename std::enable_if<!detail::is_batch_bool_register_same<T, A>::value, int>::type = 3>
233+
template <class A, class T, std::enable_if_t<!detail::is_batch_bool_register_same<T, A>::value, int> = 3>
234234
XSIMD_INLINE batch_bool<T, A> select(batch_bool<T, A> const& cond, batch_bool<T, A> const& true_br, batch_bool<T, A> const& false_br, requires_arch<common>)
235235
{
236236
return (true_br & cond) | (bitwise_andnot(false_br, cond));

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

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -286,7 +286,7 @@ namespace xsimd
286286
}
287287

288288
// copysign
289-
template <class A, class T, class = typename std::enable_if<std::is_floating_point<T>::value>::type>
289+
template <class A, class T, class = std::enable_if_t<std::is_floating_point<T>::value>>
290290
XSIMD_INLINE batch<T, A> copysign(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
291291
{
292292
return abs(self) | bitofsign(other);
@@ -1877,7 +1877,7 @@ namespace xsimd
18771877
}
18781878

18791879
// mod
1880-
template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
1880+
template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
18811881
XSIMD_INLINE batch<T, A> mod(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
18821882
{
18831883
return detail::apply([](T x, T y) noexcept -> T
@@ -1886,7 +1886,7 @@ namespace xsimd
18861886
}
18871887

18881888
// nearbyint
1889-
template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
1889+
template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
18901890
XSIMD_INLINE batch<T, A> nearbyint(batch<T, A> const& self, requires_arch<common>) noexcept
18911891
{
18921892
return self;
@@ -1926,7 +1926,7 @@ namespace xsimd
19261926
}
19271927

19281928
// nearbyint_as_int
1929-
template <class T, class A, class = typename std::enable_if<std::is_integral<T>::value>::type>
1929+
template <class T, class A, class = std::enable_if_t<std::is_integral<T>::value>>
19301930
XSIMD_INLINE batch<T, A> nearbyint_as_int(batch<T, A> const& self, requires_arch<common>) noexcept
19311931
{
19321932
return self;
@@ -2088,7 +2088,7 @@ namespace xsimd
20882088
}
20892089

20902090
// reciprocal
2091-
template <class T, class A, class = typename std::enable_if<std::is_floating_point<T>::value>::type>
2091+
template <class T, class A, class = std::enable_if_t<std::is_floating_point<T>::value>>
20922092
XSIMD_INLINE batch<T, A> reciprocal(batch<T, A> const& self,
20932093
requires_arch<common>) noexcept
20942094
{
@@ -2103,7 +2103,7 @@ namespace xsimd
21032103
return { reduce_add(self.real()), reduce_add(self.imag()) };
21042104
}
21052105

2106-
template <class A, class T, class /*=typename std::enable_if<std::is_scalar<T>::value>::type*/>
2106+
template <class A, class T, class /*=std::enable_if_t<std::is_scalar<T>::value>*/>
21072107
XSIMD_INLINE T reduce_add(batch<T, A> const& self, requires_arch<common>) noexcept
21082108
{
21092109
alignas(A::alignment()) T buffer[batch<T, A>::size];
@@ -2175,7 +2175,7 @@ namespace xsimd
21752175
return res;
21762176
}
21772177

2178-
template <class A, class T, class /*=typename std::enable_if<std::is_scalar<T>::value>::type*/>
2178+
template <class A, class T, class /*=std::enable_if_t<std::is_scalar<T>::value>*/>
21792179
XSIMD_INLINE T reduce_mul(batch<T, A> const& self, requires_arch<common>) noexcept
21802180
{
21812181
alignas(A::alignment()) T buffer[batch<T, A>::size];
@@ -2199,7 +2199,7 @@ namespace xsimd
21992199
{
22002200
return fnma(nearbyint(self / other), other, self);
22012201
}
2202-
template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
2202+
template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
22032203
XSIMD_INLINE batch<T, A> remainder(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
22042204
{
22052205
auto mod = self % other;
@@ -2214,7 +2214,7 @@ namespace xsimd
22142214
}
22152215

22162216
// sign
2217-
template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
2217+
template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
22182218
XSIMD_INLINE batch<T, A> sign(batch<T, A> const& self, requires_arch<common>) noexcept
22192219
{
22202220
using batch_type = batch<T, A>;
@@ -2260,7 +2260,7 @@ namespace xsimd
22602260
}
22612261

22622262
// signnz
2263-
template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
2263+
template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
22642264
XSIMD_INLINE batch<T, A> signnz(batch<T, A> const& self, requires_arch<common>) noexcept
22652265
{
22662266
using batch_type = batch<T, A>;

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

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -136,14 +136,14 @@ namespace xsimd
136136
namespace detail
137137
{
138138
// Not using XSIMD_INLINE here as it makes msvc hand got ever on avx512
139-
template <size_t N, typename T, typename A, typename U, typename V, typename std::enable_if<N == 0, int>::type = 0>
139+
template <size_t N, typename T, typename A, typename U, typename V, std::enable_if_t<N == 0, int> = 0>
140140
inline batch<T, A> gather(U const* src, batch<V, A> const& index,
141141
::xsimd::index<N> I) noexcept
142142
{
143143
return insert(batch<T, A> {}, static_cast<T>(src[index.get(I)]), I);
144144
}
145145

146-
template <size_t N, typename T, typename A, typename U, typename V, typename std::enable_if<N != 0, int>::type = 0>
146+
template <size_t N, typename T, typename A, typename U, typename V, std::enable_if_t<N != 0, int> = 0>
147147
inline batch<T, A>
148148
gather(U const* src, batch<V, A> const& index, ::xsimd::index<N> I) noexcept
149149
{
@@ -397,15 +397,15 @@ namespace xsimd
397397
}
398398

399399
template <class A, bool... Values, class Mode>
400-
XSIMD_INLINE typename std::enable_if<types::has_simd_register<double, A>::value, batch<int64_t, A>>::type
400+
XSIMD_INLINE std::enable_if_t<types::has_simd_register<double, A>::value, batch<int64_t, A>>
401401
load_masked(int64_t const* mem, batch_bool_constant<int64_t, A, Values...>, convert<int64_t>, Mode, requires_arch<A>) noexcept
402402
{
403403
const auto d = load_masked<A>(reinterpret_cast<const double*>(mem), batch_bool_constant<double, A, Values...> {}, convert<double> {}, Mode {}, A {});
404404
return bitwise_cast<int64_t>(d);
405405
}
406406

407407
template <class A, bool... Values, class Mode>
408-
XSIMD_INLINE typename std::enable_if<types::has_simd_register<double, A>::value, batch<uint64_t, A>>::type
408+
XSIMD_INLINE std::enable_if_t<types::has_simd_register<double, A>::value, batch<uint64_t, A>>
409409
load_masked(uint64_t const* mem, batch_bool_constant<uint64_t, A, Values...>, convert<uint64_t>, Mode, requires_arch<A>) noexcept
410410
{
411411
const auto d = load_masked<A>(reinterpret_cast<const double*>(mem), batch_bool_constant<double, A, Values...> {}, convert<double> {}, Mode {}, A {});
@@ -425,14 +425,14 @@ namespace xsimd
425425
}
426426

427427
template <class A, bool... Values, class Mode>
428-
XSIMD_INLINE typename std::enable_if<types::has_simd_register<double, A>::value, void>::type
428+
XSIMD_INLINE std::enable_if_t<types::has_simd_register<double, A>::value, void>
429429
store_masked(int64_t* mem, batch<int64_t, A> const& src, batch_bool_constant<int64_t, A, Values...>, Mode, requires_arch<A>) noexcept
430430
{
431431
store_masked<A>(reinterpret_cast<double*>(mem), bitwise_cast<double>(src), batch_bool_constant<double, A, Values...> {}, Mode {}, A {});
432432
}
433433

434434
template <class A, bool... Values, class Mode>
435-
XSIMD_INLINE typename std::enable_if<types::has_simd_register<double, A>::value, void>::type
435+
XSIMD_INLINE std::enable_if_t<types::has_simd_register<double, A>::value, void>
436436
store_masked(uint64_t* mem, batch<uint64_t, A> const& src, batch_bool_constant<uint64_t, A, Values...>, Mode, requires_arch<A>) noexcept
437437
{
438438
store_masked<A>(reinterpret_cast<double*>(mem), bitwise_cast<double>(src), batch_bool_constant<double, A, Values...> {}, Mode {}, A {});
@@ -483,15 +483,15 @@ namespace xsimd
483483
// Scatter with runtime indexes.
484484
namespace detail
485485
{
486-
template <size_t N, typename T, typename A, typename U, typename V, typename std::enable_if<N == 0, int>::type = 0>
486+
template <size_t N, typename T, typename A, typename U, typename V, std::enable_if_t<N == 0, int> = 0>
487487
XSIMD_INLINE void scatter(batch<T, A> const& src, U* dst,
488488
batch<V, A> const& index,
489489
::xsimd::index<N> I) noexcept
490490
{
491491
dst[index.get(I)] = static_cast<U>(src.get(I));
492492
}
493493

494-
template <size_t N, typename T, typename A, typename U, typename V, typename std::enable_if<N != 0, int>::type = 0>
494+
template <size_t N, typename T, typename A, typename U, typename V, std::enable_if_t<N != 0, int> = 0>
495495
XSIMD_INLINE void
496496
scatter(batch<T, A> const& src, U* dst, batch<V, A> const& index,
497497
::xsimd::index<N> I) noexcept
@@ -829,7 +829,7 @@ namespace xsimd
829829
}
830830

831831
// transpose
832-
template <class A, class = typename std::enable_if<batch<int16_t, A>::size == 8>::type>
832+
template <class A, class = std::enable_if_t<batch<int16_t, A>::size == 8>>
833833
XSIMD_INLINE void transpose(batch<int16_t, A>* matrix_begin, batch<int16_t, A>* matrix_end, requires_arch<common>) noexcept
834834
{
835835
assert((matrix_end - matrix_begin == batch<int16_t, A>::size) && "correctly sized matrix");
@@ -873,7 +873,7 @@ namespace xsimd
873873
transpose(reinterpret_cast<batch<int16_t, A>*>(matrix_begin), reinterpret_cast<batch<int16_t, A>*>(matrix_end), A {});
874874
}
875875

876-
template <class A, class = typename std::enable_if<batch<int8_t, A>::size == 16>::type>
876+
template <class A, class = std::enable_if_t<batch<int8_t, A>::size == 16>>
877877
XSIMD_INLINE void transpose(batch<int8_t, A>* matrix_begin, batch<int8_t, A>* matrix_end, requires_arch<common>) noexcept
878878
{
879879
assert((matrix_end - matrix_begin == batch<int8_t, A>::size) && "correctly sized matrix");

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -49,7 +49,7 @@ namespace xsimd
4949
}
5050

5151
// trunc
52-
template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
52+
template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
5353
XSIMD_INLINE batch<T, A> trunc(batch<T, A> const& self, requires_arch<common>) noexcept
5454
{
5555
return self;

0 commit comments

Comments
 (0)