atlas::array namespace

Contains classes to operate with multidimensional arrays.

Classes

class Array
template<typename Value>
class ArrayT
class ArrayDataStore
class ArrayLayout
class ArrayAlignment
class ArrayShape
class ArraySpec
class ArrayStrides
template<typename Value, int Rank>
class LocalView
Multi-dimensional access existing POD array pointer.
class Range
template<typename T>
class SVector
template<typename T>
class Vector
template<typename T>
class VectorView
template<typename Value, int Rank>
class ArrayView
template<typename Value, int Rank>
class IndexView
class DataType

Typedefs

using ArrayIdx = std::vector<idx_t>
using ArrayViewVariant = detail::Variant<detail::VariantValueTypes, detail::VariantRanks>
Variant containing all supported non-const ArrayView alternatives.
using ConstArrayViewVariant = detail::Variant<detail::VariantValueTypes::add_const, detail::VariantRanks>
Variant containing all supported const ArrayView alternatives.
template<typename Value, int Rank>
using View = LocalView<Value, Rank>

Functions

template<typename... idx_t>
auto make_idx(idx_t... indices) -> ArrayIdx
template<typename... idx_t>
auto make_layout(idx_t... indices) -> ArrayLayout
auto make_shape(std::initializer_list<idx_t> sizes) -> ArrayShape
template<typename... idx_t>
auto make_shape(idx_t... indices) -> ArrayShape
auto make_strides(std::initializer_list<idx_t> sizes) -> ArrayStrides
template<typename... idx_t>
auto make_strides(idx_t... indices) -> ArrayStrides
auto make_view_variant(Array& array) -> ArrayViewVariant
Create an ArrayView and assign to an ArrayViewVariant.
auto make_view_variant(const Array& array) -> ConstArrayViewVariant
Create a const ArrayView and assign to an ArrayViewVariant.
auto make_host_view_variant(Array& array) -> ArrayViewVariant
Create a host ArrayView and assign to an ArrayViewVariant.
auto make_host_view_variant(const Array& array) -> ConstArrayViewVariant
Create a const host ArrayView and assign to an ArrayViewVariant.
auto make_device_view_variant(Array& array) -> ArrayViewVariant
Create a device ArrayView and assign to an ArrayViewVariant.
auto make_device_view_variant(const Array& array) -> ConstArrayViewVariant
Create a const device ArrayView and assign to an ArrayViewVariant.
template<int... Ranks, typename View>
auto is_rank(const View&) -> bool constexpr
Return true if View::rank() is any of Ranks...
template<typename... ValueTypes, typename View>
auto is_value_type(const View&) -> bool constexpr
Return true if View::value_type is any of ValuesTypes...
template<typename... ValueTypes, typename View>
auto is_non_const_value_type(const View&) -> bool constexpr
Return true if View::non_const_value_type is any of ValuesTypes...
auto make_indexview<idx_t, 1>(Array&) -> template IndexView<idx_t, 1>
auto make_indexview<idx_t, 2>(Array&) -> template IndexView<idx_t, 2>
auto make_indexview<const idx_t, 1>(Array&) -> template IndexView<const idx_t, 1>
auto make_indexview<const idx_t, 2>(Array&) -> template IndexView<const idx_t, 2>
auto make_indexview<idx_t, 1>(const Array&) -> template IndexView<const idx_t, 1>
auto make_indexview<idx_t, 2>(const Array&) -> template IndexView<const idx_t, 2>
template<typename T>
auto make_host_vector_view(Vector<T> vector_) -> VectorView<T>
template<typename T>
auto make_device_vector_view(Vector<T> vector_) -> VectorView<T>
template<typename Value, int Rank>
auto make_view(Array& array) -> ArrayView<Value, Rank>
template<typename Value, int Rank>
auto make_view(const Array& array) -> ArrayView<const Value, Rank>
template<class Value, int Rank, ENABLE_IF_NOT_CONST>
auto make_view(Value data[], const ArrayShape& shape) -> LocalView<Value, Rank>
template<class Value, int Rank, ENABLE_IF_NOT_CONST>
auto make_view(const Value data[], const ArrayShape& shape) -> LocalView<const Value, Rank>
template<class Value, int Rank, ENABLE_IF_CONST>
auto make_view(typename std::remove_const<Value>::type data[], const ArrayShape& shape) -> LocalView<Value, Rank>
template<typename Value, unsigned int Rank, ENABLE_IF_NOT_CONST>
auto make_view(Value data[], size_t size) -> LocalView<Value, Rank>
template<typename Value, unsigned int Rank, ENABLE_IF_NOT_CONST>
auto make_view(const Value data[], size_t size) -> LocalView<const Value, Rank>
template<typename Value, unsigned int Rank, ENABLE_IF_CONST>
auto make_view(typename std::remove_const<Value>::type data[], size_t size) -> LocalView<Value, Rank>
template<typename Value, int Rank>
auto make_host_view(Array& array) -> ArrayView<Value, Rank>
template<typename Value, int Rank>
auto make_host_view(const Array& array) -> ArrayView<const Value, Rank>
template<typename Value, int Rank>
auto make_device_view(Array& array) -> ArrayView<Value, Rank>
template<typename Value, int Rank>
auto make_device_view(const Array& array) -> ArrayView<const Value, Rank>
template<typename Value, int Rank>
auto make_indexview(Array& array) -> IndexView<Value, Rank>
template<typename Value, int Rank>
auto make_indexview(const Array& array) -> IndexView<const Value, Rank>
template<typename Value, int Rank>
auto make_host_indexview(Array& array) -> IndexView<Value, Rank>
template<typename Value, int Rank>
auto make_host_indexview(const Array& array) -> IndexView<const Value, Rank>
void interprete(const Array&, atlas::io::ArrayReference&)
void decode(const atlas::io::Metadata&, const atlas::io::Data&, Array&)
template<>
auto DataType::str<std::byte>() -> std::string
template<>
auto DataType::str<const std::byte>() -> std::string
template<>
auto DataType::kind<std::byte>() -> DataType::kind_t constexpr
template<>
auto DataType::kind<const std::byte>() -> DataType::kind_t constexpr
auto operator==(DataType dt1, DataType dt2) -> bool
auto operator!=(DataType dt1, DataType dt2) -> bool
auto operator==(DataType dt, DataType::kind_t kind) -> bool
auto operator!=(DataType dt, DataType::kind_t kind) -> bool
auto operator==(DataType::kind_t kind, DataType dt) -> bool
auto operator!=(DataType::kind_t kind, DataType dt) -> bool
template<typename DATATYPE>
auto make_datatype() -> DataType

