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

Inheritance diagram for ArrayView< ElementType, MemorySpaceType >:

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 (const std::vector< typename std::remove_cv< value_type >::type > &vector)

	ArrayView (std::vector< typename std::remove_cv< value_type >::type > &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 in C++20.

Author: Wolfgang Bangerth, 2015, David Wells, 2017

Definition at line 77 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 84 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 89 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 94 of file array_view.h.

Constructor & Destructor Documentation

◆ ArrayView() [1/5]

template<typename ElementType , typename MemorySpaceType >

ArrayView< ElementType, MemorySpaceType >::ArrayView ( )

inline

Default constructor.

Definition at line 336 of file array_view.h.

◆ ArrayView() [2/5]

template<typename ElementType , typename MemorySpaceType >

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

inline

Constructor.

Parameters

[in]	starting_element	A pointer to the first element of the array this object should represent.
[in]	n_elements	The 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 344 of file array_view.h.

◆ ArrayView() [3/5]

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 371 of file array_view.h.

◆ ArrayView() [4/5]

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 381 of file array_view.h.

◆ ArrayView() [5/5]

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 405 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_element	A pointer to the first element of the array this object should represent.
[in]	n_elements	The 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 362 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 416 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 427 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 439 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 461 of file array_view.h.

◆ size()

template<typename ElementType , typename MemorySpaceType >

std::size_t ArrayView< ElementType, MemorySpaceType >::size ( ) const

inline

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

Definition at line 471 of file array_view.h.

◆ data()

template<typename ElementType , typename MemorySpaceType >

ArrayView< ElementType, MemorySpaceType >::value_type * ArrayView< ElementType, MemorySpaceType >::data ( ) const

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 448 of file array_view.h.

◆ begin()

template<typename ElementType , typename MemorySpaceType >

ArrayView< ElementType, MemorySpaceType >::iterator ArrayView< ElementType, MemorySpaceType >::begin ( ) const

inline

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

Definition at line 480 of file array_view.h.

◆ end()

template<typename ElementType , typename MemorySpaceType >

ArrayView< ElementType, MemorySpaceType >::iterator ArrayView< ElementType, MemorySpaceType >::end ( ) const

inline

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

Definition at line 489 of file array_view.h.

◆ cbegin()

template<typename ElementType , typename MemorySpaceType >

ArrayView< ElementType, MemorySpaceType >::const_iterator ArrayView< ElementType, MemorySpaceType >::cbegin ( ) const

inline

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

Definition at line 498 of file array_view.h.

◆ cend()

template<typename ElementType , typename MemorySpaceType >

ArrayView< ElementType, MemorySpaceType >::const_iterator ArrayView< ElementType, MemorySpaceType >::cend ( ) const

inline

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

Definition at line 507 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 516 of file array_view.h.

Friends And Related Function Documentation

◆ 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
	)

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 594 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
	)

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

Definition at line 624 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 )

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

Parameters

[in] array_view The ArrayView that we wish to make a copy of.

Definition at line 646 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 )

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

Parameters

[in] array_view The ArrayView that we wish to make a copy of.

Definition at line 665 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 )

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] tensor The 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 690 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 )

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] tensor The 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 715 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 )

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] tensor The 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 740 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 )

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] tensor The 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 766 of file array_view.h.

◆ make_array_view() [9/23]

template<typename ElementType , int N>

ArrayView< ElementType > make_array_view ( ElementType(&) array[N] )

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

Parameters

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

Definition at line 787 of file array_view.h.

◆ make_array_view() [10/23]

template<typename ElementType >

ArrayView< ElementType > make_array_view ( Vector< ElementType > & vector )

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] vector The Vector for which we want to have an array view object. The array view corresponds to the entire Vector.

Definition at line 810 of file array_view.h.

◆ make_array_view() [11/23]

template<typename ElementType >

ArrayView< const ElementType > make_array_view ( const Vector< ElementType > & vector )

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] vector The Vector for which we want to have an array view object. The array view corresponds to the entire Vector.

Definition at line 833 of file array_view.h.

◆ make_array_view() [12/23]

template<typename ElementType >

ArrayView< ElementType > make_array_view ( std::vector< ElementType > & vector )

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] vector The vector for which we want to have an array view object. The array view corresponds to the entire vector.

