Reference documentation for deal.II version 9.3.3
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Public Types | Public Member Functions | Private Attributes | Friends | Related Functions | List of all members
ArrayView< ElementType, MemorySpaceType > Class Template Reference
Utility functions and classes » Data storage primitives

#include <deal.II/base/array_view.h>

Inheritance diagram for ArrayView< ElementType, MemorySpaceType >:
[legend]

Public Types

using value_type = ElementType
 
using iterator = value_type *
 
using const_iterator = const ElementType *
 

Public Member Functions

 ArrayView ()
 
 ArrayView (value_type *starting_element, const std::size_t n_elements)
 
 ArrayView (const ArrayView< typename std::remove_cv< value_type >::type, MemorySpaceType > &view)
 
 ArrayView (value_type &element)
 
 ArrayView (const std::vector< typename std::remove_cv< value_type >::type > &vector)
 
 ArrayView (std::vector< typename std::remove_cv< value_type >::type > &vector)
 
template<std::size_t N>
 ArrayView (value_type(&array)[N])
 
template<std::size_t N>
 ArrayView (const std::array< typename std::remove_cv< value_type >::type, N > &vector)
 
template<std::size_t N>
 ArrayView (std::array< typename std::remove_cv< value_type >::type, N > &vector)
 
void reinit (value_type *starting_element, const std::size_t n_elements)
 
bool operator== (const ArrayView< const value_type, MemorySpaceType > &other_view) const
 
bool operator== (const ArrayView< typename std::remove_cv< value_type >::type, MemorySpaceType > &other_view) const
 
bool operator!= (const ArrayView< const value_type, MemorySpaceType > &other_view) const
 
bool operator!= (const ArrayView< typename std::remove_cv< value_type >::type, MemorySpaceType > &other_view) const
 
std::size_t size () const
 
value_type * data () const noexcept
 
iterator begin () const
 
iterator end () const
 
const_iterator cbegin () const
 
const_iterator cend () const
 
value_type & operator[] (const std::size_t i) const
 

Private Attributes

value_type * starting_element
 
std::size_t n_elements
 

Friends

class ArrayView< const ElementType, MemorySpaceType >
 

Related Functions

(Note that these are not member functions.)

template<typename Iterator , typename MemorySpaceType = MemorySpace::Host>
ArrayView< typename std::remove_reference< typename std::iterator_traits< Iterator >::reference >::type, MemorySpaceType > make_array_view (const Iterator begin, const Iterator end)
 
template<typename ElementType , typename MemorySpaceType = MemorySpace::Host>
ArrayView< ElementType, MemorySpaceType > make_array_view (ElementType *const begin, ElementType *const end)
 
template<typename Number , typename MemorySpaceType >
ArrayView< const Number, MemorySpaceType > make_array_view (const ArrayView< Number, MemorySpaceType > &array_view)
 
template<typename Number , typename MemorySpaceType >
ArrayView< Number, MemorySpaceType > make_array_view (ArrayView< Number, MemorySpaceType > &array_view)
 
template<int rank, int dim, typename Number >
ArrayView< const Number > make_array_view (const Tensor< rank, dim, Number > &tensor)
 
template<int rank, int dim, typename Number >
ArrayView< Number > make_array_view (Tensor< rank, dim, Number > &tensor)
 
template<int rank, int dim, typename Number >
ArrayView< const Number > make_array_view (const SymmetricTensor< rank, dim, Number > &tensor)
 
template<int rank, int dim, typename Number >
ArrayView< Number > make_array_view (SymmetricTensor< rank, dim, Number > &tensor)
 
template<typename ElementType , int N>
ArrayView< ElementType > make_array_view (ElementType(&array)[N])
 
template<typename ElementType >
ArrayView< ElementType > make_array_view (Vector< ElementType > &vector)
 
template<typename ElementType >
ArrayView< const ElementType > make_array_view (const Vector< ElementType > &vector)
 
template<typename ElementType >
ArrayView< ElementType > make_array_view (std::vector< ElementType > &vector)
 
template<typename ElementType >
ArrayView< const ElementType > make_array_view (const std::vector< ElementType > &vector)
 
template<typename ElementType >
ArrayView< ElementType > make_array_view (std::vector< ElementType > &vector, const std::size_t starting_index, const std::size_t size_of_view)
 