Typedef documentation

typedef std::vector<idx_t> atlas::array::ArrayIdx
#include <atlas/array/ArrayIdx.h>

using atlas::array::ArrayViewVariant = detail::Variant<detail::VariantValueTypes, detail::VariantRanks>
#include <atlas/array/ArrayViewVariant.h>

Variant containing all supported non-const ArrayView alternatives.

using atlas::array::ConstArrayViewVariant = detail::Variant<detail::VariantValueTypes::add_const, detail::VariantRanks>
#include <atlas/array/ArrayViewVariant.h>

Variant containing all supported const ArrayView alternatives.

#include <atlas/array/LocalView.h>
template<typename Value, int Rank>
using atlas::array::View = LocalView<Value, Rank>

Function documentation

#include <atlas/array/ArrayIdx.h>
template<typename... idx_t>
ArrayIdx atlas::array::make_idx(idx_t... indices)

#include <atlas/array/ArrayLayout.h>
template<typename... idx_t>
ArrayLayout atlas::array::make_layout(idx_t... indices)

#include <atlas/array/ArrayShape.h>
template<typename... idx_t>
ArrayShape atlas::array::make_shape(idx_t... indices)

#include <atlas/array/ArrayStrides.h>
template<typename... idx_t>
ArrayStrides atlas::array::make_strides(idx_t... indices)

ArrayViewVariant atlas::array::make_view_variant(Array& array)
#include <atlas/array/ArrayViewVariant.h>

Create an ArrayView and assign to an ArrayViewVariant.

ConstArrayViewVariant atlas::array::make_view_variant(const Array& array)
#include <atlas/array/ArrayViewVariant.h>

Create a const ArrayView and assign to an ArrayViewVariant.

ArrayViewVariant atlas::array::make_host_view_variant(Array& array)
#include <atlas/array/ArrayViewVariant.h>

Create a host ArrayView and assign to an ArrayViewVariant.

ConstArrayViewVariant atlas::array::make_host_view_variant(const Array& array)
#include <atlas/array/ArrayViewVariant.h>

Create a const host ArrayView and assign to an ArrayViewVariant.

ArrayViewVariant atlas::array::make_device_view_variant(Array& array)
#include <atlas/array/ArrayViewVariant.h>

Create a device ArrayView and assign to an ArrayViewVariant.

ConstArrayViewVariant atlas::array::make_device_view_variant(const Array& array)
#include <atlas/array/ArrayViewVariant.h>

Create a const device ArrayView and assign to an ArrayViewVariant.

#include <atlas/array/ArrayViewVariant.h>
template<int... Ranks, typename View>
bool atlas::array::is_rank(const View&) constexpr

Return true if View::rank() is any of Ranks...

#include <atlas/array/ArrayViewVariant.h>
template<typename... ValueTypes, typename View>
bool atlas::array::is_value_type(const View&) constexpr

Return true if View::value_type is any of ValuesTypes...

#include <atlas/array/ArrayViewVariant.h>
template<typename... ValueTypes, typename View>
bool atlas::array::is_non_const_value_type(const View&) constexpr

Return true if View::non_const_value_type is any of ValuesTypes...

template IndexView<const idx_t, 1> atlas::array::make_indexview<const idx_t, 1>(Array&)
#include <atlas/array/MakeView.h>