Definition at line 856 of file array_view.h.

◆ make_array_view() [13/23]

template<typename ElementType >

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

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] vector The vector for which we want to have an array view object. The array view corresponds to the entire vector.

Definition at line 879 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
	)

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]	vector	The vector for which we want to have an array view object.
[in]	starting_index	The index of the first element of the vector that will be part of this view.
[in]	size_of_view	Number of elements in the new ArrayView.

Precondition: starting_index + size_of_view <= vector.size()

Definition at line 907 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
	)

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]	vector	The vector for which we want to have an array view object.
[in]	starting_index	The index of the first element of the vector that will be part of this view.
[in]	size_of_view	Number of elements in the new ArrayView.

Precondition: starting_index + size_of_view <= vector.size()

Definition at line 941 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
	)

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]	table	The Table for which we want to have an array view object. The array view corresponds to an entire row.
[in]	row	The index of the row into the table to which this view should correspond.

Definition at line 972 of file array_view.h.

◆ make_array_view() [17/23]

template<typename ElementType >

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

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] table The 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 998 of file array_view.h.

◆ make_array_view() [18/23]

template<typename ElementType >

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

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] table The 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 1023 of file array_view.h.

◆ make_array_view() [19/23]

template<typename ElementType >

ArrayView< ElementType > make_array_view ( LAPACKFullMatrix< ElementType > & matrix )

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] matrix The 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 1048 of file array_view.h.

◆ make_array_view() [20/23]

template<typename ElementType >

ArrayView< const ElementType > make_array_view ( const LAPACKFullMatrix< ElementType > & matrix )

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] matrix The 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 1073 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
	)

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]	table	The Table for which we want to have an array view object. The array view corresponds to an entire row.
[in]	row	The index of the row into the table to which this view should correspond.

Definition at line 1098 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
	)

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]	table	The Table for which we want to have an array view object. The array view corresponds to an entire row.
[in]	row	The index of the row into the table to which this view should correspond.
[in]	starting_column	The index of the column into the given row of the table that corresponds to the first element of this view.
[in]	size_of_view	The 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 1127 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
	)

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]	table	The Table for which we want to have an array view object. The array view corresponds to an entire row.
[in]	row	The index of the row into the table to which this view should correspond.
[in]	starting_column	The index of the column into the given row of the table that corresponds to the first element of this view.
[in]	size_of_view	The 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 1165 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 282 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 287 of file array_view.h.

The documentation for this class was generated from the following file:

deal.II/base/array_view.h

Public Types

Public Member Functions

Private Attributes

Friends

Related Functions

Detailed Description

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

Member Typedef Documentation

◆ value_type

◆ iterator

◆ const_iterator

Constructor & Destructor Documentation

◆ ArrayView() [1/5]

◆ ArrayView() [2/5]

◆ ArrayView() [3/5]

◆ ArrayView() [4/5]

◆ ArrayView() [5/5]

Member Function Documentation

◆ reinit()

◆ operator==() [1/2]

◆ operator==() [2/2]

◆ operator!=() [1/2]

◆ operator!=() [2/2]

◆ size()

◆ data()

◆ begin()

◆ end()

◆ cbegin()

◆ cend()

◆ operator[]()

Friends And Related Function Documentation

◆ make_array_view() [1/23]

◆ make_array_view() [2/23]

◆ make_array_view() [3/23]

◆ make_array_view() [4/23]

◆ make_array_view() [5/23]

◆ make_array_view() [6/23]

◆ make_array_view() [7/23]

◆ make_array_view() [8/23]

◆ make_array_view() [9/23]

◆ make_array_view() [10/23]

◆ make_array_view() [11/23]

◆ make_array_view() [12/23]

◆ make_array_view() [13/23]

◆ make_array_view() [14/23]

◆ make_array_view() [15/23]

◆ make_array_view() [16/23]

◆ make_array_view() [17/23]

◆ make_array_view() [18/23]

◆ make_array_view() [19/23]

◆ make_array_view() [20/23]

◆ make_array_view() [21/23]

◆ make_array_view() [22/23]

◆ make_array_view() [23/23]

Member Data Documentation

◆ starting_element

◆ n_elements

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