template<typename ElementType >
ArrayView< const ElementType > make_array_view (const std::vector< ElementType > &vector, const std::size_t starting_index, const std::size_t size_of_view)
 
template<typename ElementType >
ArrayView< ElementType > make_array_view (Table< 2, ElementType > &table, const typename Table< 2, ElementType >::size_type row)
 
template<typename ElementType >
ArrayView< ElementType > make_array_view (Table< 2, ElementType > &table)
 
template<typename ElementType >
ArrayView< const ElementType > make_array_view (const Table< 2, ElementType > &table)
 
template<typename ElementType >
ArrayView< ElementType > make_array_view (LAPACKFullMatrix< ElementType > &matrix)
 
template<typename ElementType >
ArrayView< const ElementType > make_array_view (const LAPACKFullMatrix< ElementType > &matrix)
 
template<typename ElementType >
ArrayView< const ElementType > make_array_view (const Table< 2, ElementType > &table, const typename Table< 2, ElementType >::size_type row)
 
template<typename ElementType >
ArrayView< ElementType > make_array_view (Table< 2, ElementType > &table, const typename Table< 2, ElementType >::size_type row, const typename Table< 2, ElementType >::size_type starting_column, const std::size_t size_of_view)
 
template<typename ElementType >
ArrayView< const ElementType > make_array_view (const Table< 2, ElementType > &table, const typename Table< 2, ElementType >::size_type row, const typename Table< 2, ElementType >::size_type starting_column, const std::size_t size_of_view)
 

Detailed Description

template<typename ElementType, typename MemorySpaceType = MemorySpace::Host>
class ArrayView< ElementType, MemorySpaceType >

A class that represents a window of memory locations of type ElementType and presents it as if it was an array. In essence, this class is nothing more than just a pointer to the first location and an integer that represents the length of the array in elements. The memory remains owned by whoever allocated it, as this class does not take over ownership.

The advantage of using this class is that you don't have to pass around pairs of pointers and that operator[] checks for the validity of the index with which you subscript this array view. Note that accessing elements is only allowed if the underlying data is stored in CPU memory.

This class can handle views to both non-constant and constant memory locations. If you want to represent a view of a constant array, then the template argument type of this class needs to be const as well. The following code snippet gives an example:

std::vector<int> array = get_data(); // a writable array
ArrayView<int> view (&array[5], 5); // a view of elements 5..9 (inclusive)
view[2] = 42; // array[7] is set to 42
ArrayView<const int> const_view (&array[5], 5); // same view, but read-only
int element_7 = const_view[2]; // set element_7 to 42
const_view[2] = 42; // this line won't compile; can't write into this view

In either case, accessing an element of a view does not change the ArrayView object itself, and consequently ArrayView::operator[] is a const function. This corresponds to the notion that a view simply represents a, well, "view" of memory that is owned by someone else. Thus, accessing elements of the view changes the memory managed by some other object, but not the view itself, allowing us to make ArrayView::operator[] a const member function. This is in contrast to, say, std::vector, which manages the memory it points to and changing an element of the std::vector therefore changes the std::vector object itself – consequently, the std::vector::operator[] is non-const.

Note
This class is similar to std::span, but the latter is only available starting in C++20.

Definition at line 81 of file array_view.h.

Member Typedef Documentation

◆ value_type

template<typename ElementType , typename MemorySpaceType = MemorySpace::Host>
using ArrayView< ElementType, MemorySpaceType >::value_type = ElementType

An alias that denotes the "value_type" of this container-like class, i.e., the type of the element it "stores" or points to.

Definition at line 88 of file array_view.h.

◆ iterator

template<typename ElementType , typename MemorySpaceType = MemorySpace::Host>
using ArrayView< ElementType, MemorySpaceType >::iterator = value_type *

An alias for iterators pointing into the array.

Definition at line 93 of file array_view.h.

◆ const_iterator

template<typename ElementType , typename MemorySpaceType = MemorySpace::Host>
using ArrayView< ElementType, MemorySpaceType >::const_iterator = const ElementType *

An alias for const iterators pointing into the array.

Definition at line 98 of file array_view.h.

Constructor & Destructor Documentation

◆ ArrayView() [1/9]

template<typename ElementType , typename MemorySpaceType >
ArrayView< ElementType, MemorySpaceType >::ArrayView
inline

Default constructor.

Definition at line 387 of file array_view.h.

