Ginkgo: ginkgo/core/base/index_set.hpp Source File

| Ginkgo Generated from branch based on main. Ginkgo version 1.11.0 A numerical linear algebra library targeting many-core architectures

Loading...
Searching...
No Matches
index_set.hpp
1// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
2//
3// SPDX-License-Identifier: BSD-3-Clause
4
5#ifndef GKO_PUBLIC_CORE_BASE_INDEX_SET_HPP_
6#define GKO_PUBLIC_CORE_BASE_INDEX_SET_HPP_
7
8
9#include <algorithm>
10#include <initializer_list>
11#include <mutex>
12#include <vector>
13
14#include <ginkgo/core/base/array.hpp>
15#include <ginkgo/core/base/exception_helpers.hpp>
16#include <ginkgo/core/base/executor.hpp>
17#include <ginkgo/core/base/types.hpp>
18#include <ginkgo/core/base/utils.hpp>
19
20
21namespace gko {
22
23
55template <typename IndexType = int32>
56 class index_set {
57public:
61 using index_type = IndexType;
62
68 explicit index_set(std::shared_ptr<const Executor> exec) noexcept
69 : exec_(std::move(exec)),
70 index_space_size_{0},
71 num_stored_indices_{0},
72 subsets_begin_{array<index_type>(exec_)},
73 subsets_end_{array<index_type>(exec_)},
74 superset_cumulative_indices_{array<index_type>(exec_)}
75 {}
76
86 explicit index_set(std::shared_ptr<const gko::Executor> exec,
87 std::initializer_list<IndexType> init_list,
88 const bool is_sorted = false)
89 : exec_(std::move(exec)),
90 index_space_size_(init_list.size() > 0
91 ? *(std::max_element(std::begin(init_list),
92 std::end(init_list))) +
93 1
94 : 0),
95 num_stored_indices_{static_cast<IndexType>(init_list.size())}
96 {
97 GKO_ASSERT(index_space_size_ > 0);
98 this->populate_subsets(
99 array<IndexType>(this->get_executor(), init_list), is_sorted);
100 }
101
112 explicit index_set(std::shared_ptr<const gko::Executor> exec,
113 const index_type size,
114 const gko::array<index_type>& indices,
115 const bool is_sorted = false)
116 : exec_(std::move(exec)), index_space_size_(size)
117 {
118 GKO_ASSERT(index_space_size_ >= indices.get_size());
119 this->populate_subsets(indices, is_sorted);
120 }
121
128 index_set(std::shared_ptr<const Executor> exec, const index_set& other)
129 : index_set(exec)
130 {
131 *this = other;
132 }
133
139 index_set(const index_set& other) : index_set(other.get_executor(), other)
140 {}
141
148 index_set(std::shared_ptr<const Executor> exec, index_set&& other)
149 : index_set(exec)
150 {
151 *this = std::move(other);
152 }
153
159 index_set(index_set&& other)
160 : index_set(other.get_executor(), std::move(other))
161 {}
162
173 index_set& operator=(const index_set& other)
174 {
175 if (&other == this) {
176 return *this;
177 }
178 this->index_space_size_ = other.index_space_size_;
179 this->num_stored_indices_ = other.num_stored_indices_;
180 this->subsets_begin_ = other.subsets_begin_;
181 this->subsets_end_ = other.subsets_end_;
182 this->superset_cumulative_indices_ = other.superset_cumulative_indices_;
183
184 return *this;
185 }
186
197 index_set& operator=(index_set&& other)
198 {
199 if (&other == this) {
200 return *this;
201 }
202 this->index_space_size_ = std::exchange(other.index_space_size_, 0);
203 this->num_stored_indices_ = std::exchange(other.num_stored_indices_, 0);
204 this->subsets_begin_ = std::move(other.subsets_begin_);
205 this->subsets_end_ = std::move(other.subsets_end_);
206 this->superset_cumulative_indices_ =
207 std::move(other.superset_cumulative_indices_);
208
209 return *this;
210 }
211
219 void clear() noexcept
220 {
221 this->index_space_size_ = 0;
222 this->num_stored_indices_ = 0;
223 this->subsets_begin_.clear();
224 this->subsets_end_.clear();
225 this->superset_cumulative_indices_.clear();
226 }
227
233 std::shared_ptr<const Executor> get_executor() const { return this->exec_; }
234
240 index_type get_size() const { return this->index_space_size_; }
241
247 bool is_contiguous() const { return (this->get_num_subsets() <= 1); }
248
254 index_type get_num_elems() const { return this->num_stored_indices_; };
255
275 index_type get_global_index(index_type local_index) const;
276
297 index_type get_local_index(index_type global_index) const;
298
313 array<index_type> map_local_to_global(
314 const array<index_type>& local_indices,
315 const bool is_sorted = false) const;
316
329 array<index_type> map_global_to_local(
330 const array<index_type>& global_indices,
331 const bool is_sorted = false) const;
332
339 array<index_type> to_global_indices() const;
340
351 array<bool> contains(const array<index_type>& global_indices,
352 const bool is_sorted = false) const;
353
364 bool contains(const index_type global_index) const;
365
371 index_type get_num_subsets() const
372 {
373 return this->subsets_begin_.get_size();
374 }
375
381 const index_type* get_subsets_begin() const
382 {
383 return this->subsets_begin_.get_const_data();
384 }
385
391 const index_type* get_subsets_end() const
392 {
393 return this->subsets_end_.get_const_data();
394 }
395
403 const index_type* get_superset_indices() const
404 {
405 return this->superset_cumulative_indices_.get_const_data();
406 }
407
408private:
409 void populate_subsets(const gko::array<index_type>& indices,
410 const bool is_sorted);
411
412 std::shared_ptr<const Executor> exec_;
413 index_type index_space_size_;
414 index_type num_stored_indices_;
415 gko::array<index_type> subsets_begin_;
416 gko::array<index_type> subsets_end_;
417 gko::array<index_type> superset_cumulative_indices_;
418};
419
420
421} // namespace gko
422
423
424#endif // GKO_PUBLIC_CORE_BASE_INDEX_SET_HPP_
gko::array
An array is a container which encapsulates fixed-sized arrays, stored on the Executor tied to the arr...
Definition array.hpp:166
gko::array::get_size
size_type get_size() const noexcept
Returns the number of elements in the array.
Definition array.hpp:670
gko::index_set::index_set
index_set(const index_set &other)
Creates a copy of the input index_set.
Definition index_set.hpp:139
gko::index_set::operator=
index_set & operator=(index_set &&other)
Moves data from another index_set.
Definition index_set.hpp:197
gko::index_set::to_global_indices
array< index_type > to_global_indices() const
This function allows the user obtain a decompressed global_indices array from the indices stored in t...
gko::index_set::get_subsets_begin
const index_type * get_subsets_begin() const
Returns a pointer to the beginning indices of the subsets.
Definition index_set.hpp:381
gko::index_set::get_num_elems
index_type get_num_elems() const
Return the actual number of indices stored in the index set.
Definition index_set.hpp:254
gko::index_set::get_global_index
index_type get_global_index(index_type local_index) const
Return the global index given a local index.
gko::index_set::contains
array< bool > contains(const array< index_type > &global_indices, const bool is_sorted=false) const
Checks if the individual global indeices exist in the index set.
gko::index_set::index_type
IndexType index_type
The type of elements stored in the index set.
Definition index_set.hpp:61
gko::index_set::get_subsets_end
const index_type * get_subsets_end() const
Returns a pointer to the end indices of the subsets.
Definition index_set.hpp:391
gko::index_set::get_executor
std::shared_ptr< const Executor > get_executor() const
Returns the executor of the index_set.
Definition index_set.hpp:233
gko::index_set::clear
void clear() noexcept
Deallocates all data used by the index_set.
Definition index_set.hpp:219
gko::index_set::index_set
index_set(std::shared_ptr< const Executor > exec) noexcept
Creates an empty index_set tied to the specified Executor.
Definition index_set.hpp:68
gko::index_set::get_local_index
index_type get_local_index(index_type global_index) const
Return the local index given a global index.
gko::index_set::index_set
index_set(index_set &&other)
Moves the input index_set.
Definition index_set.hpp:159
gko::index_set::map_global_to_local
array< index_type > map_global_to_local(const array< index_type > &global_indices, const bool is_sorted=false) const
This is an array version of the scalar function above.
gko::index_set::index_set
index_set(std::shared_ptr< const gko::Executor > exec, std::initializer_list< IndexType > init_list, const bool is_sorted=false)
Creates an index set on the specified executor from the initializer list.
Definition index_set.hpp:86
gko::index_set::get_num_subsets
index_type get_num_subsets() const
Returns the number of subsets stored in the index set.
Definition index_set.hpp:371
gko::index_set::index_set
index_set(std::shared_ptr< const Executor > exec, index_set &&other)
Moves the input index_set to a different executor.
Definition index_set.hpp:148
gko::index_set::contains
bool contains(const index_type global_index) const
Checks if the global index exists in the index set.
gko::index_set::operator=
index_set & operator=(const index_set &other)
Copies data from another index_set.
Definition index_set.hpp:173
gko::index_set::is_contiguous
bool is_contiguous() const
Returns if the index set is contiguous.
Definition index_set.hpp:247
gko::index_set::index_set
index_set(std::shared_ptr< const gko::Executor > exec, const index_type size, const gko::array< index_type > &indices, const bool is_sorted=false)
Creates an index set on the specified executor and the given size.
Definition index_set.hpp:112
gko::index_set::map_local_to_global
array< index_type > map_local_to_global(const array< index_type > &local_indices, const bool is_sorted=false) const
This is an array version of the scalar function above.
gko::index_set::get_superset_indices
const index_type * get_superset_indices() const
Returns a pointer to the cumulative indices of the superset of the subsets.
Definition index_set.hpp:403
gko::index_set::index_set
index_set(std::shared_ptr< const Executor > exec, const index_set &other)
Creates a copy of the input index_set on a different executor.
Definition index_set.hpp:128
gko::index_set::get_size
index_type get_size() const
Returns the size of the index set space.
Definition index_set.hpp:240
gko
The Ginkgo namespace.
Definition abstract_factory.hpp:20
std
STL namespace.