DDC 0.7.0
Loading...
Searching...
No Matches
strided_discrete_domain.hpp
1// Copyright (C) The DDC development team, see COPYRIGHT.md file
2//
3// SPDX-License-Identifier: MIT
4
5#pragma once
6
7#include <cassert>
8#include <cstddef>
9#include <iterator>
10#include <tuple>
11#include <type_traits>
12
13#include <Kokkos_Macros.hpp>
14
15#include "detail/type_seq.hpp"
16
17#include "discrete_element.hpp"
18#include "discrete_vector.hpp"
19
20namespace ddc {
21
22template <class DDim>
24
25template <class... DDims>
27
28template <class T>
29struct is_strided_discrete_domain : std::false_type
30{
31};
32
33template <class... Tags>
34struct is_strided_discrete_domain<StridedDiscreteDomain<Tags...>> : std::true_type
35{
36};
37
38template <class T>
40
41
42namespace detail {
43
44template <class... Tags>
45struct ToTypeSeq<StridedDiscreteDomain<Tags...>>
46{
47 using type = TypeSeq<Tags...>;
48};
49
50template <class T, class U>
51struct RebindDomain;
52
53template <class... DDims, class... ODDims>
54struct RebindDomain<StridedDiscreteDomain<DDims...>, detail::TypeSeq<ODDims...>>
55{
56 using type = StridedDiscreteDomain<ODDims...>;
57};
58
59} // namespace detail
60
61template <class... ODDims>
63 DiscreteVector<ODDims...> const& lhs,
64 DiscreteVector<ODDims...> const& rhs) noexcept
65{
66 return DiscreteVector<ODDims...>((get<ODDims>(lhs) * get<ODDims>(rhs))...);
67}
68
69template <class... DDims>
71{
72 template <class...>
73 friend class StridedDiscreteDomain;
74
75public:
76 using discrete_element_type = DiscreteElement<DDims...>;
77
78 using discrete_vector_type = DiscreteVector<DDims...>;
79
80private:
81 DiscreteElement<DDims...> m_element_begin;
82
83 DiscreteVector<DDims...> m_extents;
84
85 DiscreteVector<DDims...> m_strides;
86
87public:
88 static KOKKOS_FUNCTION constexpr std::size_t rank()
89 {
90 return sizeof...(DDims);
91 }
92
94
95 /// Construct a StridedDiscreteDomain by copies and merge of domains
96 template <
97 class... DDoms,
98 class = std::enable_if_t<(is_strided_discrete_domain_v<DDoms> && ...)>>
99 KOKKOS_FUNCTION constexpr explicit StridedDiscreteDomain(DDoms const&... domains)
100 : m_element_begin(domains.front()...)
101 , m_extents(domains.extents()...)
102 , m_strides(domains.strides()...)
103 {
104 }
105
106 /** Construct a StridedDiscreteDomain starting from element_begin with size points.
107 * @param element_begin the lower bound in each direction
108 * @param extents the number of points in each direction
109 * @param strides the step between two elements
110 */
112 discrete_element_type const& element_begin,
113 discrete_vector_type const& extents,
114 discrete_vector_type const& strides)
115 : m_element_begin(element_begin)
116 , m_extents(extents)
117 , m_strides(strides)
118 {
119 }
120
122
124
126
128 = default;
129
131
132 template <class... ODims>
133 KOKKOS_FUNCTION constexpr bool operator==(StridedDiscreteDomain<ODims...> const& other) const
134 {
135 if (empty() && other.empty()) {
136 return true;
137 }
138 return m_element_begin == other.m_element_begin && m_extents == other.m_extents
139 && m_strides == other.m_strides;
140 }
141
142#if !defined(__cpp_impl_three_way_comparison) || __cpp_impl_three_way_comparison < 201902L
143 // In C++20, `a!=b` shall be automatically translated by the compiler to `!(a==b)`
144 template <class... ODims>
145 KOKKOS_FUNCTION constexpr bool operator!=(StridedDiscreteDomain<ODims...> const& other) const
146 {
147 return !(*this == other);
148 }
149#endif
150
151 KOKKOS_FUNCTION constexpr std::size_t size() const
152 {
153 return (1UL * ... * get<DDims>(m_extents));
154 }
155
156 KOKKOS_FUNCTION constexpr discrete_vector_type extents() const noexcept
157 {
158 return m_extents;
159 }
160
161 KOKKOS_FUNCTION constexpr discrete_vector_type strides() const noexcept
162 {
163 return m_strides;
164 }
165
166 template <class QueryDDim>
167 KOKKOS_FUNCTION constexpr DiscreteVector<QueryDDim> extent() const noexcept
168 {
169 return DiscreteVector<QueryDDim>(m_extents);
170 }
171
172 KOKKOS_FUNCTION constexpr discrete_element_type front() const noexcept
173 {
174 return m_element_begin;
175 }
176
177 KOKKOS_FUNCTION constexpr discrete_element_type back() const noexcept
178 {
179 return discrete_element_type(
180 (DiscreteElement<DDims>(m_element_begin)
181 + (get<DDims>(m_extents) - 1) * get<DDims>(m_strides))...);
182 }
183
184 KOKKOS_FUNCTION constexpr StridedDiscreteDomain take_first(discrete_vector_type n) const
185 {
186 return StridedDiscreteDomain(front(), n, m_strides);
187 }
188
189 KOKKOS_FUNCTION constexpr StridedDiscreteDomain take_last(discrete_vector_type n) const
190 {
191 return StridedDiscreteDomain(front() + prod(extents() - n, m_strides), n, m_strides);
192 }
193
194 KOKKOS_FUNCTION constexpr StridedDiscreteDomain remove_first(discrete_vector_type n) const
195 {
196 return StridedDiscreteDomain(front() + prod(n, m_strides), extents() - n, m_strides);
197 }
198
199 KOKKOS_FUNCTION constexpr StridedDiscreteDomain remove_last(discrete_vector_type n) const
200 {
201 return StridedDiscreteDomain(front(), extents() - n, m_strides);
202 }
203
205 discrete_vector_type n1,
206 discrete_vector_type n2) const
207 {
208 return StridedDiscreteDomain(front() + prod(n1, m_strides), extents() - n1 - n2, m_strides);
209 }
210
211 KOKKOS_FUNCTION constexpr DiscreteElement<DDims...> operator()(
212 DiscreteVector<DDims...> const& dvect) const noexcept
213 {
214 return m_element_begin + prod(dvect, m_strides);
215 }
216
217 template <class... DElems>
218 KOKKOS_FUNCTION bool contains(DElems const&... delems) const noexcept
219 {
220 static_assert(
221 sizeof...(DDims) == (0 + ... + DElems::size()),
222 "Invalid number of dimensions");
223 static_assert((is_discrete_element_v<DElems> && ...), "Expected DiscreteElements");
224 auto const test1
225 = ((DiscreteElement<DDims>(take<DDims>(delems...))
226 >= DiscreteElement<DDims>(m_element_begin))
227 && ...);
228 auto const test2
229 = ((DiscreteElement<DDims>(take<DDims>(delems...))
230 < (DiscreteElement<DDims>(m_element_begin)
231 + DiscreteVector<DDims>(m_extents) * DiscreteVector<DDims>(m_strides)))
232 && ...);
233 auto const test3
234 = ((((DiscreteElement<DDims>(take<DDims>(delems...))
235 - DiscreteElement<DDims>(m_element_begin))
236 % DiscreteVector<DDims>(m_strides))
237 == 0)
238 && ...);
239 return test1 && test2 && test3;
240 }
241
242 template <class... DElems>
244 DElems const&... delems) const noexcept
245 {
246 static_assert(
247 sizeof...(DDims) == (0 + ... + DElems::size()),
248 "Invalid number of dimensions");
249 static_assert((is_discrete_element_v<DElems> && ...), "Expected DiscreteElements");
250 assert(contains(delems...));
251 return DiscreteVector<DDims...>(
252 ((DiscreteElement<DDims>(take<DDims>(delems...))
253 - DiscreteElement<DDims>(m_element_begin))
254 / DiscreteVector<DDims>(m_strides))...);
255 }
256
257 KOKKOS_FUNCTION constexpr bool empty() const noexcept
258 {
259 return size() == 0;
260 }
261
262 KOKKOS_FUNCTION constexpr explicit operator bool()
263 {
264 return !empty();
265 }
266
267 template <
268 std::size_t N = sizeof...(DDims),
269 class DDim0 = std::enable_if_t<N == 1, std::tuple_element_t<0, std::tuple<DDims...>>>>
270 KOKKOS_FUNCTION auto begin() const
271 {
272 return StridedDiscreteDomainIterator<DDim0>(front(), m_strides);
273 }
274
275 template <
276 std::size_t N = sizeof...(DDims),
277 class DDim0 = std::enable_if_t<N == 1, std::tuple_element_t<0, std::tuple<DDims...>>>>
278 KOKKOS_FUNCTION auto end() const
279 {
281 DDim0>(m_element_begin + m_extents * m_strides, m_strides);
282 }
283
284 template <
285 std::size_t N = sizeof...(DDims),
286 class DDim0 = std::enable_if_t<N == 1, std::tuple_element_t<0, std::tuple<DDims...>>>>
287 KOKKOS_FUNCTION auto cbegin() const
288 {
289 return StridedDiscreteDomainIterator<DDim0>(front(), m_strides);
290 }
291
292 template <
293 std::size_t N = sizeof...(DDims),
294 class DDim0 = std::enable_if_t<N == 1, std::tuple_element_t<0, std::tuple<DDims...>>>>
295 KOKKOS_FUNCTION auto cend() const
296 {
298 DDim0>(m_element_begin + m_extents * m_strides, m_strides);
299 }
300
301 template <
302 std::size_t N = sizeof...(DDims),
303 class = std::enable_if_t<N == 1, std::tuple_element_t<0, std::tuple<DDims...>>>>
304 KOKKOS_FUNCTION constexpr decltype(auto) operator[](std::size_t n)
305 {
306 return begin()[n];
307 }
308
309 template <
310 std::size_t N = sizeof...(DDims),
311 class = std::enable_if_t<N == 1, std::tuple_element_t<0, std::tuple<DDims...>>>>
312 KOKKOS_FUNCTION constexpr decltype(auto) operator[](std::size_t n) const
313 {
314 return begin()[n];
315 }
316};
317
318template <>
320{
321 template <class...>
322 friend class StridedDiscreteDomain;
323
324public:
325 using discrete_element_type = DiscreteElement<>;
326
327 using discrete_vector_type = DiscreteVector<>;
328
329 static KOKKOS_FUNCTION constexpr std::size_t rank()
330 {
331 return 0;
332 }
333
335
336 // Construct a StridedDiscreteDomain from a reordered copy of `domain`
337 template <class... ODDims>
338 KOKKOS_FUNCTION constexpr explicit StridedDiscreteDomain(
339 [[maybe_unused]] StridedDiscreteDomain<ODDims...> const& domain)
340 {
341 }
342
343 /** Construct a StridedDiscreteDomain starting from element_begin with size points.
344 * @param element_begin the lower bound in each direction
345 * @param size the number of points in each direction
346 * @param strides the step between two elements
347 */
349 [[maybe_unused]] discrete_element_type const& element_begin,
350 [[maybe_unused]] discrete_vector_type const& size,
351 [[maybe_unused]] discrete_vector_type const& strides)
352 {
353 }
354
356
358
360
362 = default;
363
365
366 KOKKOS_FUNCTION constexpr bool operator==(
367 [[maybe_unused]] StridedDiscreteDomain const& other) const
368 {
369 return true;
370 }
371
372#if !defined(__cpp_impl_three_way_comparison) || __cpp_impl_three_way_comparison < 201902L
373 // In C++20, `a!=b` shall be automatically translated by the compiler to `!(a==b)`
374 KOKKOS_FUNCTION constexpr bool operator!=(StridedDiscreteDomain const& other) const
375 {
376 return !(*this == other);
377 }
378#endif
379
380 static KOKKOS_FUNCTION constexpr std::size_t size()
381 {
382 return 1;
383 }
384
385 static KOKKOS_FUNCTION constexpr discrete_vector_type extents() noexcept
386 {
387 return {};
388 }
389
390 static KOKKOS_FUNCTION constexpr discrete_element_type front() noexcept
391 {
392 return {};
393 }
394
395 static KOKKOS_FUNCTION constexpr discrete_element_type back() noexcept
396 {
397 return {};
398 }
399
401 [[maybe_unused]] discrete_vector_type n) const
402 {
403 return *this;
404 }
405
407 [[maybe_unused]] discrete_vector_type n) const
408 {
409 return *this;
410 }
411
413 [[maybe_unused]] discrete_vector_type n) const
414 {
415 return *this;
416 }
417
419 [[maybe_unused]] discrete_vector_type n) const
420 {
421 return *this;
422 }
423
425 [[maybe_unused]] discrete_vector_type n1,
426 [[maybe_unused]] discrete_vector_type n2) const
427 {
428 return *this;
429 }
430
431 KOKKOS_FUNCTION constexpr DiscreteElement<> operator()(
432 DiscreteVector<> const& /* dvect */) const noexcept
433 {
434 return {};
435 }
436
437 static KOKKOS_FUNCTION bool contains() noexcept
438 {
439 return true;
440 }
441
442 static KOKKOS_FUNCTION bool contains(DiscreteElement<>) noexcept
443 {
444 return true;
445 }
446
448 {
449 return {};
450 }
451
452 static KOKKOS_FUNCTION DiscreteVector<> distance_from_front(DiscreteElement<>) noexcept
453 {
454 return {};
455 }
456
457 static KOKKOS_FUNCTION constexpr bool empty() noexcept
458 {
459 return false;
460 }
461
462 KOKKOS_FUNCTION constexpr explicit operator bool()
463 {
464 return true;
465 }
466};
467
468template <class... QueryDDims, class... DDims>
469KOKKOS_FUNCTION constexpr StridedDiscreteDomain<QueryDDims...> select(
470 StridedDiscreteDomain<DDims...> const& domain)
471{
472 return StridedDiscreteDomain<QueryDDims...>(
473 DiscreteElement<QueryDDims...>(domain.front()),
474 DiscreteVector<QueryDDims...>(domain.extents()),
475 DiscreteVector<QueryDDims...>(domain.strides()));
476}
477
478namespace detail {
479
480template <class T>
481struct ConvertTypeSeqToStridedDiscreteDomain;
482
483template <class... DDims>
484struct ConvertTypeSeqToStridedDiscreteDomain<detail::TypeSeq<DDims...>>
485{
486 using type = StridedDiscreteDomain<DDims...>;
487};
488
489template <class T>
490using convert_type_seq_to_strided_discrete_domain_t =
491 typename ConvertTypeSeqToStridedDiscreteDomain<T>::type;
492
493} // namespace detail
494
495// Computes the subtraction DDom_a - DDom_b in the sense of linear spaces(retained dimensions are those in DDom_a which are not in DDom_b)
496template <class... DDimsA, class... DDimsB>
497KOKKOS_FUNCTION constexpr auto remove_dims_of(
498 StridedDiscreteDomain<DDimsA...> const& DDom_a,
499 [[maybe_unused]] StridedDiscreteDomain<DDimsB...> const& DDom_b) noexcept
500{
501 using TagSeqA = detail::TypeSeq<DDimsA...>;
502 using TagSeqB = detail::TypeSeq<DDimsB...>;
503
504 using type_seq_r = type_seq_remove_t<TagSeqA, TagSeqB>;
505 return detail::convert_type_seq_to_strided_discrete_domain_t<type_seq_r>(DDom_a);
506}
507
508//! Remove the dimensions DDimsB from DDom_a
509//! @param[in] DDom_a The discrete domain on which to remove dimensions
510//! @return The discrete domain without DDimsB dimensions
511template <class... DDimsB, class... DDimsA>
512KOKKOS_FUNCTION constexpr auto remove_dims_of(
513 StridedDiscreteDomain<DDimsA...> const& DDom_a) noexcept
514{
515 using TagSeqA = detail::TypeSeq<DDimsA...>;
516 using TagSeqB = detail::TypeSeq<DDimsB...>;
517
518 using type_seq_r = type_seq_remove_t<TagSeqA, TagSeqB>;
519 return detail::convert_type_seq_to_strided_discrete_domain_t<type_seq_r>(DDom_a);
520}
521
522namespace detail {
523
524// Checks if dimension of DDom_a is DDim1. If not, returns restriction to DDim2 of DDom_b. May not be useful in its own, it helps for replace_dim_of
525template <typename DDim1, typename DDim2, typename DDimA, typename... DDimsB>
526KOKKOS_FUNCTION constexpr std::conditional_t<
527 std::is_same_v<DDimA, DDim1>,
530replace_dim_of_1d(
531 StridedDiscreteDomain<DDimA> const& DDom_a,
532 [[maybe_unused]] StridedDiscreteDomain<DDimsB...> const& DDom_b) noexcept
533{
534 if constexpr (std::is_same_v<DDimA, DDim1>) {
535 return ddc::StridedDiscreteDomain<DDim2>(DDom_b);
536 } else {
537 return DDom_a;
538 }
539}
540
541} // namespace detail
542
543// Replace in DDom_a the dimension Dim1 by the dimension Dim2 of DDom_b
544template <typename DDim1, typename DDim2, typename... DDimsA, typename... DDimsB>
545KOKKOS_FUNCTION constexpr auto replace_dim_of(
546 StridedDiscreteDomain<DDimsA...> const& DDom_a,
547 [[maybe_unused]] StridedDiscreteDomain<DDimsB...> const& DDom_b) noexcept
548{
549 // TODO : static_asserts
550 using TagSeqA = detail::TypeSeq<DDimsA...>;
551 using TagSeqB = detail::TypeSeq<DDim1>;
552 using TagSeqC = detail::TypeSeq<DDim2>;
553
554 using type_seq_r = ddc::type_seq_replace_t<TagSeqA, TagSeqB, TagSeqC>;
555 return ddc::detail::convert_type_seq_to_strided_discrete_domain_t<type_seq_r>(
556 detail::replace_dim_of_1d<
557 DDim1,
558 DDim2,
559 DDimsA,
560 DDimsB...>(ddc::StridedDiscreteDomain<DDimsA>(DDom_a), DDom_b)...);
561}
562
563template <class... QueryDDims, class... DDims>
564KOKKOS_FUNCTION constexpr DiscreteVector<QueryDDims...> extents(
565 StridedDiscreteDomain<DDims...> const& domain) noexcept
566{
567 return DiscreteVector<QueryDDims...>(StridedDiscreteDomain<QueryDDims>(domain).size()...);
568}
569
570template <class... QueryDDims, class... DDims>
571KOKKOS_FUNCTION constexpr DiscreteElement<QueryDDims...> front(
572 StridedDiscreteDomain<DDims...> const& domain) noexcept
573{
574 return DiscreteElement<QueryDDims...>(StridedDiscreteDomain<QueryDDims>(domain).front()...);
575}
576
577template <class... QueryDDims, class... DDims>
578KOKKOS_FUNCTION constexpr DiscreteElement<QueryDDims...> back(
579 StridedDiscreteDomain<DDims...> const& domain) noexcept
580{
581 return DiscreteElement<QueryDDims...>(StridedDiscreteDomain<QueryDDims>(domain).back()...);
582}
583
584template <class DDim>
586{
587private:
588 DiscreteElement<DDim> m_value = DiscreteElement<DDim>();
589
590 DiscreteVector<DDim> m_stride = DiscreteVector<DDim>();
591
592public:
593 using iterator_category = std::random_access_iterator_tag;
594
595 using value_type = DiscreteElement<DDim>;
596
597 using difference_type = std::ptrdiff_t;
598
600
602 DiscreteElement<DDim> value,
603 DiscreteVector<DDim> stride)
604 : m_value(value)
605 , m_stride(stride)
606 {
607 }
608
609 KOKKOS_FUNCTION constexpr DiscreteElement<DDim> operator*() const noexcept
610 {
611 return m_value;
612 }
613
615 {
616 m_value += m_stride;
617 return *this;
618 }
619
621 {
622 auto tmp = *this;
623 ++*this;
624 return tmp;
625 }
626
628 {
629 m_value -= m_stride;
630 return *this;
631 }
632
634 {
635 auto tmp = *this;
636 --*this;
637 return tmp;
638 }
639
640 KOKKOS_FUNCTION constexpr StridedDiscreteDomainIterator& operator+=(difference_type n)
641 {
642 if (n >= difference_type(0)) {
643 m_value += static_cast<DiscreteElementType>(n) * m_stride;
644 } else {
645 m_value -= static_cast<DiscreteElementType>(-n) * m_stride;
646 }
647 return *this;
648 }
649
650 KOKKOS_FUNCTION constexpr StridedDiscreteDomainIterator& operator-=(difference_type n)
651 {
652 if (n >= difference_type(0)) {
653 m_value -= static_cast<DiscreteElementType>(n) * m_stride;
654 } else {
655 m_value += static_cast<DiscreteElementType>(-n) * m_stride;
656 }
657 return *this;
658 }
659
660 KOKKOS_FUNCTION constexpr DiscreteElement<DDim> operator[](difference_type n) const
661 {
662 return m_value + n * m_stride;
663 }
664
665 friend KOKKOS_FUNCTION constexpr bool operator==(
668 {
669 return xx.m_value == yy.m_value;
670 }
671
672#if !defined(__cpp_impl_three_way_comparison) || __cpp_impl_three_way_comparison < 201902L
673 // In C++20, `a!=b` shall be automatically translated by the compiler to `!(a==b)`
674 friend KOKKOS_FUNCTION constexpr bool operator!=(
677 {
678 return xx.m_value != yy.m_value;
679 }
680#endif
681
682 friend KOKKOS_FUNCTION constexpr bool operator<(
685 {
686 return xx.m_value < yy.m_value;
687 }
688
689 friend KOKKOS_FUNCTION constexpr bool operator>(
692 {
693 return yy < xx;
694 }
695
696 friend KOKKOS_FUNCTION constexpr bool operator<=(
699 {
700 return !(yy < xx);
701 }
702
703 friend KOKKOS_FUNCTION constexpr bool operator>=(
706 {
707 return !(xx < yy);
708 }
709
712 difference_type n)
713 {
714 return i += n;
715 }
716
718 difference_type n,
720 {
721 return i += n;
722 }
723
726 difference_type n)
727 {
728 return i -= n;
729 }
730
731 friend KOKKOS_FUNCTION constexpr difference_type operator-(
734 {
735 return (yy.m_value > xx.m_value) ? (-static_cast<difference_type>(yy.m_value - xx.m_value))
736 : (xx.m_value - yy.m_value);
737 }
738};
739
740} // namespace ddc
KOKKOS_DEFAULTED_FUNCTION constexpr DiscreteElement()=default
KOKKOS_FUNCTION constexpr bool operator!=(DiscreteVector< OTags... > const &rhs) const noexcept
KOKKOS_DEFAULTED_FUNCTION constexpr DiscreteVector()=default
static KOKKOS_FUNCTION DiscreteVector distance_from_front() noexcept
KOKKOS_DEFAULTED_FUNCTION StridedDiscreteDomain & operator=(StridedDiscreteDomain &&x)=default
static KOKKOS_FUNCTION constexpr std::size_t size()
KOKKOS_FUNCTION constexpr StridedDiscreteDomain(discrete_element_type const &element_begin, discrete_vector_type const &size, discrete_vector_type const &strides)
Construct a StridedDiscreteDomain starting from element_begin with size points.
static KOKKOS_FUNCTION bool contains(DiscreteElement<>) noexcept
KOKKOS_FUNCTION constexpr StridedDiscreteDomain remove_first(discrete_vector_type n) const
static KOKKOS_FUNCTION constexpr discrete_element_type front() noexcept
KOKKOS_FUNCTION constexpr StridedDiscreteDomain remove(discrete_vector_type n1, discrete_vector_type n2) const
static KOKKOS_FUNCTION bool contains() noexcept
KOKKOS_FUNCTION constexpr StridedDiscreteDomain remove_last(discrete_vector_type n) const
KOKKOS_FUNCTION constexpr StridedDiscreteDomain take_last(discrete_vector_type n) const
static KOKKOS_FUNCTION constexpr discrete_vector_type extents() noexcept
static KOKKOS_FUNCTION constexpr std::size_t rank()
KOKKOS_DEFAULTED_FUNCTION StridedDiscreteDomain(StridedDiscreteDomain &&x)=default
static KOKKOS_FUNCTION DiscreteVector distance_from_front(DiscreteElement<>) noexcept
KOKKOS_DEFAULTED_FUNCTION constexpr StridedDiscreteDomain()=default
KOKKOS_FUNCTION constexpr operator bool()
static KOKKOS_FUNCTION constexpr bool empty() noexcept
KOKKOS_DEFAULTED_FUNCTION StridedDiscreteDomain(StridedDiscreteDomain const &x)=default
KOKKOS_FUNCTION constexpr DiscreteElement operator()(DiscreteVector<> const &) const noexcept
static KOKKOS_FUNCTION constexpr discrete_element_type back() noexcept
KOKKOS_FUNCTION constexpr bool operator==(StridedDiscreteDomain const &other) const
KOKKOS_DEFAULTED_FUNCTION ~StridedDiscreteDomain()=default
KOKKOS_FUNCTION constexpr StridedDiscreteDomain take_first(discrete_vector_type n) const
KOKKOS_FUNCTION constexpr StridedDiscreteDomain(StridedDiscreteDomain< ODDims... > const &domain)
KOKKOS_DEFAULTED_FUNCTION StridedDiscreteDomain & operator=(StridedDiscreteDomain const &x)=default
KOKKOS_DEFAULTED_FUNCTION StridedDiscreteDomain & operator=(StridedDiscreteDomain const &x)=default
KOKKOS_FUNCTION constexpr discrete_vector_type extents() const noexcept
KOKKOS_FUNCTION constexpr operator bool()
KOKKOS_FUNCTION constexpr StridedDiscreteDomain take_first(discrete_vector_type n) const
KOKKOS_FUNCTION constexpr DiscreteVector< QueryDDim > extent() const noexcept
KOKKOS_FUNCTION constexpr discrete_element_type front() const noexcept
KOKKOS_FUNCTION bool contains(DElems const &... delems) const noexcept
KOKKOS_FUNCTION constexpr std::size_t size() const
KOKKOS_FUNCTION auto cend() const
KOKKOS_FUNCTION constexpr StridedDiscreteDomain(DDoms const &... domains)
Construct a StridedDiscreteDomain by copies and merge of domains.
KOKKOS_FUNCTION DiscreteVector< DDims... > distance_from_front(DElems const &... delems) const noexcept
KOKKOS_DEFAULTED_FUNCTION StridedDiscreteDomain(StridedDiscreteDomain &&x)=default
KOKKOS_FUNCTION constexpr discrete_vector_type strides() const noexcept
KOKKOS_DEFAULTED_FUNCTION StridedDiscreteDomain & operator=(StridedDiscreteDomain &&x)=default
KOKKOS_FUNCTION constexpr StridedDiscreteDomain remove(discrete_vector_type n1, discrete_vector_type n2) const
KOKKOS_FUNCTION constexpr StridedDiscreteDomain remove_first(discrete_vector_type n) const
KOKKOS_FUNCTION constexpr discrete_element_type back() const noexcept
KOKKOS_DEFAULTED_FUNCTION StridedDiscreteDomain()=default
KOKKOS_FUNCTION constexpr DiscreteElement< DDims... > operator()(DiscreteVector< DDims... > const &dvect) const noexcept
KOKKOS_FUNCTION auto begin() const
KOKKOS_FUNCTION auto end() const
KOKKOS_FUNCTION constexpr StridedDiscreteDomain remove_last(discrete_vector_type n) const
KOKKOS_FUNCTION constexpr StridedDiscreteDomain take_last(discrete_vector_type n) const
KOKKOS_DEFAULTED_FUNCTION ~StridedDiscreteDomain()=default
KOKKOS_DEFAULTED_FUNCTION StridedDiscreteDomain(StridedDiscreteDomain const &x)=default
KOKKOS_FUNCTION constexpr bool operator==(StridedDiscreteDomain< ODims... > const &other) const
KOKKOS_FUNCTION constexpr decltype(auto) operator[](std::size_t n)
static KOKKOS_FUNCTION constexpr std::size_t rank()
KOKKOS_FUNCTION auto cbegin() const
KOKKOS_FUNCTION constexpr bool empty() const noexcept
KOKKOS_FUNCTION constexpr decltype(auto) operator[](std::size_t n) const
KOKKOS_FUNCTION constexpr StridedDiscreteDomain(discrete_element_type const &element_begin, discrete_vector_type const &extents, discrete_vector_type const &strides)
Construct a StridedDiscreteDomain starting from element_begin with size points.
The top-level namespace of DDC.
KOKKOS_FUNCTION constexpr auto remove_dims_of(StridedDiscreteDomain< DDimsA... > const &DDom_a, StridedDiscreteDomain< DDimsB... > const &DDom_b) noexcept
KOKKOS_FUNCTION constexpr DiscreteElement< QueryDDims... > front(StridedDiscreteDomain< DDims... > const &domain) noexcept
KOKKOS_FUNCTION constexpr DiscreteVector< QueryDDims... > extents(StridedDiscreteDomain< DDims... > const &domain) noexcept
KOKKOS_FUNCTION constexpr DiscreteElement< QueryDDims... > back(StridedDiscreteDomain< DDims... > const &domain) noexcept
KOKKOS_FUNCTION constexpr StridedDiscreteDomain< QueryDDims... > select(StridedDiscreteDomain< DDims... > const &domain)
KOKKOS_FUNCTION constexpr auto remove_dims_of(StridedDiscreteDomain< DDimsA... > const &DDom_a) noexcept
Remove the dimensions DDimsB from DDom_a.
constexpr bool is_strided_discrete_domain_v
KOKKOS_FUNCTION DiscreteVector< ODDims... > prod(DiscreteVector< ODDims... > const &lhs, DiscreteVector< ODDims... > const &rhs) noexcept
KOKKOS_FUNCTION constexpr auto replace_dim_of(StridedDiscreteDomain< DDimsA... > const &DDom_a, StridedDiscreteDomain< DDimsB... > const &DDom_b) noexcept
friend KOKKOS_FUNCTION constexpr StridedDiscreteDomainIterator operator-(StridedDiscreteDomainIterator i, difference_type n)
KOKKOS_FUNCTION constexpr DiscreteElement< DDim > operator*() const noexcept
KOKKOS_FUNCTION constexpr StridedDiscreteDomainIterator & operator++()
friend KOKKOS_FUNCTION constexpr StridedDiscreteDomainIterator operator+(difference_type n, StridedDiscreteDomainIterator i)
KOKKOS_FUNCTION constexpr StridedDiscreteDomainIterator & operator-=(difference_type n)
KOKKOS_FUNCTION constexpr StridedDiscreteDomainIterator operator++(int)
friend KOKKOS_FUNCTION constexpr bool operator<(StridedDiscreteDomainIterator const &xx, StridedDiscreteDomainIterator const &yy)
KOKKOS_DEFAULTED_FUNCTION StridedDiscreteDomainIterator()=default
KOKKOS_FUNCTION constexpr StridedDiscreteDomainIterator operator--(int)
friend KOKKOS_FUNCTION constexpr bool operator==(StridedDiscreteDomainIterator const &xx, StridedDiscreteDomainIterator const &yy)
KOKKOS_FUNCTION constexpr StridedDiscreteDomainIterator(DiscreteElement< DDim > value, DiscreteVector< DDim > stride)
KOKKOS_FUNCTION constexpr StridedDiscreteDomainIterator & operator+=(difference_type n)
KOKKOS_FUNCTION constexpr DiscreteElement< DDim > operator[](difference_type n) const
friend KOKKOS_FUNCTION constexpr difference_type operator-(StridedDiscreteDomainIterator const &xx, StridedDiscreteDomainIterator const &yy)
KOKKOS_FUNCTION constexpr StridedDiscreteDomainIterator & operator--()
friend KOKKOS_FUNCTION constexpr bool operator>=(StridedDiscreteDomainIterator const &xx, StridedDiscreteDomainIterator const &yy)
friend KOKKOS_FUNCTION constexpr StridedDiscreteDomainIterator operator+(StridedDiscreteDomainIterator i, difference_type n)
friend KOKKOS_FUNCTION constexpr bool operator>(StridedDiscreteDomainIterator const &xx, StridedDiscreteDomainIterator const &yy)
friend KOKKOS_FUNCTION constexpr bool operator!=(StridedDiscreteDomainIterator const &xx, StridedDiscreteDomainIterator const &yy)
friend KOKKOS_FUNCTION constexpr bool operator<=(StridedDiscreteDomainIterator const &xx, StridedDiscreteDomainIterator const &yy)