◆ ArrayView() [2/9]

template<typename ElementType , typename MemorySpaceType >
ArrayView< ElementType, MemorySpaceType >::ArrayView ( value_type *  starting_element,
const std::size_t  n_elements 
)
inline

Constructor.

Parameters
[in]starting_elementA pointer to the first element of the array this object should represent.
[in]n_elementsThe length (in elements) of the chunk of memory this object should represent.
Note
The object that is constructed from these arguments has no knowledge how large the object into which it points really is. As a consequence, whenever you call ArrayView::operator[], the array view can check that the given index is within the range of the view, but it can't check that the view is indeed a subset of the valid range of elements of the underlying object that allocated that range. In other words, you need to ensure that the range of the view specified by the two arguments to this constructor is in fact a subset of the elements of the array into which it points. The appropriate way to do this is to use the make_array_view() functions.

Definition at line 395 of file array_view.h.

◆ ArrayView() [3/9]

template<typename ElementType , typename MemorySpaceType >
ArrayView< ElementType, MemorySpaceType >::ArrayView ( const ArrayView< typename std::remove_cv< value_type >::type, MemorySpaceType > &  view)
inline

Copy constructor from array views that point to non-const elements. If the current object will point to non-const elements, then this is a straight forward copy constructor. On the other hand, if the current type's ElementType template argument is a const qualified type, then the current constructor is a conversion constructor that converts a non-const view to a const view, akin to converting a non-const pointer to a const pointer.

Definition at line 430 of file array_view.h.

◆ ArrayView() [4/9]

template<typename ElementType , typename MemorySpaceType >
ArrayView< ElementType, MemorySpaceType >::ArrayView ( value_type &  element)
inlineexplicit

A constructor that automatically creates a view from a single value_type object. The view so created then has length one.

Definition at line 422 of file array_view.h.

◆ ArrayView() [5/9]

template<typename ElementType , typename MemorySpaceType >
ArrayView< ElementType, MemorySpaceType >::ArrayView ( const std::vector< typename std::remove_cv< value_type >::type > &  vector)
inline

A constructor that automatically creates a view from a std::vector object. The view encompasses all elements of the given vector.

This implicit conversion constructor is particularly useful when calling a function that takes an ArrayView object as argument, and passing in a std::vector.

Note
This constructor takes a reference to a const vector as argument. It can only be used to initialize ArrayView objects that point to const memory locations, such as ArrayView<const double>. You cannot initialize ArrayView objects to non-const memory with such arguments, such as ArrayView<double>.

Definition at line 440 of file array_view.h.

◆ ArrayView() [6/9]

template<typename ElementType , typename MemorySpaceType >
ArrayView< ElementType, MemorySpaceType >::ArrayView ( std::vector< typename std::remove_cv< value_type >::type > &  vector)
inline

A constructor that automatically creates a view from a std::vector object. The view encompasses all elements of the given vector.

This implicit conversion constructor is particularly useful when calling a function that takes an ArrayView object as argument, and passing in a std::vector.

Note
This constructor takes a reference to a non-const vector as argument. It can be used to initialize ArrayView objects that point to either const memory locations, such as ArrayView<const double>, or to non-const memory, such as ArrayView<double>.

Definition at line 464 of file array_view.h.

◆ ArrayView() [7/9]

template<typename ElementType , typename MemorySpaceType >
template<std::size_t N>
ArrayView< ElementType, MemorySpaceType >::ArrayView ( value_type(&)  array[N])
inline

A constructor that automatically creates a view for a given C-style array. This constructor can be used as follows:

ArrayView<const int>
get_data_table ()
{
static const int my_data[7] = { 1, 1, 2, 3, 5, 8, 13 };
return {my_data};
}

The object so returned is then a view of the array, with the size 7 correctly deduced.

Definition at line 499 of file array_view.h.

◆ ArrayView() [8/9]

template<typename ElementType , typename MemorySpaceType >
template<std::size_t N>
ArrayView< ElementType, MemorySpaceType >::ArrayView ( const std::array< typename std::remove_cv< value_type >::type, N > &  vector)
inline

A constructor that automatically creates a view from a std::array object. The view encompasses all elements of the given vector.

This implicit conversion constructor is particularly useful when calling a function that takes an ArrayView object as argument, and passing in a std::array.

Definition at line 474 of file array_view.h.