template IndexView<const idx_t, 2> atlas::array::make_indexview<const idx_t, 2>(Array&)
#include <atlas/array/MakeView.h>

template IndexView<const idx_t, 1> atlas::array::make_indexview<idx_t, 1>(const Array&)
#include <atlas/array/MakeView.h>

template IndexView<const idx_t, 2> atlas::array::make_indexview<idx_t, 2>(const Array&)
#include <atlas/array/MakeView.h>

#include <atlas/array/Vector.h>
template<typename T>
VectorView<T> atlas::array::make_host_vector_view(Vector<T> vector_)

#include <atlas/array/Vector.h>
template<typename T>
VectorView<T> atlas::array::make_device_vector_view(Vector<T> vector_)

#include <atlas/array_fwd.h>
template<typename Value, int Rank>
ArrayView<Value, Rank> atlas::array::make_view(Array& array)

#include <atlas/array_fwd.h>
template<typename Value, int Rank>
ArrayView<const Value, Rank> atlas::array::make_view(const Array& array)

#include <atlas/array_fwd.h>
template<class Value, int Rank, ENABLE_IF_NOT_CONST>
LocalView<Value, Rank> atlas::array::make_view(Value data[], const ArrayShape& shape)

#include <atlas/array_fwd.h>
template<class Value, int Rank, ENABLE_IF_NOT_CONST>
LocalView<const Value, Rank> atlas::array::make_view(const Value data[], const ArrayShape& shape)

#include <atlas/array_fwd.h>
template<class Value, int Rank, ENABLE_IF_CONST>
LocalView<Value, Rank> atlas::array::make_view(typename std::remove_const<Value>::type data[], const ArrayShape& shape)

#include <atlas/array_fwd.h>
template<typename Value, unsigned int Rank, ENABLE_IF_NOT_CONST>
LocalView<Value, Rank> atlas::array::make_view(Value data[], size_t size)

#include <atlas/array_fwd.h>
template<typename Value, unsigned int Rank, ENABLE_IF_NOT_CONST>
LocalView<const Value, Rank> atlas::array::make_view(const Value data[], size_t size)

#include <atlas/array_fwd.h>
template<typename Value, unsigned int Rank, ENABLE_IF_CONST>
LocalView<Value, Rank> atlas::array::make_view(typename std::remove_const<Value>::type data[], size_t size)

#include <atlas/array_fwd.h>
template<typename Value, int Rank>
ArrayView<Value, Rank> atlas::array::make_host_view(Array& array)

#include <atlas/array_fwd.h>
template<typename Value, int Rank>
ArrayView<const Value, Rank> atlas::array::make_host_view(const Array& array)

#include <atlas/array_fwd.h>
template<typename Value, int Rank>
ArrayView<Value, Rank> atlas::array::make_device_view(Array& array)

#include <atlas/array_fwd.h>
template<typename Value, int Rank>
ArrayView<const Value, Rank> atlas::array::make_device_view(const Array& array)

#include <atlas/array_fwd.h>
template<typename Value, int Rank>
IndexView<Value, Rank> atlas::array::make_indexview(Array& array)

#include <atlas/array_fwd.h>
template<typename Value, int Rank>
IndexView<const Value, Rank> atlas::array::make_indexview(const Array& array)

#include <atlas/array_fwd.h>
template<typename Value, int Rank>
IndexView<Value, Rank> atlas::array::make_host_indexview(Array& array)

#include <atlas/array_fwd.h>
template<typename Value, int Rank>
IndexView<const Value, Rank> atlas::array::make_host_indexview(const Array& array)

void atlas::array::interprete(const Array&, atlas::io::ArrayReference&)
#include <atlas/io/ArrayAdaptor.h>

void atlas::array::decode(const atlas::io::Metadata&, const atlas::io::Data&, Array&)
#include <atlas/io/ArrayAdaptor.h>

#include <atlas/util/DataType.h>
template<>
std::string atlas::array::DataType::str<std::byte>()

#include <atlas/util/DataType.h>
template<>
DataType::kind_t atlas::array::DataType::kind<std::byte>() constexpr

#include <atlas/util/DataType.h>
template<>
DataType::kind_t atlas::array::DataType::kind<const std::byte>() constexpr

bool atlas::array::operator==(DataType dt1, DataType dt2)
#include <atlas/util/DataType.h>

bool atlas::array::operator!=(DataType dt1, DataType dt2)
#include <atlas/util/DataType.h>

bool atlas::array::operator==(DataType dt, DataType::kind_t kind)
#include <atlas/util/DataType.h>

bool atlas::array::operator!=(DataType dt, DataType::kind_t kind)
#include <atlas/util/DataType.h>

bool atlas::array::operator==(DataType::kind_t kind, DataType dt)
#include <atlas/util/DataType.h>

bool atlas::array::operator!=(DataType::kind_t kind, DataType dt)
#include <atlas/util/DataType.h>

#include <atlas/util/DataType.h>
template<typename DATATYPE>
DataType atlas::array::make_datatype()