Array¶
Defined in header <Kokkos_Array.hpp> which is included from <Kokkos_Core.hpp>
Array is a contiguous aggregate owning container storing a fixed size sequence of objects (models holding exactly N elements).
This is intended as a replacement for std::array<T, N>.
This container is an owning container (the data is embedded in the container itself).
This container is an aggregate type with the same semantics as a struct holding a C-style array T[N] as its only non-static data member when N > 0; otherwise, it is an empty container.
Unlike a C-style array, it doesn’t decay to T* automatically.
As an aggregate type, it can be initialized with aggregate-initialization given at most N initializers that are convertible to T: Kokkos::Array<int, 3> a = { 1, 2, 3 };.
Changed in version 4.4.0.
Template Parameters
T – The type of the element being stored.
N – The number of elements being stored.
Public Types
Public Member Functions
N == 0
N
iType – An integral type or an unscoped enum type.
A reference to the i-th element of the array.
A pointer to the first element of the array. If N == 0, the return value is unspecified and not dereferenceable.
true if and only if ∀ the elements in l and r compare equal.
!(l == r)
If T is swappable or N == 0, each of the elements in l and r are swapped via kokkos_swap.
An Array containing the elements copied/moved from a.
a[I] for (tuple protocol / structured binding support)
std::move(a[I]) (for tuple protocol / structured binding support)
a.data()
a.data() + a.size()
Deprecated since version 4.4.00.
The primary template was an contiguous aggregate owning container of exactly N elements of type T.
This container did not support move semantics.
This container was an empty container.
This container was a non-owning container.
This container had its size determined at construction time.
This container could be assigned from any Array<T, N , Proxy>.
Assignment did not change the size of this container.
This container did not support move semantics.
This container was a non-owning container.
This container had its size and stride determined at construction time.
This container could be assigned from any Array<T, N , Proxy>.
Assignment did not change the size or stride of this container.
This container did not support move semantics.
Public Types
This specialization defined the embedded tag types: contiguous and strided.
#include "Kokkos_Core.hpp"
#include <algorithm>
#include <iostream>
#include <iterator>
#include <memory>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
// creates a constexpr array of string_view's
constexpr auto w1n = Kokkos::to_array<std::string_view>(
{"Mary", "Patricia", "Linda", "Barbara", "Elizabeth", "Jennifer"});
static_assert(
std::is_same_v<decltype(w1n), const Kokkos::Array<std::string_view, 6>>);
static_assert(w1n.size() == 6 and w1n[5] == "Jennifer");
extern int Main(int /* argc */, char const *const /* argv */[]);
int Main(int /* argc */, char const *const /* argv */[]) {
Kokkos::ScopeGuard _;
// Construction uses aggregate initialization
[[maybe_unused]] Kokkos::Array<int, 3> a1{
{1, 2, 3}}; // Double-braces required in C++11
// and still allowed in C++14 and beyond
Kokkos::Array<int, 3> a2 = {1, 2, 3}; // Double braces never required after =
// Output is 3 2 1
std::reverse_copy(std::data(a2), end(a2),
std::ostream_iterator<int>(std::cout, " "));
std::cout << '\n';
// Ranged for loop is supported
// Output is E Ǝ
Kokkos::Array<std::string, 2> a3{"E", "\u018E"};
for (const auto &s : a3)
std::cout << s << ' ';
std::cout << '\n';
// Deduction guide for array creation
[[maybe_unused]] Kokkos::Array a4{3.0, 1.0, 4.0}; // Kokkos::Array<double, 3>
// Behavior of unspecified elements is the same as with built-in arrays
[[maybe_unused]] Kokkos::Array<int, 2> a5; // No list init, a5[0] and a5[1]
// are default initialized
[[maybe_unused]] Kokkos::Array<int, 2>
a6{}; // List init, both elements are value
// initialized, a6[0] = a6[1] = 0
[[maybe_unused]] Kokkos::Array<int, 2> a7{
1}; // List init, unspecified element is value
// initialized, a7[0] = 1, a7[1] = 0
// copies a string literal
auto t1 = Kokkos::to_array("foo");
static_assert(t1.size() == 4);
// deduces both element type and length
auto t2 = Kokkos::to_array({0, 2, 1, 3});
static_assert(std::is_same_v<decltype(t2), Kokkos::Array<int, 4>>);
// deduces length with element type specified
// implicit conversion happens
auto t3 = Kokkos::to_array<long>({0, 1, 3});
static_assert(std::is_same_v<decltype(t3), Kokkos::Array<long, 3>>);
auto t4 = Kokkos::to_array<std::pair<int, float>>(
{{3, 0.0f}, {4, 0.1f}, {4, 0.1e23f}});
static_assert(t4.size() == 3);
// creates a non-copyable Kokkos::Array
auto t5 = Kokkos::to_array({std::make_unique<int>(3)});
static_assert(t5.size() == 1);
// error: copying multidimensional arrays is not supported
// char s[2][6] = {"nice", "thing"};
// auto t6 = Kokkos::to_array(s);
return 0;
}
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4