◆ ArrayView() [9/9]

template<typename ElementType , typename MemorySpaceType >
template<std::size_t N>
ArrayView< ElementType, MemorySpaceType >::ArrayView ( std::array< typename std::remove_cv< value_type >::type, N > &  vector)
inline

A constructor that automatically creates a view from a std::array object. The view encompasses all elements of the given vector.

This implicit conversion constructor is particularly useful when calling a function that takes an ArrayView object as argument, and passing in a std::array.

Definition at line 508 of file array_view.h.

Member Function Documentation

◆ reinit()

template<typename ElementType , typename MemorySpaceType >
void ArrayView< ElementType, MemorySpaceType >::reinit ( value_type *  starting_element,
const std::size_t  n_elements 
)
inline

Reinitialize a view.

Parameters
[in]starting_elementA pointer to the first element of the array this object should represent.
[in]n_elementsThe length (in elements) of the chunk of memory this object should represent.
Note
The object that is constructed from these arguments has no knowledge how large the object into which it points really is. As a consequence, whenever you call ArrayView::operator[], the array view can check that the given index is within the range of the view, but it can't check that the view is indeed a subset of the valid range of elements of the underlying object that allocated that range. In other words, you need to ensure that the range of the view specified by the two arguments to this constructor is in fact a subset of the elements of the array into which it points. The appropriate way to do this is to use the make_array_view() functions.

Definition at line 413 of file array_view.h.

◆ operator==() [1/2]

template<typename ElementType , typename MemorySpaceType >
bool ArrayView< ElementType, MemorySpaceType >::operator== ( const ArrayView< const value_type, MemorySpaceType > &  other_view) const
inline

Compare two ArrayView objects of the same type. Two objects are considered equal if they have the same size and the same starting pointer. This version always compares with the const value_type.

Definition at line 518 of file array_view.h.

◆ operator==() [2/2]

template<typename ElementType , typename MemorySpaceType >
bool ArrayView< ElementType, MemorySpaceType >::operator== ( const ArrayView< typename std::remove_cv< value_type >::type, MemorySpaceType > &  other_view) const
inline

Compare two ArrayView objects of the same type. Two objects are considered equal if they have the same size and the same starting pointer. This version always compares with the non-const value_type.

Definition at line 529 of file array_view.h.

◆ operator!=() [1/2]

template<typename ElementType , typename MemorySpaceType >
bool ArrayView< ElementType, MemorySpaceType >::operator!= ( const ArrayView< const value_type, MemorySpaceType > &  other_view) const
inline

Compare two ArrayView objects of the same type. Two objects are considered equal if they have the same size and the same starting pointer. This version always compares with the const value_type.

Definition at line 541 of file array_view.h.

◆ operator!=() [2/2]

template<typename ElementType , typename MemorySpaceType >
bool ArrayView< ElementType, MemorySpaceType >::operator!= ( const ArrayView< typename std::remove_cv< value_type >::type, MemorySpaceType > &  other_view) const
inline

Compare two ArrayView objects of the same type. Two objects are considered equal if they have the same size and the same starting pointer. This version always compares with the non-const value_type.

Definition at line 563 of file array_view.h.

◆ size()

template<typename ElementType , typename MemorySpaceType >
std::size_t ArrayView< ElementType, MemorySpaceType >::size
inline

Return the size (in elements) of the view of memory this object represents.

Definition at line 574 of file array_view.h.

◆ data()

template<typename ElementType , typename MemorySpaceType >
ArrayView< ElementType, MemorySpaceType >::value_type * ArrayView< ElementType, MemorySpaceType >::data
inlinenoexcept

Return a pointer to the underlying array serving as element storage. In case the container is empty a nullptr is returned.

Definition at line 551 of file array_view.h.

◆ begin()

template<typename ElementType , typename MemorySpaceType >
ArrayView< ElementType, MemorySpaceType >::iterator ArrayView< ElementType, MemorySpaceType >::begin
inline

Return an iterator pointing to the beginning of the array view.

Definition at line 583 of file array_view.h.

◆ end()

template<typename ElementType , typename MemorySpaceType >
ArrayView< ElementType, MemorySpaceType >::iterator ArrayView< ElementType, MemorySpaceType >::end
inline

Return an iterator pointing to one past the end of the array view.

Definition at line 592 of file array_view.h.

◆ cbegin()

