41#if defined __clang__ && __clang_major__ < 12
46template <
size_t... Is,
size_t... Js>
47constexpr auto operator+(index_sequence<Is...>, index_sequence<Js...>)
49 return index_sequence<Is..., Js...>();
65template <
typename... TYPES>
struct list;
68template <
typename TYPE>
70 auto addr =
reinterpret_cast<std::uintptr_t
>(ptr);
71 return !(addr %
alignof(TYPE));
78template <
typename TYPE>
82 operator std::type_index()
const {
91template <
typename TYPE>
95template <auto VALUE,
typename TYPE = decltype(VALUE)>
96using value =
typename std::integral_constant<TYPE, VALUE>::type;
101 return typeid(T).
name();
110 std::is_base_of_v<AD,T>
111 || std::is_base_of_v<SimdBase,T>
112 || std::is_base_of_v<ExprBase,T>
113 || std::is_arithmetic_v<T>
116 || std::is_pointer_v<T>
120template <
typename T,
typename U =
void>
124template <
typename WANTED,
typename... TYPES>
126 return (std::is_same_v<WANTED, TYPES> || ... ||
false);
130template <
typename... TYPES>
132 return ((field ==
typeid(TYPES)) || ... ||
false);
142 typename HEAD = void,
146 using type = std::conditional_t<
147 std::is_base_of<BASE, HEAD>::value,
153template <
typename BASE,
typename HEAD>
155 using type = std::conditional_t<
156 std::is_base_of<BASE, HEAD>::value,
168 typename HEAD = void,
172 using type = std::conditional_t<
173 std::is_base_of<BASE, HEAD>::value,
179template <
typename BASE,
typename HEAD>
181 using type = std::conditional_t<
182 std::is_base_of<BASE, HEAD>::value,
188template <
typename BASE,
typename... TYPES>
192template <
template<
typename>
typename COND,
typename... TYPES>
195template <
template<
typename>
typename COND,
typename HEAD,
typename... TAIL>
197 static constexpr unsigned value = std::conditional_t<
199 std::integral_constant<unsigned, 0>,
204template <
template<
typename>
typename COND>
206 static constexpr unsigned value = 0;
210template <
typename... TYPES>
212 template <
typename T>
213 using type = std::integral_constant<bool, (std::is_same_v<TYPES,T> || ...)>;
217template <
typename... TYPES>
219 template <
typename T>
220 using type = std::integral_constant<bool, (!std::is_same_v<TYPES,T> && ...)>;
224template <
template <
typename>
class COND,
typename HEAD=void,
typename... TAIL>
226 using type = std::conditional_t<
227 COND<HEAD>::value && !std::is_void_v<HEAD>,
228 typename filter<COND, TAIL...>::type::template push<HEAD>,
234template <
template <
typename>
class COND,
typename TYPE>
236 using type = std::conditional_t<
237 COND<TYPE>::value && !std::is_void<TYPE>::value,
244template <
template <
typename>
class COND,
typename... TYPES>
249template <
typename HEAD=void,
typename... TAIL>
251 using type = std::conditional_t<!std::is_void_v<HEAD>,
252 typename reverse<TAIL...>::type::template append<HEAD>,
258template <
typename TYPE>
260 using type = std::conditional_t<
261 !std::is_void<TYPE>::value,
268template <
typename... TYPES>
275template <
typename... TYPES>
277 static constexpr unsigned size =
sizeof...(TYPES);
280 template <
unsigned INDEX>
281 using get =
typename std::tuple_element<INDEX, std::tuple<id<TYPES>...>>::type::type;
287 template <
template<
typename...>
class COLLECTION>
290 template <
template<
typename>
class F>
293 template <
typename F>
296 template <
typename TYPE>
299 template <
typename... UYPES>
303 template <
typename... UYPES>
309 template <
typename BASE>
316 template <
typename BASE,
typename FALLBACK>
318 std::is_void_v<first_with_base<BASE>>,
324 template <
typename TYPE>
330 template <
typename F>
335 template <
typename TYPE>
343template <
typename TYPES,
typename F, std::size_t... INDICES>
347 (f(
id<
typename TYPES::template get<INDICES>>(), INDICES), ...);
349 (f(
id<
typename TYPES::template get<INDICES>>()), ...);
354template <
typename TUPLE,
typename F, std::size_t...INDICES>
357 if constexpr (std::is_invocable_v<F, decltype(std::get<0>(tuple)), std::integral_constant<std::size_t,0>>) {
358 (f(std::get<INDICES>(tuple), std::integral_constant<std::size_t,INDICES>{}), ...);
359 }
else if constexpr (std::is_invocable_v<F, decltype(std::get<0>(tuple)),
unsigned>) {
360 (f(std::get<INDICES>(tuple), INDICES), ...);
362 (f(std::get<INDICES>(tuple)), ...);
368template <
typename TUPLE,
typename F>
371 tuple_for_each_index(tuple, std::forward<F>(f), std::make_index_sequence<std::tuple_size<TUPLE>::value> {});
375template <
typename T,
unsigned D,
typename U, std::size_t... INDICES>
376std::array<T,D>
make_array(U&& u, std::index_sequence<INDICES...>)
378 return std::array<T,D> {(INDICES, u)...};
382template <
typename T,
unsigned D,
typename U>
385 return make_array<T,D,U>(std::forward<U>(u), std::make_index_sequence<D> {});
389template <
typename T,
unsigned D,
typename F, std::size_t... INDICES>
392 return std::array<T,D> {f(INDICES)...};
396template <
typename T,
unsigned D,
typename F>
399 return make_array_f<T,D,F>(std::forward<F&&>(f), std::make_index_sequence<D> {});
403template <
auto... VALUE,
typename COND>
406 return (cond(i++, VALUE) || ...);
409#if !defined __clang__ || __clang_major__ >= 12
412template <std::size_t... Is, std::size_t... Js>
413constexpr auto operator+(std::index_sequence<Is...>, std::index_sequence<Js...>)
415 return std::index_sequence<Is..., Js...>();
421template <std::size_t... Is>
424 return std::array<std::size_t,
sizeof...(Is)>{Is...};
428template <
typename PREDICATE, std::size_t... Is>
431 std::conditional_t<predicate(Is),
432 std::index_sequence<Is>,
433 std::index_sequence<>>()
435 + std::index_sequence<>()
440template <
typename TYPES,
typename PREDICATE, std::size_t... Is>
443 std::conditional_t<predicate(
id<
typename TYPES::template get<Is>>()),
444 std::index_sequence<Is>,
445 std::index_sequence<>>()
447 + std::index_sequence<>()
452template <
typename TYPES,
template<
typename>
class COND, std::size_t... Is>
455 std::conditional_t<COND<
typename TYPES::template get<Is>>
::value,
456 std::index_sequence<Is>,
457 std::index_sequence<>>()
459 + std::index_sequence<>()
464template <
typename TYPES,
template<
typename>
class COND>
466 return filter_index_sequence<TYPES,COND>(std::make_index_sequence<TYPES::size>());
469template <
typename MAP, std::size_t... Is>
471 return std::index_sequence<
map(Is)...>();
474template <std::size_t N, std::size_t I, std::size_t... Is>
476 if constexpr (N > 0) {
477 return std::index_sequence<I>() +
take_n_sequence<N-1>(std::index_sequence<Is...>());
479 return std::index_sequence<>();
481 __builtin_unreachable();
484template <std::size_t N, std::size_t I, std::size_t... Is>
486 if constexpr (N > 0) {
489 return std::index_sequence<I,Is...>();
491 __builtin_unreachable();
494template <std::
size_t N>
498 }, std::make_index_sequence<N>());
501template <std::
size_t I, std::
size_t O>
505 }, std::make_index_sequence<(O-I)>());
508template <std::size_t... Is>
510 return ((Is == 0) && ... &&
true);
514template <
typename F, std::size_t... INDICES>
520template <
unsigned N,
typename F>
522 return call_n_times<F>(std::forward<F&&>(f), std::make_index_sequence<N>{});
529template <
typename TYPES,
typename Fa,
typename Fb, std::size_t Ia, std::size_t Iaa, std::size_t... Is>
531 if constexpr (seq.size()>2) {
532 fa(
id<
typename TYPES::template get<Ia>>());
533 fb(make_index_sequence_in_range<Ia+1,Iaa>());
534 index_sequence_for_subsequence_L2<TYPES>(fa,fb,std::index_sequence<Iaa,Is...>());
536 fa(
id<
typename TYPES::template get<Ia>>());
537 fb(make_index_sequence_in_range<Ia+1,Iaa>());
538 fa(
id<
typename TYPES::template get<Iaa>>());
539 fb(make_index_sequence_in_range<Iaa+1,TYPES::size>());
545template <
typename TYPES,
typename Fa,
typename Fb, std::size_t I, std::size_t... Is>
547 fb(std::make_index_sequence<I>());
548 if constexpr (seq.size()>1) {
549 index_sequence_for_subsequence_L2<TYPES>(fa, fb, seq );
551 fa(
id<
typename TYPES::template get<I>>());
552 fb(make_index_sequence_in_range<I+1,TYPES::size>());
558template <
typename TYPES,
typename Fa,
typename Fb, std::size_t... Is>
560 if constexpr (seq.size()>0) {
561 index_sequence_for_subsequence_L1<TYPES>(fa, fb, seq );
563 fb(std::make_index_sequence<TYPES::size>());
569 typename HEAD = void,
574 if constexpr (!
sizeof...(TAIL)) {
575 if constexpr (std::is_same<HEAD,void>::value) {
578 if constexpr(std::is_same<BASE,void>::value){
581 using HEAD_EVAL =
typename BASE::template derivedField<HEAD>;
586 if constexpr(std::is_same<BASE,void>::value){
589 using HEAD_EVAL =
typename BASE::template derivedField<HEAD>;
593 __builtin_unreachable();
599 return !std::is_same_v<type, void>;
Top level namespace for all of OpenLB.