Dune Core Modules (2.9.0)

loop.hh
1// SPDX-FileCopyrightInfo: Copyright (C) DUNE Project contributors, see file LICENSE.md in module root
2// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
3#ifndef DUNE_COMMON_SIMD_LOOP_HH
4#define DUNE_COMMON_SIMD_LOOP_HH
5
6#include <array>
7#include <cmath>
8#include <cstddef>
9#include <cstdlib>
10#include <ostream>
11
12#include <dune/common/math.hh>
13#include <dune/common/simd/simd.hh>
14#include <dune/common/typetraits.hh>
15
16namespace Dune {
17
18
19/*
20 * silence warnings from GCC about using integer operands on a bool
21 * (when instantiated for T=bool)
22 */
23#if __GNUC__ >= 7
24# pragma GCC diagnostic push
25# pragma GCC diagnostic ignored "-Wbool-operation"
26# pragma GCC diagnostic ignored "-Wint-in-bool-context"
27# define GCC_WARNING_DISABLED
28#endif
29
30/*
31 * silence warnings from Clang about using bitwise operands on
32 * a bool (when instantiated for T=bool)
33 */
34#ifdef __clang__
35#if __has_warning("-Wbitwise-instead-of-logical")
36# pragma clang diagnostic push
37# pragma clang diagnostic ignored "-Wbitwise-instead-of-logical"
38# define CLANG_WARNING_DISABLED
39#endif
40#endif
41
42/*
43 * Introduce a simd pragma if OpenMP is available in standard version >= 4
44 */
45#if _OPENMP >= 201307
46 #define DUNE_PRAGMA_OMP_SIMD _Pragma("omp simd")
47#else
48 #define DUNE_PRAGMA_OMP_SIMD
49#endif
50
51
63 template<class T, std::size_t S, std::size_t A = 0>
64 class alignas(A==0?alignof(T):A) LoopSIMD : public std::array<T,S> {
65
66 public:
67
68 //default constructor
69 LoopSIMD() {
70 assert(reinterpret_cast<uintptr_t>(this) % std::min(alignof(LoopSIMD<T,S,A>),alignof(std::max_align_t)) == 0);
71 }
72
73 // broadcast constructor initializing the content with a given value
74 LoopSIMD(Simd::Scalar<T> i) : LoopSIMD() {
75 this->fill(i);
76 }
77
78 template<std::size_t OA>
79 explicit LoopSIMD(const LoopSIMD<T,S,OA>& other)
80 : std::array<T,S>(other)
81 {
82 assert(reinterpret_cast<uintptr_t>(this) % std::min(alignof(LoopSIMD<T,S,A>),alignof(std::max_align_t)) == 0);
83 }
84
85 /*
86 * Definition of basic operators
87 */
88
89 //Prefix operators
90#define DUNE_SIMD_LOOP_PREFIX_OP(SYMBOL) \
91 auto operator SYMBOL() { \
92 DUNE_PRAGMA_OMP_SIMD \
93 for(std::size_t i=0; i<S; i++){ \
94 SYMBOL(*this)[i]; \
95 } \
96 return *this; \
97 } \
98 static_assert(true, "expecting ;")
99
100 DUNE_SIMD_LOOP_PREFIX_OP(++);
101 DUNE_SIMD_LOOP_PREFIX_OP(--);
102#undef DUNE_SIMD_LOOP_PREFIX_OP
103
104 //Unary operators
105#define DUNE_SIMD_LOOP_UNARY_OP(SYMBOL) \
106 auto operator SYMBOL() const { \
107 LoopSIMD<T,S,A> out; \
108 DUNE_PRAGMA_OMP_SIMD \
109 for(std::size_t i=0; i<S; i++){ \
110 out[i] = SYMBOL((*this)[i]); \
111 } \
112 return out; \
113 } \
114 static_assert(true, "expecting ;")
115
116 DUNE_SIMD_LOOP_UNARY_OP(+);
117 DUNE_SIMD_LOOP_UNARY_OP(-);
118 DUNE_SIMD_LOOP_UNARY_OP(~);
119
120 auto operator!() const {
121 Simd::Mask<LoopSIMD<T,S,A>> out;
122 DUNE_PRAGMA_OMP_SIMD
123 for(std::size_t i=0; i<S; i++){
124 out[i] = !((*this)[i]);
125 }
126 return out;
127 }
128#undef DUNE_SIMD_LOOP_UNARY_OP
129
130 //Postfix operators
131#define DUNE_SIMD_LOOP_POSTFIX_OP(SYMBOL) \
132 auto operator SYMBOL(int){ \
133 LoopSIMD<T,S,A> out = *this; \
134 SYMBOL(*this); \
135 return out; \
136 } \
137 static_assert(true, "expecting ;")
138
139 DUNE_SIMD_LOOP_POSTFIX_OP(++);
140 DUNE_SIMD_LOOP_POSTFIX_OP(--);
141#undef DUNE_SIMD_LOOP_POSTFIX_OP
142
143 //Assignment operators
144#define DUNE_SIMD_LOOP_ASSIGNMENT_OP(SYMBOL) \
145 auto operator SYMBOL(const Simd::Scalar<T> s) { \
146 DUNE_PRAGMA_OMP_SIMD \
147 for(std::size_t i=0; i<S; i++){ \
148 (*this)[i] SYMBOL s; \
149 } \
150 return *this; \
151 } \
152 \
153 auto operator SYMBOL(const LoopSIMD<T,S,A> &v) { \
154 DUNE_PRAGMA_OMP_SIMD \
155 for(std::size_t i=0; i<S; i++){ \
156 (*this)[i] SYMBOL v[i]; \
157 } \
158 return *this; \
159 } \
160 static_assert(true, "expecting ;")
161
162 DUNE_SIMD_LOOP_ASSIGNMENT_OP(+=);
163 DUNE_SIMD_LOOP_ASSIGNMENT_OP(-=);
164 DUNE_SIMD_LOOP_ASSIGNMENT_OP(*=);
165 DUNE_SIMD_LOOP_ASSIGNMENT_OP(/=);
166 DUNE_SIMD_LOOP_ASSIGNMENT_OP(%=);
167 DUNE_SIMD_LOOP_ASSIGNMENT_OP(<<=);
168 DUNE_SIMD_LOOP_ASSIGNMENT_OP(>>=);
169 DUNE_SIMD_LOOP_ASSIGNMENT_OP(&=);
170 DUNE_SIMD_LOOP_ASSIGNMENT_OP(|=);
171 DUNE_SIMD_LOOP_ASSIGNMENT_OP(^=);
172#undef DUNE_SIMD_LOOP_ASSIGNMENT_OP
173 };
174
175 //Arithmetic operators
176#define DUNE_SIMD_LOOP_BINARY_OP(SYMBOL) \
177 template<class T, std::size_t S, std::size_t A> \
178 auto operator SYMBOL(const LoopSIMD<T,S,A> &v, const Simd::Scalar<T> s) { \
179 LoopSIMD<T,S,A> out; \
180 DUNE_PRAGMA_OMP_SIMD \
181 for(std::size_t i=0; i<S; i++){ \
182 out[i] = v[i] SYMBOL s; \
183 } \
184 return out; \
185 } \
186 template<class T, std::size_t S, std::size_t A> \
187 auto operator SYMBOL(const Simd::Scalar<T> s, const LoopSIMD<T,S,A> &v) { \
188 LoopSIMD<T,S,A> out; \
189 DUNE_PRAGMA_OMP_SIMD \
190 for(std::size_t i=0; i<S; i++){ \
191 out[i] = s SYMBOL v[i]; \
192 } \
193 return out; \
194 } \
195 template<class T, std::size_t S, std::size_t A> \
196 auto operator SYMBOL(const LoopSIMD<T,S,A> &v, \
197 const LoopSIMD<T,S,A> &w) { \
198 LoopSIMD<T,S,A> out; \
199 DUNE_PRAGMA_OMP_SIMD \
200 for(std::size_t i=0; i<S; i++){ \
201 out[i] = v[i] SYMBOL w[i]; \
202 } \
203 return out; \
204 } \
205 static_assert(true, "expecting ;")
206
207 DUNE_SIMD_LOOP_BINARY_OP(+);
208 DUNE_SIMD_LOOP_BINARY_OP(-);
209 DUNE_SIMD_LOOP_BINARY_OP(*);
210 DUNE_SIMD_LOOP_BINARY_OP(/);
211 DUNE_SIMD_LOOP_BINARY_OP(%);
212
213 DUNE_SIMD_LOOP_BINARY_OP(&);
214 DUNE_SIMD_LOOP_BINARY_OP(|);
215 DUNE_SIMD_LOOP_BINARY_OP(^);
216
217#undef DUNE_SIMD_LOOP_BINARY_OP
218
219 //Bitshift operators
220#define DUNE_SIMD_LOOP_BITSHIFT_OP(SYMBOL) \
221 template<class T, std::size_t S, std::size_t A, class U> \
222 auto operator SYMBOL(const LoopSIMD<T,S,A> &v, const U s) { \
223 LoopSIMD<T,S,A> out; \
224 DUNE_PRAGMA_OMP_SIMD \
225 for(std::size_t i=0; i<S; i++){ \
226 out[i] = v[i] SYMBOL s; \
227 } \
228 return out; \
229 } \
230 template<class T, std::size_t S, std::size_t A, class U, std::size_t AU> \
231 auto operator SYMBOL(const LoopSIMD<T,S,A> &v, \
232 const LoopSIMD<U,S,AU> &w) { \
233 LoopSIMD<T,S,A> out; \
234 DUNE_PRAGMA_OMP_SIMD \
235 for(std::size_t i=0; i<S; i++){ \
236 out[i] = v[i] SYMBOL w[i]; \
237 } \
238 return out; \
239 } \
240 static_assert(true, "expecting ;")
241
242 DUNE_SIMD_LOOP_BITSHIFT_OP(<<);
243 DUNE_SIMD_LOOP_BITSHIFT_OP(>>);
244
245#undef DUNE_SIMD_LOOP_BITSHIFT_OP
246
247 //Comparison operators
248#define DUNE_SIMD_LOOP_COMPARISON_OP(SYMBOL) \
249 template<class T, std::size_t S, std::size_t A, class U> \
250 auto operator SYMBOL(const LoopSIMD<T,S,A> &v, const U s) { \
251 Simd::Mask<LoopSIMD<T,S,A>> out; \
252 DUNE_PRAGMA_OMP_SIMD \
253 for(std::size_t i=0; i<S; i++){ \
254 out[i] = v[i] SYMBOL s; \
255 } \
256 return out; \
257 } \
258 template<class T, std::size_t S, std::size_t A> \
259 auto operator SYMBOL(const Simd::Scalar<T> s, const LoopSIMD<T,S,A> &v) { \
260 Simd::Mask<LoopSIMD<T,S,A>> out; \
261 DUNE_PRAGMA_OMP_SIMD \
262 for(std::size_t i=0; i<S; i++){ \
263 out[i] = s SYMBOL v[i]; \
264 } \
265 return out; \
266 } \
267 template<class T, std::size_t S, std::size_t A> \
268 auto operator SYMBOL(const LoopSIMD<T,S,A> &v, \
269 const LoopSIMD<T,S,A> &w) { \
270 Simd::Mask<LoopSIMD<T,S,A>> out; \
271 DUNE_PRAGMA_OMP_SIMD \
272 for(std::size_t i=0; i<S; i++){ \
273 out[i] = v[i] SYMBOL w[i]; \
274 } \
275 return out; \
276 } \
277 static_assert(true, "expecting ;")
278
279 DUNE_SIMD_LOOP_COMPARISON_OP(<);
280 DUNE_SIMD_LOOP_COMPARISON_OP(>);
281 DUNE_SIMD_LOOP_COMPARISON_OP(<=);
282 DUNE_SIMD_LOOP_COMPARISON_OP(>=);
283 DUNE_SIMD_LOOP_COMPARISON_OP(==);
284 DUNE_SIMD_LOOP_COMPARISON_OP(!=);
285#undef DUNE_SIMD_LOOP_COMPARISON_OP
286
287 //Boolean operators
288#define DUNE_SIMD_LOOP_BOOLEAN_OP(SYMBOL) \
289 template<class T, std::size_t S, std::size_t A> \
290 auto operator SYMBOL(const LoopSIMD<T,S,A> &v, const Simd::Scalar<T> s) { \
291 Simd::Mask<LoopSIMD<T,S,A>> out; \
292 DUNE_PRAGMA_OMP_SIMD \
293 for(std::size_t i=0; i<S; i++){ \
294 out[i] = v[i] SYMBOL s; \
295 } \
296 return out; \
297 } \
298 template<class T, std::size_t S, std::size_t A> \
299 auto operator SYMBOL(const Simd::Mask<T> s, const LoopSIMD<T,S,A> &v) { \
300 Simd::Mask<LoopSIMD<T,S,A>> out; \
301 DUNE_PRAGMA_OMP_SIMD \
302 for(std::size_t i=0; i<S; i++){ \
303 out[i] = s SYMBOL v[i]; \
304 } \
305 return out; \
306 } \
307 template<class T, std::size_t S, std::size_t A> \
308 auto operator SYMBOL(const LoopSIMD<T,S,A> &v, \
309 const LoopSIMD<T,S,A> &w) { \
310 Simd::Mask<LoopSIMD<T,S,A>> out; \
311 DUNE_PRAGMA_OMP_SIMD \
312 for(std::size_t i=0; i<S; i++){ \
313 out[i] = v[i] SYMBOL w[i]; \
314 } \
315 return out; \
316 } \
317 static_assert(true, "expecting ;")
318
319 DUNE_SIMD_LOOP_BOOLEAN_OP(&&);
320 DUNE_SIMD_LOOP_BOOLEAN_OP(||);
321#undef DUNE_SIMD_LOOP_BOOLEAN_OP
322
323 //prints a given LoopSIMD
324 template<class T, std::size_t S, std::size_t A>
325 std::ostream& operator<< (std::ostream &os, const LoopSIMD<T,S,A> &v) {
326 os << "[";
327 for(std::size_t i=0; i<S-1; i++) {
328 os << v[i] << ", ";
329 }
330 os << v[S-1] << "]";
331 return os;
332 }
333
334 namespace Simd {
335 namespace Overloads {
336 /*
337 * Implementation/Overloads of the functions needed for
338 * SIMD-interface-compatibility
339 */
340
341 //Implementation of SIMD-interface-types
342 template<class T, std::size_t S, std::size_t A>
343 struct ScalarType<LoopSIMD<T,S,A>> {
344 using type = Simd::Scalar<T>;
345 };
346
347 template<class U, class T, std::size_t S, std::size_t A>
348 struct RebindType<U, LoopSIMD<T,S,A>> {
349 using type = LoopSIMD<Simd::Rebind<U, T>,S,A>;
350 };
351
352 //Implementation of SIMD-interface-functionality
353 template<class T, std::size_t S, std::size_t A>
354 struct LaneCount<LoopSIMD<T,S,A>> : index_constant<S*lanes<T>()> {};
355
356 template<class T, std::size_t S, std::size_t A>
357 auto lane(ADLTag<5>, std::size_t l, LoopSIMD<T,S,A> &&v)
358 -> decltype(std::move(Simd::lane(l%lanes<T>(), v[l/lanes<T>()])))
359 {
360 return std::move(Simd::lane(l%lanes<T>(), v[l/lanes<T>()]));
361 }
362
363 template<class T, std::size_t S, std::size_t A>
364 auto lane(ADLTag<5>, std::size_t l, const LoopSIMD<T,S,A> &v)
365 -> decltype(Simd::lane(l%lanes<T>(), v[l/lanes<T>()]))
366 {
367 return Simd::lane(l%lanes<T>(), v[l/lanes<T>()]);
368 }
369
370 template<class T, std::size_t S, std::size_t A>
371 auto lane(ADLTag<5>, std::size_t l, LoopSIMD<T,S,A> &v)
372 -> decltype(Simd::lane(l%lanes<T>(), v[l/lanes<T>()]))
373 {
374 return Simd::lane(l%lanes<T>(), v[l/lanes<T>()]);
375 }
376
377 template<class T, std::size_t S, std::size_t AM, std::size_t AD>
378 auto cond(ADLTag<5>, Simd::Mask<LoopSIMD<T,S,AM>> mask,
379 LoopSIMD<T,S,AD> ifTrue, LoopSIMD<T,S,AD> ifFalse) {
380 LoopSIMD<T,S,AD> out;
381 for(std::size_t i=0; i<S; i++) {
382 out[i] = Simd::cond(mask[i], ifTrue[i], ifFalse[i]);
383 }
384 return out;
385 }
386
387 template<class M, class T, std::size_t S, std::size_t A>
388 auto cond(ADLTag<5, std::is_same<bool, Simd::Scalar<M> >::value
389 && Simd::lanes<M>() == Simd::lanes<LoopSIMD<T,S,A> >()>,
390 M mask, LoopSIMD<T,S,A> ifTrue, LoopSIMD<T,S,A> ifFalse)
391 {
392 LoopSIMD<T,S,A> out;
393 for(auto l : range(Simd::lanes(mask)))
394 Simd::lane(l, out) = Simd::lane(l, mask) ? Simd::lane(l, ifTrue) : Simd::lane(l, ifFalse);
395 return out;
396 }
397
398 template<class M, std::size_t S, std::size_t A>
399 bool anyTrue(ADLTag<5>, LoopSIMD<M,S,A> mask) {
400 bool out = false;
401 for(std::size_t i=0; i<S; i++) {
402 out |= Simd::anyTrue(mask[i]);
403 }
404 return out;
405 }
406
407 template<class M, std::size_t S, std::size_t A>
408 bool allTrue(ADLTag<5>, LoopSIMD<M,S,A> mask) {
409 bool out = true;
410 for(std::size_t i=0; i<S; i++) {
411 out &= Simd::allTrue(mask[i]);
412 }
413 return out;
414 }
415
416 template<class M, std::size_t S, std::size_t A>
417 bool anyFalse(ADLTag<5>, LoopSIMD<M,S,A> mask) {
418 bool out = false;
419 for(std::size_t i=0; i<S; i++) {
420 out |= Simd::anyFalse(mask[i]);
421 }
422 return out;
423 }
424
425 template<class M, std::size_t S, std::size_t A>
426 bool allFalse(ADLTag<5>, LoopSIMD<M,S,A> mask) {
427 bool out = true;
428 for(std::size_t i=0; i<S; i++) {
429 out &= Simd::allFalse(mask[i]);
430 }
431 return out;
432 }
433 } //namespace Overloads
434
435 } //namespace Simd
436
437
438 /*
439 * Overloads the unary cmath-operations. Operations requiring
440 * or returning more than one argument are not supported.
441 * Due to inconsistency with the return values, cmath-operations
442 * on integral types are also not supported-
443 */
444
445#define DUNE_SIMD_LOOP_CMATH_UNARY_OP(expr) \
446 template<class T, std::size_t S, std::size_t A, typename Sfinae = \
447 typename std::enable_if_t<!std::is_integral<Simd::Scalar<T>>::value> > \
448 auto expr(const LoopSIMD<T,S,A> &v) { \
449 using std::expr; \
450 LoopSIMD<T,S,A> out; \
451 for(std::size_t i=0; i<S; i++) { \
452 out[i] = expr(v[i]); \
453 } \
454 return out; \
455 } \
456 static_assert(true, "expecting ;")
457
458#define DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN(expr, returnType) \
459 template<class T, std::size_t S, std::size_t A, typename Sfinae = \
460 typename std::enable_if_t<!std::is_integral<Simd::Scalar<T>>::value> > \
461 auto expr(const LoopSIMD<T,S,A> &v) { \
462 using std::expr; \
463 LoopSIMD<returnType,S> out; \
464 for(std::size_t i=0; i<S; i++) { \
465 out[i] = expr(v[i]); \
466 } \
467 return out; \
468 } \
469 static_assert(true, "expecting ;")
470
471 DUNE_SIMD_LOOP_CMATH_UNARY_OP(cos);
472 DUNE_SIMD_LOOP_CMATH_UNARY_OP(sin);
473 DUNE_SIMD_LOOP_CMATH_UNARY_OP(tan);
474 DUNE_SIMD_LOOP_CMATH_UNARY_OP(acos);
475 DUNE_SIMD_LOOP_CMATH_UNARY_OP(asin);
476 DUNE_SIMD_LOOP_CMATH_UNARY_OP(atan);
477 DUNE_SIMD_LOOP_CMATH_UNARY_OP(cosh);
478 DUNE_SIMD_LOOP_CMATH_UNARY_OP(sinh);
479 DUNE_SIMD_LOOP_CMATH_UNARY_OP(tanh);
480 DUNE_SIMD_LOOP_CMATH_UNARY_OP(acosh);
481 DUNE_SIMD_LOOP_CMATH_UNARY_OP(asinh);
482 DUNE_SIMD_LOOP_CMATH_UNARY_OP(atanh);
483
484 DUNE_SIMD_LOOP_CMATH_UNARY_OP(exp);
485 DUNE_SIMD_LOOP_CMATH_UNARY_OP(log);
486 DUNE_SIMD_LOOP_CMATH_UNARY_OP(log10);
487 DUNE_SIMD_LOOP_CMATH_UNARY_OP(exp2);
488 DUNE_SIMD_LOOP_CMATH_UNARY_OP(expm1);
489 DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN(ilogb, int);
490 DUNE_SIMD_LOOP_CMATH_UNARY_OP(log1p);
491 DUNE_SIMD_LOOP_CMATH_UNARY_OP(log2);
492 DUNE_SIMD_LOOP_CMATH_UNARY_OP(logb);
493
494 DUNE_SIMD_LOOP_CMATH_UNARY_OP(sqrt);
495 DUNE_SIMD_LOOP_CMATH_UNARY_OP(cbrt);
496
497 DUNE_SIMD_LOOP_CMATH_UNARY_OP(erf);
498 DUNE_SIMD_LOOP_CMATH_UNARY_OP(erfc);
499 DUNE_SIMD_LOOP_CMATH_UNARY_OP(tgamma);
500 DUNE_SIMD_LOOP_CMATH_UNARY_OP(lgamma);
501
502 DUNE_SIMD_LOOP_CMATH_UNARY_OP(ceil);
503 DUNE_SIMD_LOOP_CMATH_UNARY_OP(floor);
504 DUNE_SIMD_LOOP_CMATH_UNARY_OP(trunc);
505 DUNE_SIMD_LOOP_CMATH_UNARY_OP(round);
506 DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN(lround, long);
507 DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN(llround, long long);
508 DUNE_SIMD_LOOP_CMATH_UNARY_OP(rint);
509 DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN(lrint, long);
510 DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN(llrint, long long);
511 DUNE_SIMD_LOOP_CMATH_UNARY_OP(nearbyint);
512
513 DUNE_SIMD_LOOP_CMATH_UNARY_OP(fabs);
514 DUNE_SIMD_LOOP_CMATH_UNARY_OP(abs);
515
516#undef DUNE_SIMD_LOOP_CMATH_UNARY_OP
517#undef DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN
518
519
520 /* not implemented cmath-functions:
521 * atan2
522 * frexp, idexp
523 * modf
524 * scalbn, scalbln
525 * pow
526 * hypot
527 * remainder, remquo
528 * copysign
529 * nan
530 * nextafter, nexttoward
531 * fdim, fmax, fmin
532 */
533
534 /*
535 * Overloads specific functions usually provided by the std library
536 * More overloads will be provided should the need arise.
537 */
538
539#define DUNE_SIMD_LOOP_STD_UNARY_OP(expr) \
540 template<class T, std::size_t S, std::size_t A> \
541 auto expr(const LoopSIMD<T,S,A> &v) { \
542 using std::expr; \
543 LoopSIMD<T,S,A> out; \
544 for(std::size_t i=0; i<S; i++) { \
545 out[i] = expr(v[i]); \
546 } \
547 return out; \
548 } \
549 \
550 template<class T, std::size_t S, std::size_t A> \
551 auto expr(const LoopSIMD<std::complex<T>,S,A> &v) { \
552 using std::expr; \
553 LoopSIMD<T,S,A> out; \
554 for(std::size_t i=0; i<S; i++) { \
555 out[i] = expr(v[i]); \
556 } \
557 return out; \
558 } \
559 static_assert(true, "expecting ;")
560
561 DUNE_SIMD_LOOP_STD_UNARY_OP(real);
562 DUNE_SIMD_LOOP_STD_UNARY_OP(imag);
563
564#undef DUNE_SIMD_LOOP_STD_UNARY_OP
565
566#define DUNE_SIMD_LOOP_STD_BINARY_OP(expr) \
567 template<class T, std::size_t S, std::size_t A> \
568 auto expr(const LoopSIMD<T,S,A> &v, const LoopSIMD<T,S,A> &w) { \
569 using std::expr; \
570 LoopSIMD<T,S,A> out; \
571 for(std::size_t i=0; i<S; i++) { \
572 out[i] = expr(v[i],w[i]); \
573 } \
574 return out; \
575 } \
576 static_assert(true, "expecting ;")
577
578 DUNE_SIMD_LOOP_STD_BINARY_OP(max);
579 DUNE_SIMD_LOOP_STD_BINARY_OP(min);
580
581#undef DUNE_SIMD_LOOP_STD_BINARY_OP
582
583 namespace MathOverloads {
584 template<class T, std::size_t S, std::size_t A>
585 auto isNaN(const LoopSIMD<T,S,A> &v, PriorityTag<3>, ADLTag) {
586 Simd::Mask<LoopSIMD<T,S,A>> out;
587 for(auto l : range(S))
588 out[l] = Dune::isNaN(v[l]);
589 return out;
590 }
591
592 template<class T, std::size_t S, std::size_t A>
593 auto isInf(const LoopSIMD<T,S,A> &v, PriorityTag<3>, ADLTag) {
594 Simd::Mask<LoopSIMD<T,S,A>> out;
595 for(auto l : range(S))
596 out[l] = Dune::isInf(v[l]);
597 return out;
598 }
599
600 template<class T, std::size_t S, std::size_t A>
601 auto isFinite(const LoopSIMD<T,S,A> &v, PriorityTag<3>, ADLTag) {
602 Simd::Mask<LoopSIMD<T,S,A>> out;
603 for(auto l : range(S))
604 out[l] = Dune::isFinite(v[l]);
605 return out;
606 }
607 } //namespace MathOverloads
608
609 template<class T, std::size_t S, std::size_t A>
610 struct IsNumber<LoopSIMD<T,S,A>> :
611 public std::integral_constant<bool, IsNumber<T>::value>{
612 };
613
614#ifdef CLANG_WARNING_DISABLED
615# pragma clang diagnostic pop
616# undef CLANG_WARNING_DISABLED
617#endif
618
619#ifdef GCC_WARNING_DISABLED
620# pragma GCC diagnostic pop
621# undef GCC_WARNING_DISABLED
622#endif
623
624} //namespace Dune
625
626#endif
Dune::LoopSIMD
Definition: loop.hh:64
typetraits.hh
Traits for type conversions and type information.
Dune::index_constant
std::integral_constant< std::size_t, i > index_constant
An index constant with value i.
Definition: indices.hh:30
Dune::FloatCmp::round
I round(const T &val, typename EpsilonType< T >::Type epsilon)
round using epsilon
Definition: float_cmp.cc:311
Dune::FloatCmp::trunc
I trunc(const T &val, typename EpsilonType< T >::Type epsilon)
truncate using epsilon
Definition: float_cmp.cc:407
Dune::Simd::Overloads::mask
Mask< V > mask(ADLTag< 0, std::is_same< V, Mask< V > >::value >, const V &v)
implements Simd::mask()
Definition: defaults.hh:153
Dune::Simd::Overloads::allFalse
bool allFalse(ADLTag< 0 >, const Mask &mask)
implements Simd::allFalse()
Definition: defaults.hh:124
Dune::Simd::Overloads::allTrue
bool allTrue(ADLTag< 0 >, const Mask &mask)
implements Simd::allTrue()
Definition: defaults.hh:104
Dune::Simd::Overloads::anyFalse
bool anyFalse(ADLTag< 0 >, const Mask &mask)
implements Simd::anyFalse()
Definition: defaults.hh:114
Dune::Simd::Overloads::min
auto min(ADLTag< 0 >, const V &v1, const V &v2)
implements binary Simd::min()
Definition: defaults.hh:89
Dune::Simd::Overloads::max
auto max(ADLTag< 0 >, const V &v1, const V &v2)
implements binary Simd::max()
Definition: defaults.hh:81
Dune::Simd::anyTrue
bool anyTrue(const Mask &mask)
Whether any entry is true
Definition: interface.hh:429
Dune::Simd::cond
V cond(M &&mask, const V &ifTrue, const V &ifFalse)
Like the ?: operator.
Definition: interface.hh:386
Dune::Simd::allTrue
bool allTrue(const Mask &mask)
Whether all entries are true
Definition: interface.hh:439
Dune::Simd::anyFalse
bool anyFalse(const Mask &mask)
Whether any entry is false
Definition: interface.hh:449
Dune::Simd::lanes
constexpr std::size_t lanes()
Number of lanes in a SIMD type.
Definition: interface.hh:305
Dune::Simd::lane
decltype(auto) lane(std::size_t l, V &&v)
Extract an element of a SIMD type.
Definition: interface.hh:324
Dune::Simd::Mask
Rebind< bool, V > Mask
Mask type type of some SIMD type.
Definition: interface.hh:289
Dune::Simd::allFalse
bool allFalse(const Mask &mask)
Whether all entries are false
Definition: interface.hh:459
Dune::Simd::Scalar
typename Overloads::ScalarType< std::decay_t< V > >::type Scalar
Element type of some SIMD type.
Definition: interface.hh:235
math.hh
Some useful basic math stuff.
Dune
Dune namespace.
Definition: alignedallocator.hh:13
Dune::cond
const T1 cond(bool b, const T1 &v1, const T2 &v2)
conditional evaluate
Definition: conditional.hh:28
simd.hh
Include file for users of the SIMD abstraction layer.
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.111.3 (Dec 21, 23:30, 2024)