template<typename ElementType , typename MemorySpaceType >
ArrayView< ElementType, MemorySpaceType >::const_iterator ArrayView< ElementType, MemorySpaceType >::cbegin
inline

Return a constant iterator pointing to the beginning of the array view.

Definition at line 601 of file array_view.h.

◆ cend()

template<typename ElementType , typename MemorySpaceType >
ArrayView< ElementType, MemorySpaceType >::const_iterator ArrayView< ElementType, MemorySpaceType >::cend
inline

Return a constant iterator pointing to one past the end of the array view.

Definition at line 610 of file array_view.h.

◆ operator[]()

template<typename ElementType , typename MemorySpaceType >
ArrayView< ElementType, MemorySpaceType >::value_type & ArrayView< ElementType, MemorySpaceType >::operator[] ( const std::size_t  i) const
inline

Return a reference to the \(i\)th element of the range represented by the current object.

This function is marked as const because it does not change the view object. It may however return a reference to a non-const memory location depending on whether the template type of the class is const or not.

This function is only allowed to be called if the underlying data is indeed stored in CPU memory.

Definition at line 619 of file array_view.h.

Friends And Related Function Documentation

◆ ArrayView< const ElementType, MemorySpaceType >

template<typename ElementType , typename MemorySpaceType = MemorySpace::Host>
friend class ArrayView< const ElementType, MemorySpaceType >
friend

Definition at line 337 of file array_view.h.

◆ make_array_view() [1/23]

template<typename Iterator , typename MemorySpaceType = MemorySpace::Host>
ArrayView< typename std::remove_reference< typename std::iterator_traits< Iterator >::reference >::type, MemorySpaceType > make_array_view ( const Iterator  begin,
const Iterator  end 
)
related

Create an ArrayView that takes a pair of iterators as arguments. The type of the ArrayView is inferred from the value type of the iterator (e.g., the view created from two const iterators will have a const type).

Warning
The iterators begin and end must bound (in the usual half-open way) a contiguous in memory range of values. This function is intended for use with iterators into containers like boost::container::small_vector or std::vector and will not work correctly with, e.g., boost::container::stable_vector or std::deque. In debug mode, we check that the provided iterators represent contiguous memory indeed.

Definition at line 697 of file array_view.h.

◆ make_array_view() [2/23]

template<typename ElementType , typename MemorySpaceType = MemorySpace::Host>
ArrayView< ElementType, MemorySpaceType > make_array_view ( ElementType *const  begin,
ElementType *const  end 
)
related

Create a view from a pair of pointers. ElementType may be const-qualified.

Warning
The pointers begin and end must bound (in the usual half-open way) a contiguous in memory range of values.

Definition at line 727 of file array_view.h.

◆ make_array_view() [3/23]

template<typename Number , typename MemorySpaceType >
ArrayView< const Number, MemorySpaceType > make_array_view ( const ArrayView< Number, MemorySpaceType > &  array_view)
related

Create a view from an ArrayView itself.

This function is used for const references to objects of ArrayView type. It only exists for compatibility purposes.

Parameters
[in]array_viewThe ArrayView that we wish to make a copy of.

Definition at line 749 of file array_view.h.

◆ make_array_view() [4/23]

template<typename Number , typename MemorySpaceType >
ArrayView< Number, MemorySpaceType > make_array_view ( ArrayView< Number, MemorySpaceType > &  array_view)
related

Create a view from an ArrayView itself.

This function is used for non-const references to objects of ArrayView type. It only exists for compatibility purposes.

Parameters
[in]array_viewThe ArrayView that we wish to make a copy of.

Definition at line 768 of file array_view.h.

◆ make_array_view() [5/23]

template<int rank, int dim, typename Number >
ArrayView< const Number > make_array_view ( const Tensor< rank, dim, Number > &  tensor)
related

Create a view to an entire Tensor object. This is equivalent to initializing an ArrayView object with a pointer to the first element and the size of the given argument.

This function is used for const references to objects of Tensor type because they contain immutable elements. Consequently, the return type of this function is a view to a set of const objects.

Parameters
[in]tensorThe Tensor for which we want to have an array view object. The array view corresponds to the entire object but the order in which the entries are presented in the array is an implementation detail and should not be relied upon.

Definition at line 793 of file array_view.h.

◆ make_array_view() [6/23]

template<int rank, int dim, typename Number >
ArrayView< Number > make_array_view ( Tensor< rank, dim, Number > &  tensor)
related

Create a view to an entire Tensor object. This is equivalent to initializing an ArrayView object with a pointer to the first element and the size of the given argument.

This function is used for non-const references to objects of Tensor type. Such objects contain elements that can be written to. Consequently, the return type of this function is a view to a set of writable objects.

Parameters
[in]tensorThe Tensor for which we want to have an array view object. The array view corresponds to the entire object but the order in which the entries are presented in the array is an implementation detail and should not be relied upon.

Definition at line 818 of file array_view.h.

◆ make_array_view() [7/23]

template<int rank, int dim, typename Number >
ArrayView< const Number > make_array_view ( const SymmetricTensor< rank, dim, Number > &  tensor)
related

Create a view to an entire SymmetricTensor object. This is equivalent to initializing an ArrayView object with a pointer to the first element and the size of the given argument.

This function is used for const references to objects of SymmetricTensor type because they contain immutable elements. Consequently, the return type of this function is a view to a set of const objects.

Parameters
[in]tensorThe SymmetricTensor for which we want to have an array view object. The array view corresponds to the entire object but the order in which the entries are presented in the array is an implementation detail and should not be relied upon.

Definition at line 843 of file array_view.h.

◆ make_array_view() [8/23]

template<int rank, int dim, typename Number >
ArrayView< Number > make_array_view ( SymmetricTensor< rank, dim, Number > &  tensor)
related

Create a view to an entire SymmetricTensor object. This is equivalent to initializing an ArrayView object with a pointer to the first element and the size of the given argument.

This function is used for non-const references to objects of SymmetricTensor type. Such objects contain elements that can be written to. Consequently, the return type of this function is a view to a set of writable objects.

Parameters
[in]tensorThe SymmetricTensor for which we want to have an array view object. The array view corresponds to the entire object but the order in which the entries are presented in the array is an implementation detail and should not be relied upon.

Definition at line 869 of file array_view.h.

◆ make_array_view() [9/23]

template<typename ElementType , int N>
ArrayView< ElementType > make_array_view ( ElementType(&)  array[N])
related

Create a view to an entire C-style array. This is equivalent to initializing an ArrayView object with a pointer to the first element and the size of the given argument.

Whether the resulting ArrayView is writable or not depends on the ElementType being a const type or not.

Parameters
[in]arrayThe C-style array for which we want to have an ArrayView object. The ArrayView corresponds to the entire vector.

Definition at line 890 of file array_view.h.

◆ make_array_view() [10/23]

template<typename ElementType >
ArrayView< ElementType > make_array_view ( Vector< ElementType > &  vector)
related

Create a view to an entire Vector object. This is equivalent to initializing an ArrayView object with a pointer to the first element and the size of the given argument.

This function is used for non-const references to objects of Vector type. Such objects contain elements that can be written to. Consequently, the return type of this function is a view to a set of writable objects.

Parameters
[in]vectorThe Vector for which we want to have an array view object. The array view corresponds to the entire Vector.

Definition at line 913 of file array_view.h.

◆ make_array_view() [11/23]

template<typename ElementType >
ArrayView< const ElementType > make_array_view ( const Vector< ElementType > &  vector)
related

Create a view to an entire Vector object. This is equivalent to initializing an ArrayView object with a pointer to the first element and the size of the given argument.

This function is used for const references to objects of Vector type because they contain immutable elements. Consequently, the return type of this function is a view to a set of const objects.

Parameters
[in]vectorThe Vector for which we want to have an array view object. The array view corresponds to the entire Vector.

Definition at line 936 of file array_view.h.

◆ make_array_view() [12/23]

template<typename ElementType >
ArrayView< ElementType > make_array_view ( std::vector< ElementType > &  vector)
related

Create a view to an entire std::vector object. This is equivalent to initializing an ArrayView object with a pointer to the first element and the size of the given argument.

This function is used for non-const references to objects of vector type. Such objects contain elements that can be written to. Consequently, the return type of this function is a view to a set of writable objects.

Parameters
[in]vectorThe vector for which we want to have an array view object. The array view corresponds to the entire vector.

Definition at line 959 of file array_view.h.

◆ make_array_view() [13/23]

template<typename ElementType >
ArrayView< const ElementType > make_array_view ( const std::vector< ElementType > &  vector)
related

Create a view to an entire std::vector object. This is equivalent to initializing an ArrayView object with a pointer to the first element and the size of the given argument.

This function is used for const references to objects of vector type because they contain immutable elements. Consequently, the return type of this function is a view to a set of const objects.

Parameters
[in]vectorThe vector for which we want to have an array view object. The array view corresponds to the entire vector.

Definition at line 982 of file array_view.h.

◆ make_array_view() [14/23]

template<typename ElementType >
ArrayView< ElementType > make_array_view ( std::vector< ElementType > &  vector,
const std::size_t  starting_index,
const std::size_t  size_of_view 
)
related

Create a view to a part of a std::vector object. This is equivalent to initializing the ArrayView object with a pointer to the starting_index- th element and the size_of_view as the length of the view.

This function is used for non-const references to objects of vector type. Such objects contain elements that can be written to. Consequently, the return type of this function is a view to a set of writable objects.

Parameters
[in]vectorThe vector for which we want to have an array view object.
[in]starting_indexThe index of the first element of the vector that will be part of this view.
[in]size_of_viewNumber of elements in the new ArrayView.
Precondition
starting_index + size_of_view <= vector.size()

Definition at line 1010 of file array_view.h.

◆ make_array_view() [15/23]

template<typename ElementType >
ArrayView< const ElementType > make_array_view ( const std::vector< ElementType > &  vector,
const std::size_t  starting_index,
const std::size_t  size_of_view 
)
related

Create a view to a part of a std::vector object. This is equivalent to initializing the ArrayView object with a pointer to the starting_index- th element and the size_of_view as the length of the view.

This function is used for const references to objects of vector type because they contain immutable elements. Consequently, the return type of this function is a view to a set of const objects.

Parameters
[in]vectorThe vector for which we want to have an array view object.
[in]starting_indexThe index of the first element of the vector that will be part of this view.
[in]size_of_viewNumber of elements in the new ArrayView.
Precondition
starting_index + size_of_view <= vector.size()

Definition at line 1044 of file array_view.h.

◆ make_array_view() [16/23]

template<typename ElementType >
ArrayView< ElementType > make_array_view ( Table< 2, ElementType > &  table,
const typename Table< 2, ElementType >::size_type  row 
)
related

Create a view to an entire row of a Table<2> object. This is equivalent to initializing an ArrayView object with a pointer to the first element of the given row, and the length of the row as the length of the view.

This function is used for non-const references to objects of Table type. Such objects contain elements that can be written to. Consequently, the return type of this function is a view to a set of writable objects.

Parameters
[in]tableThe Table for which we want to have an array view object. The array view corresponds to an entire row.
[in]rowThe index of the row into the table to which this view should correspond.

Definition at line 1075 of file array_view.h.

◆ make_array_view() [17/23]

template<typename ElementType >
ArrayView< ElementType > make_array_view ( Table< 2, ElementType > &  table)
related

Create a view to an entire Table<2> object. This is equivalent to initializing an ArrayView object with a pointer to the first element of the given table, and the number of table entries as the length of the view.

This function is used for non-const references to objects of Table type. Such objects contain elements that can be written to. Consequently, the return type of this function is a view to a set of writable objects.

Parameters
[in]tableThe Table for which we want to have an array view object. The array view corresponds to the entire table but the order in which the entries are presented in the array is an implementation detail and should not be relied upon.

Definition at line 1101 of file array_view.h.

◆ make_array_view() [18/23]

template<typename ElementType >
ArrayView< const ElementType > make_array_view ( const Table< 2, ElementType > &  table)
related

Create a view to an entire Table<2> object. This is equivalent to initializing an ArrayView object with a pointer to the first element of the given table, and the number of table entries as the length of the view.

This function is used for const references to objects of Table type because they contain immutable elements. Consequently, the return type of this function is a view to a set of const objects.

Parameters
[in]tableThe Table for which we want to have an array view object. The array view corresponds to the entire table but the order in which the entries are presented in the array is an implementation detail and should not be relied upon.

Definition at line 1126 of file array_view.h.

◆ make_array_view() [19/23]

template<typename ElementType >
ArrayView< ElementType > make_array_view ( LAPACKFullMatrix< ElementType > &  matrix)
related

Create a view to an entire LAPACKFullMatrix object. This is equivalent to initializing an ArrayView object with a pointer to the first element of the given object, and the number entries as the length of the view.

This function is used for non-const references to objects of LAPACKFullMatrix type. Such objects contain elements that can be written to. Consequently, the return type of this function is a view to a set of non-const objects.

Parameters
[in]matrixThe LAPACKFullMatrix for which we want to have an array view object. The array view corresponds to the entire object but the order in which the entries are presented in the array is an implementation detail and should not be relied upon.

Definition at line 1151 of file array_view.h.

◆ make_array_view() [20/23]

template<typename ElementType >
ArrayView< const ElementType > make_array_view ( const LAPACKFullMatrix< ElementType > &  matrix)
related

Create a view to an entire LAPACKFullMatrix object. This is equivalent to initializing an ArrayView object with a pointer to the first element of the given object, and the number of entries as the length of the view.

This function is used for const references to objects of LAPACKFullMatrix type because they contain immutable elements. Consequently, the return type of this function is a view to a set of const objects.

Parameters
[in]matrixThe LAPACKFullMatrix for which we want to have an array view object. The array view corresponds to the entire object but the order in which the entries are presented in the array is an implementation detail and should not be relied upon.

Definition at line 1176 of file array_view.h.

◆ make_array_view() [21/23]

template<typename ElementType >
ArrayView< const ElementType > make_array_view ( const Table< 2, ElementType > &  table,
const typename Table< 2, ElementType >::size_type  row 
)
related

Create a view to an entire row of a Table<2> object. This is equivalent to initializing an ArrayView object with a pointer to the first element of the given row, and the length of the row as the length of the view.

This function is used for const references to objects of Table type because they contain immutable elements. Consequently, the return type of this function is a view to a set of const objects.

Parameters
[in]tableThe Table for which we want to have an array view object. The array view corresponds to an entire row.
[in]rowThe index of the row into the table to which this view should correspond.

Definition at line 1201 of file array_view.h.

◆ make_array_view() [22/23]

template<typename ElementType >
ArrayView< ElementType > make_array_view ( Table< 2, ElementType > &  table,
const typename Table< 2, ElementType >::size_type  row,
const typename Table< 2, ElementType >::size_type  starting_column,
const std::size_t  size_of_view 
)
related

Create a view to (a part of) a row of a Table<2> object.

This function is used for non-const references to objects of Table type. Such objects contain elements that can be written to. Consequently, the return type of this function is a view to a set of writable objects.

Parameters
[in]tableThe Table for which we want to have an array view object. The array view corresponds to an entire row.
[in]rowThe index of the row into the table to which this view should correspond.
[in]starting_columnThe index of the column into the given row of the table that corresponds to the first element of this view.
[in]size_of_viewThe number of elements this view should have. This corresponds to the number of columns in the current row to which the view should correspond.

Definition at line 1230 of file array_view.h.

◆ make_array_view() [23/23]

template<typename ElementType >
ArrayView< const ElementType > make_array_view ( const Table< 2, ElementType > &  table,
const typename Table< 2, ElementType >::size_type  row,
const typename Table< 2, ElementType >::size_type  starting_column,
const std::size_t  size_of_view 
)
related

Create a view to (a part of) a row of a Table<2> object.

This function is used for const references to objects of Table type because they contain immutable elements. Consequently, the return type of this function is a view to a set of const objects.

Parameters
[in]tableThe Table for which we want to have an array view object. The array view corresponds to an entire row.
[in]rowThe index of the row into the table to which this view should correspond.
[in]starting_columnThe index of the column into the given row of the table that corresponds to the first element of this view.
[in]size_of_viewThe number of elements this view should have. This corresponds to the number of columns in the current row to which the view should correspond.

Definition at line 1268 of file array_view.h.

Member Data Documentation

◆ starting_element

template<typename ElementType , typename MemorySpaceType = MemorySpace::Host>
value_type* ArrayView< ElementType, MemorySpaceType >::starting_element
private

A pointer to the first element of the range of locations in memory that this object represents.

Definition at line 332 of file array_view.h.

◆ n_elements

template<typename ElementType , typename MemorySpaceType = MemorySpace::Host>
std::size_t ArrayView< ElementType, MemorySpaceType >::n_elements
private

The length of the array this object represents.

Definition at line 337 of file array_view.h.

The documentation for this class was generated from the following file:
Generated by doxygen 1.9.4