Dense multidimensional container with tensor semantic. More...

#include <xarray.hpp>

Inheritance diagram for xt::xarray_container< EC, L, SC, Tag >:

Public Types
using	self_type = xarray_container<EC, L, SC, Tag>

using	base_type = xstrided_container<self_type>

using	semantic_base = xcontainer_semantic<self_type>

using	extension_base = extension::xarray_container_base_t<EC, L, SC, Tag>

using	storage_type = typename base_type::storage_type

using	allocator_type = typename base_type::allocator_type

using	value_type = typename base_type::value_type

using	reference = typename base_type::reference

using	const_reference = typename base_type::const_reference

using	pointer = typename base_type::pointer

using	const_pointer = typename base_type::const_pointer

using	shape_type = typename base_type::shape_type

using	inner_shape_type = typename base_type::inner_shape_type

using	strides_type = typename base_type::strides_type

using	backstrides_type = typename base_type::backstrides_type

using	inner_strides_type = typename base_type::inner_strides_type

using	inner_backstrides_type = typename base_type::inner_backstrides_type

using	temporary_type = typename semantic_base::temporary_type

using	expression_tag = Tag

Public Types inherited from xt::xstrided_container< xarray_container< EC, L, SC, Tag > >
using	base_type

using	storage_type

using	value_type

using	reference

using	const_reference

using	pointer

using	const_pointer

using	size_type

using	shape_type

using	strides_type

using	inner_shape_type

using	inner_strides_type

using	inner_backstrides_type

Public Types inherited from xt::xcontainer< D >
using	derived_type = D

using	inner_types = xcontainer_inner_types<D>

using	storage_type = typename inner_types::storage_type

using	allocator_type = allocator_type_t<std::decay_t<storage_type>>

using	value_type = typename storage_type::value_type

using	reference = typename inner_types::reference

using	const_reference = typename inner_types::const_reference

using	pointer = typename storage_type::pointer

using	const_pointer = typename storage_type::const_pointer

using	size_type = typename inner_types::size_type

using	difference_type = typename storage_type::difference_type

using	simd_value_type = xt_simd::simd_type<value_type>

using	bool_load_type = xt::bool_load_type<value_type>

using	shape_type = typename inner_types::shape_type

using	strides_type = typename inner_types::strides_type

using	backstrides_type = typename inner_types::backstrides_type

using	inner_shape_type = typename inner_types::inner_shape_type

using	inner_strides_type = typename inner_types::inner_strides_type

using	inner_backstrides_type = typename inner_types::inner_backstrides_type

using	iterable_base = xcontiguous_iterable<D>

using	stepper = typename iterable_base::stepper

using	const_stepper = typename iterable_base::const_stepper

using	accessible_base = xaccessible<D>

using	data_alignment = xt_simd::container_alignment_t<storage_type>

using	simd_type = xt_simd::simd_type<value_type>

using	linear_iterator = typename iterable_base::linear_iterator

using	const_linear_iterator = typename iterable_base::const_linear_iterator

using	reverse_linear_iterator = typename iterable_base::reverse_linear_iterator

using	const_reverse_linear_iterator = typename iterable_base::const_reverse_linear_iterator

template<class requested_type >
using	simd_return_type = xt_simd::simd_return_type<value_type, requested_type>

using	container_iterator = linear_iterator

using	const_container_iterator = const_linear_iterator

Public Types inherited from xt::xcontiguous_iterable< D >
using	derived_type = D

using	inner_types = xcontainer_inner_types<D>

using	iterable_base = xiterable<D>

using	stepper = typename iterable_base::stepper

using	const_stepper = typename iterable_base::const_stepper

template<layout_type L>
using	layout_iterator = typename iterable_base::template layout_iterator<L>

template<layout_type L>
using	const_layout_iterator = typename iterable_base::template const_layout_iterator<L>

template<layout_type L>
using	reverse_layout_iterator = typename iterable_base::template reverse_layout_iterator<L>

template<layout_type L>
using	const_reverse_layout_iterator = typename iterable_base::template const_reverse_layout_iterator<L>

template<class S , layout_type L>
using	broadcast_iterator = typename iterable_base::template broadcast_iterator<S, L>

template<class S , layout_type L>
using	const_broadcast_iterator = typename iterable_base::template const_broadcast_iterator<S, L>

template<class S , layout_type L>
using	reverse_broadcast_iterator = typename iterable_base::template reverse_broadcast_iterator<S, L>

template<class S , layout_type L>
using	const_reverse_broadcast_iterator = typename iterable_base::template const_reverse_broadcast_iterator<S, L>

using	linear_traits = detail::linear_iterator_traits<D>

using	linear_iterator = typename linear_traits::linear_iterator

using	const_linear_iterator = typename linear_traits::const_linear_iterator

using	reverse_linear_iterator = typename linear_traits::reverse_linear_iterator

using	const_reverse_linear_iterator = typename linear_traits::const_reverse_linear_iterator

template<layout_type L, class It1 , class It2 >
using	select_iterator_impl = std::conditional_t<L == static_layout, It1, It2>

template<layout_type L>
using	select_iterator = select_iterator_impl<L, linear_iterator, layout_iterator<L>>

template<layout_type L>
using	select_const_iterator = select_iterator_impl<L, const_linear_iterator, const_layout_iterator<L>>

template<layout_type L>
using	select_reverse_iterator = select_iterator_impl<L, reverse_linear_iterator, reverse_layout_iterator<L>>

template<layout_type L>
using	select_const_reverse_iterator

using	iterator = select_iterator< ::xt::layout_type::row_major >

using	const_iterator = select_const_iterator< ::xt::layout_type::row_major >

using	reverse_iterator = select_reverse_iterator< ::xt::layout_type::row_major >

using	const_reverse_iterator = select_const_reverse_iterator< ::xt::layout_type::row_major >

Public Types inherited from xt::xcontainer_semantic< xarray_container< EC, L, SC, Tag > >
using	base_type

using	derived_type

using	temporary_type

Public Types inherited from xt::xsemantic_base< D >
using	base_type = select_expression_base_t<D>

using	derived_type = typename base_type::derived_type

using	temporary_type = typename xcontainer_inner_types<D>::temporary_type

Public Member Functions
	xarray_container (const xarray_container &)=default

xarray_container &	operator= (const xarray_container &)=default

	xarray_container (xarray_container &&)=default

xarray_container &	operator= (xarray_container &&)=default

template<std::size_t N>
xarray_container &	operator= (xtensor_container< EC, N, L, Tag > &&rhs)

template<class E >
xarray_container &	operator= (const xexpression< E > &e)

Constructors
	xarray_container ()
	Allocates an uninitialized xarray_container that holds 0 element.

	xarray_container (const shape_type &shape, layout_type l=L)
	Allocates an uninitialized xarray_container with the specified shape and layout_type.

	xarray_container (const shape_type &shape, const_reference value, layout_type l=L)
	Allocates an xarray_container with the specified shape and layout_type.

	xarray_container (const shape_type &shape, const strides_type &strides)
	Allocates an uninitialized xarray_container with the specified shape and strides.

	xarray_container (const shape_type &shape, const strides_type &strides, const_reference value)
	Allocates an uninitialized xarray_container with the specified shape and strides.

	xarray_container (storage_type &&storage, inner_shape_type &&shape, inner_strides_type &&strides)
	Allocates an xarray_container by moving specified data, shape and strides.

	xarray_container (const value_type &t)
	Allocates an xarray_container that holds a single element initialized to the specified value.

Constructors from initializer list
	xarray_container (nested_initializer_list_t< value_type, 1 > t)
	Allocates a one-dimensional xarray_container.

	xarray_container (nested_initializer_list_t< value_type, 2 > t)
	Allocates a two-dimensional xarray_container.

	xarray_container (nested_initializer_list_t< value_type, 3 > t)
	Allocates a three-dimensional xarray_container.

	xarray_container (nested_initializer_list_t< value_type, 4 > t)
	Allocates a four-dimensional xarray_container.

	xarray_container (nested_initializer_list_t< value_type, 5 > t)
	Allocates a five-dimensional xarray_container.

template<std::size_t N>
	xarray_container (xtensor_container< EC, N, L, Tag > &&rhs)

template<class S >
xarray_container< EC, L, SC, Tag >	from_shape (S &&s)
	Allocates and returns an xarray_container with the specified shape.

template<std::size_t N>
xarray_container< EC, L, SC, Tag > &	operator= (xtensor_container< EC, N, L, Tag > &&rhs)

Public Member Functions inherited from xt::xstrided_container< xarray_container< EC, L, SC, Tag > >
void	resize (S &&shape, bool force=false)
	Resizes the container.

void	resize (S &&shape, layout_type l)
	Resizes the container.

void	resize (S &&shape, const strides_type &strides)
	Resizes the container.

auto &	reshape (S &&shape, layout_type layout=base_type::static_layout) &
	Reshapes the container and keeps old elements.

auto &	reshape (std::initializer_list< T > shape, layout_type layout=base_type::static_layout) &

layout_type	layout () const noexcept
	Return the layout_type of the container.

bool	is_contiguous () const noexcept

Public Member Functions inherited from xt::xcontainer< D >
template<class... Args>
reference	operator() (Args... args)

template<class... Args>
const_reference	operator() (Args... args) const

template<class... Args>
reference	unchecked (Args... args)

template<class... Args>
const_reference	unchecked (Args... args) const

template<class It >
reference	element (It first, It last)

template<class It >
const_reference	element (It first, It last) const

template<class S >
stepper	stepper_begin (const S &shape) noexcept

template<class S >
stepper	stepper_end (const S &shape, layout_type l) noexcept

template<class S >
const_stepper	stepper_begin (const S &shape) const noexcept

template<class S >
const_stepper	stepper_end (const S &shape, layout_type l) const noexcept

template<class align , class requested_type = value_type, std::size_t N = xt_simd::simd_traits<requested_type>::size>
container_simd_return_type_t< storage_type, value_type, requested_type >	load_simd (size_type i) const

template<class... Args>
reference	at (Args... args)

template<class... Args>
auto	at (Args... args) -> reference
	Returns a reference to the element at the specified position in the expression, after dimension and bounds checking.

template<class... Args>
const_reference	at (Args... args) const

template<class... Args>
auto	at (Args... args) const -> const_reference
	Returns a constant reference to the element at the specified position in the expression, after dimension and bounds checking.

reference	back ()
	Returns a reference to the last element of the expression.

const_reference	back () const
	Returns a constant reference to last the element of the expression.

reference	front ()
	Returns a reference to the first element of the expression.

const_reference	front () const
	Returns a constant reference to first the element of the expression.

template<class... Args>
reference	periodic (Args... args)

template<class... Args>
auto	periodic (Args... args) -> reference
	Returns a reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).

template<class... Args>
const_reference	periodic (Args... args) const

template<class... Args>
auto	periodic (Args... args) const -> const_reference
	Returns a constant reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).

size_type	size () const noexcept
	Returns the number of element in the container.

constexpr size_type	dimension () const noexcept
	Returns the number of dimensions of the container.

constexpr const inner_shape_type &	shape () const noexcept
	Returns the shape of the container.

constexpr const inner_strides_type &	strides () const noexcept
	Returns the strides of the container.

constexpr const inner_backstrides_type &	backstrides () const noexcept
	Returns the backstrides of the container.

template<class T >
void	fill (const T &value)
	Fills the container with the given value.

storage_type &	storage () noexcept
	Returns a reference to the buffer containing the elements of the container.

const storage_type &	storage () const noexcept
	Returns a constant reference to the buffer containing the elements of the container.

pointer	data () noexcept
	Returns a pointer to the underlying array serving as element storage.

const_pointer	data () const noexcept
	Returns a constant pointer to the underlying array serving as element storage.

const size_type	data_offset () const noexcept
	Returns the offset to the first element in the container.

template<class... Args>
auto	operator() (Args... args) -> reference
	Returns a reference to the element at the specified position in the container.

template<class... Args>
auto	operator() (Args... args) const -> const_reference
	Returns a constant reference to the element at the specified position in the container.

template<class... Args>
auto	unchecked (Args... args) -> reference
	Returns a reference to the element at the specified position in the container.

template<class... Args>
auto	unchecked (Args... args) const -> const_reference
	Returns a constant reference to the element at the specified position in the container.

template<class It >
auto	element (It first, It last) -> reference
	Returns a reference to the element at the specified position in the container.

template<class It >
auto	element (It first, It last) const -> const_reference
	Returns a reference to the element at the specified position in the container.

template<class S >
bool	broadcast_shape (S &shape, bool reuse_cache=false) const
	Broadcast the shape of the container to the specified parameter.

template<class S >
bool	has_linear_assign (const S &strides) const noexcept
	Checks whether the xcontainer can be linearly assigned to an expression with the specified strides.

reference	data_element (size_type i)

const_reference	data_element (size_type i) const

reference	flat (size_type i)
	Returns a reference to the element at the specified position in the container storage (as if it was one dimensional).

const_reference	flat (size_type i) const
	Returns a constant reference to the element at the specified position in the container storage (as if it was one dimensional).

template<class align , class simd >
void	store_simd (size_type i, const simd &e)

linear_iterator	linear_begin () noexcept

linear_iterator	linear_end () noexcept

const_linear_iterator	linear_begin () const noexcept

const_linear_iterator	linear_end () const noexcept

const_linear_iterator	linear_cbegin () const noexcept

const_linear_iterator	linear_cend () const noexcept

reverse_linear_iterator	linear_rbegin () noexcept

reverse_linear_iterator	linear_rend () noexcept

const_reverse_linear_iterator	linear_rbegin () const noexcept

const_reverse_linear_iterator	linear_rend () const noexcept

const_reverse_linear_iterator	linear_crbegin () const noexcept

const_reverse_linear_iterator	linear_crend () const noexcept

template<class S >
auto	stepper_begin (const S &shape) noexcept -> stepper

template<class S >
auto	stepper_end (const S &shape, layout_type l) noexcept -> stepper

template<class S >
auto	stepper_begin (const S &shape) const noexcept -> const_stepper

template<class S >
auto	stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper

template<class alignment , class requested_type , std::size_t N>
auto	load_simd (size_type i) const -> container_simd_return_type_t< storage_type, value_type, requested_type >

Public Member Functions inherited from xt::xcontiguous_iterable< D >
template<layout_type L = ::xt::layout_type::row_major>
select_iterator< L >	begin () noexcept

template<layout_type L = ::xt::layout_type::row_major>
select_iterator< L >	end () noexcept

template<layout_type L = ::xt::layout_type::row_major>
select_const_iterator< L >	begin () const noexcept

template<layout_type L = ::xt::layout_type::row_major>
select_const_iterator< L >	end () const noexcept

template<layout_type L = ::xt::layout_type::row_major>
select_const_iterator< L >	cbegin () const noexcept

template<layout_type L = ::xt::layout_type::row_major>
select_const_iterator< L >	cend () const noexcept

template<layout_type L = ::xt::layout_type::row_major>
select_reverse_iterator< L >	rbegin () noexcept

template<layout_type L = ::xt::layout_type::row_major>
select_reverse_iterator< L >	rend () noexcept

template<layout_type L = ::xt::layout_type::row_major>
select_const_reverse_iterator< L >	rbegin () const noexcept

template<layout_type L = ::xt::layout_type::row_major>
select_const_reverse_iterator< L >	rend () const noexcept

template<layout_type L = ::xt::layout_type::row_major>
select_const_reverse_iterator< L >	crbegin () const noexcept

template<layout_type L = ::xt::layout_type::row_major>
select_const_reverse_iterator< L >	crend () const noexcept

template<layout_type L = ::xt::layout_type::row_major, class S >
broadcast_iterator< S, L >	begin (const S &shape) noexcept

template<layout_type L = ::xt::layout_type::row_major, class S >
broadcast_iterator< S, L >	end (const S &shape) noexcept

template<layout_type L = ::xt::layout_type::row_major, class S >
const_broadcast_iterator< S, L >	begin (const S &shape) const noexcept

template<layout_type L = ::xt::layout_type::row_major, class S >
const_broadcast_iterator< S, L >	end (const S &shape) const noexcept

template<layout_type L = ::xt::layout_type::row_major, class S >
const_broadcast_iterator< S, L >	cbegin (const S &shape) const noexcept

template<layout_type L = ::xt::layout_type::row_major, class S >
const_broadcast_iterator< S, L >	cend (const S &shape) const noexcept

template<layout_type L = ::xt::layout_type::row_major, class S >
reverse_broadcast_iterator< S, L >	rbegin (const S &shape) noexcept

template<layout_type L = ::xt::layout_type::row_major, class S >
reverse_broadcast_iterator< S, L >	rend (const S &shape) noexcept

template<layout_type L = ::xt::layout_type::row_major, class S >
const_reverse_broadcast_iterator< S, L >	rbegin (const S &shape) const noexcept

template<layout_type L = ::xt::layout_type::row_major, class S >
const_reverse_broadcast_iterator< S, L >	rend (const S &shape) const noexcept

template<layout_type L = ::xt::layout_type::row_major, class S >
const_reverse_broadcast_iterator< S, L >	crbegin (const S &shape) const noexcept

template<layout_type L = ::xt::layout_type::row_major, class S >
const_reverse_broadcast_iterator< S, L >	crend (const S &shape) const noexcept

template<layout_type L>
auto	begin () noexcept -> select_iterator< L >
	Returns an iterator to the first element of the expression.

template<layout_type L>
auto	end () noexcept -> select_iterator< L >
	Returns an iterator to the element following the last element of the expression.

template<layout_type L>
auto	begin () const noexcept -> select_const_iterator< L >
	Returns a constant iterator to the first element of the expression.

template<layout_type L>
auto	end () const noexcept -> select_const_iterator< L >
	Returns a constant iterator to the element following the last element of the expression.

template<layout_type L>
auto	cbegin () const noexcept -> select_const_iterator< L >
	Returns a constant iterator to the first element of the expression.

template<layout_type L>
auto	cend () const noexcept -> select_const_iterator< L >
	Returns a constant iterator to the element following the last element of the expression.

template<layout_type L>
auto	rbegin () noexcept -> select_reverse_iterator< L >
	Returns an iterator to the first element of the reversed expression.

template<layout_type L>
auto	rend () noexcept -> select_reverse_iterator< L >
	Returns an iterator to the element following the last element of the reversed expression.

template<layout_type L>
auto	rbegin () const noexcept -> select_const_reverse_iterator< L >
	Returns a constant iterator to the first element of the reversed expression.

template<layout_type L>
auto	rend () const noexcept -> select_const_reverse_iterator< L >
	Returns a constant iterator to the element following the last element of the reversed expression.

template<layout_type L>
auto	crbegin () const noexcept -> select_const_reverse_iterator< L >
	Returns a constant iterator to the first element of the reversed expression.

template<layout_type L>
auto	crend () const noexcept -> select_const_reverse_iterator< L >
	Returns a constant iterator to the element following the last element of the reversed expression.

template<layout_type L, class S >
auto	begin (const S &shape) noexcept -> broadcast_iterator< S, L >
	Returns an iterator to the first element of the expression.

template<layout_type L, class S >
auto	end (const S &shape) noexcept -> broadcast_iterator< S, L >
	Returns an iterator to the element following the last element of the expression.

template<layout_type L, class S >
auto	begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
	Returns a constant iterator to the first element of the expression.

template<layout_type L, class S >
auto	end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
	Returns a constant iterator to the element following the last element of the expression.

template<layout_type L, class S >
auto	cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
	Returns a constant iterator to the first element of the expression.

template<layout_type L, class S >
auto	cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
	Returns a constant iterator to the element following the last element of the expression.

template<layout_type L, class S >
auto	rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
	Returns an iterator to the first element of the reversed expression.

template<layout_type L, class S >
auto	rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
	Returns an iterator to the element following the last element of the reversed expression.

template<layout_type L, class S >
auto	rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
	Returns a constant iterator to the first element of the reversed expression.

template<layout_type L, class S >
auto	rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
	Returns a constant iterator to the element following the last element of the reversed expression.

template<layout_type L, class S >
auto	crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
	Returns a constant iterator to the first element of the reversed expression.

template<layout_type L, class S >
auto	crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
	Returns a constant iterator to the element following the last element of the reversed expression.

Public Member Functions inherited from xt::xcontainer_semantic< xarray_container< EC, L, SC, Tag > >
derived_type &	assign_xexpression (const xexpression< E > &e)

derived_type &	computed_assign (const xexpression< E > &e)

derived_type &	scalar_computed_assign (const E &e, F &&f)

derived_type &	assign_temporary (temporary_type &&)
	Assigns the temporary `tmp` to `*this`.

auto	assign_xexpression (const xexpression< E > &e) -> derived_type &

auto	computed_assign (const xexpression< E > &e) -> derived_type &

auto	scalar_computed_assign (const E &e, F &&f) -> derived_type &

auto	operator= (const xexpression< E > &e) -> derived_type &

Public Member Functions inherited from xt::xsemantic_base< D >
template<class E >
disable_xexpression< E, derived_type & >	operator+= (const E &)

template<class E >
disable_xexpression< E, derived_type & >	operator-= (const E &)

template<class E >
disable_xexpression< E, derived_type & >	*operator=** (const E &)

template<class E >
disable_xexpression< E, derived_type & >	operator/= (const E &)

template<class E >
disable_xexpression< E, derived_type & >	operator%= (const E &)

template<class E >
disable_xexpression< E, derived_type & >	operator&= (const E &)

template<class E >
disable_xexpression< E, derived_type & >	operator\|= (const E &)

template<class E >
disable_xexpression< E, derived_type & >	operator^= (const E &)

template<class E >
derived_type &	operator+= (const xexpression< E > &)

template<class E >
derived_type &	operator-= (const xexpression< E > &)

template<class E >
derived_type &	*operator=** (const xexpression< E > &)

template<class E >
derived_type &	operator/= (const xexpression< E > &)

template<class E >
derived_type &	operator%= (const xexpression< E > &)

template<class E >
derived_type &	operator&= (const xexpression< E > &)

template<class E >
derived_type &	operator\|= (const xexpression< E > &)

template<class E >
derived_type &	operator^= (const xexpression< E > &)

template<class E >
derived_type &	assign (const xexpression< E > &)

template<class E >
derived_type &	plus_assign (const xexpression< E > &)

template<class E >
derived_type &	minus_assign (const xexpression< E > &)

template<class E >
derived_type &	multiplies_assign (const xexpression< E > &)

template<class E >
derived_type &	divides_assign (const xexpression< E > &)

template<class E >
derived_type &	modulus_assign (const xexpression< E > &)

template<class E >
derived_type &	bit_and_assign (const xexpression< E > &)

template<class E >
derived_type &	bit_or_assign (const xexpression< E > &)

template<class E >
derived_type &	bit_xor_assign (const xexpression< E > &)

template<class E >
auto	operator+= (const E &e) -> disable_xexpression< E, derived_type & >
	Adds the scalar `e` to `*this`.

template<class E >
auto	operator-= (const E &e) -> disable_xexpression< E, derived_type & >
	Subtracts the scalar `e` from `*this`.

template<class E >
auto	operator*= (const E &e) -> disable_xexpression< E, derived_type & >
	Multiplies `*this` with the scalar `e`.

template<class E >
auto	operator/= (const E &e) -> disable_xexpression< E, derived_type & >
	Divides `*this` by the scalar `e`.

template<class E >
auto	operator%= (const E &e) -> disable_xexpression< E, derived_type & >
	Computes the remainder of `*this` after division by the scalar `e`.

template<class E >
auto	operator&= (const E &e) -> disable_xexpression< E, derived_type & >
	Computes the bitwise and of `this` and the scalar `e` and assigns it to `this`.

template<class E >
auto	operator\|= (const E &e) -> disable_xexpression< E, derived_type & >
	Computes the bitwise or of `this` and the scalar `e` and assigns it to `this`.

template<class E >
auto	operator^= (const E &e) -> disable_xexpression< E, derived_type & >
	Computes the bitwise xor of `this` and the scalar `e` and assigns it to `this`.

template<class E >
auto	operator+= (const xexpression< E > &e) -> derived_type &
	Adds the xexpression `e` to `*this`.

template<class E >
auto	operator-= (const xexpression< E > &e) -> derived_type &
	Subtracts the xexpression `e` from `*this`.

template<class E >
auto	operator*= (const xexpression< E > &e) -> derived_type &
	Multiplies `*this` with the xexpression `e`.

template<class E >
auto	operator/= (const xexpression< E > &e) -> derived_type &
	Divides `*this` by the xexpression `e`.

template<class E >
auto	operator%= (const xexpression< E > &e) -> derived_type &
	Computes the remainder of `*this` after division by the xexpression `e`.

template<class E >
auto	operator&= (const xexpression< E > &e) -> derived_type &
	Computes the bitwise and of `this` and the xexpression `e` and assigns it to `this`.

template<class E >
auto	operator\|= (const xexpression< E > &e) -> derived_type &
	Computes the bitwise or of `this` and the xexpression `e` and assigns it to `this`.

template<class E >
auto	operator^= (const xexpression< E > &e) -> derived_type &
	Computes the bitwise xor of `this` and the xexpression `e` and assigns it to `this`.

template<class E >
auto	assign (const xexpression< E > &e) -> derived_type &
	Assigns the xexpression `e` to `*this`.

template<class E >
auto	plus_assign (const xexpression< E > &e) -> derived_type &
	Adds the xexpression `e` to `*this`.

template<class E >
auto	minus_assign (const xexpression< E > &e) -> derived_type &
	Subtracts the xexpression `e` to `*this`.

template<class E >
auto	multiplies_assign (const xexpression< E > &e) -> derived_type &
	Multiplies `*this` with the xexpression `e`.

template<class E >
auto	divides_assign (const xexpression< E > &e) -> derived_type &
	Divides `*this` by the xexpression `e`.

template<class E >
auto	modulus_assign (const xexpression< E > &e) -> derived_type &
	Computes the remainder of `*this` after division by the xexpression `e`.

template<class E >
auto	bit_and_assign (const xexpression< E > &e) -> derived_type &
	Computes the bitwise and of `e` to `*this`.

template<class E >
auto	bit_or_assign (const xexpression< E > &e) -> derived_type &
	Computes the bitwise or of `e` to `*this`.

template<class E >
auto	bit_xor_assign (const xexpression< E > &e) -> derived_type &
	Computes the bitwise xor of `e` to `*this`.

template<class E >
auto	operator= (const xexpression< E > &e) -> derived_type &

Static Public Member Functions
template<class S = shape_type>
static xarray_container	from_shape (S &&s)

Static Public Attributes
static constexpr std::size_t	rank = SIZE_MAX

Static Public Attributes inherited from xt::xcontainer< D >
static constexpr layout_type	static_layout = inner_types::layout

static constexpr bool	contiguous_layout = static_layout != layout_type::dynamic

Static Public Attributes inherited from xt::xcontiguous_iterable< D >
static constexpr layout_type	static_layout = inner_types::layout

Friends
class	xcontainer< xarray_container< EC, L, SC, Tag > >

Extended copy semantic
template<class E >
	xarray_container (const xexpression< E > &e)
	The extended copy constructor.

template<class E >
auto	operator= (const xexpression< E > &e) -> self_type &
	The extended assignment operator.

Additional Inherited Members
Protected Member Functions inherited from xt::xstrided_container< xarray_container< EC, L, SC, Tag > >
	xstrided_container (const xstrided_container &)=default

	xstrided_container (xstrided_container &&)=default

xstrided_container &	operator= (const xstrided_container &)=default

xstrided_container &	operator= (xstrided_container &&)=default

	xstrided_container (inner_shape_type &&, inner_strides_type &&) noexcept

	xstrided_container (inner_shape_type &&, inner_strides_type &&, inner_backstrides_type &&, layout_type &&) noexcept

inner_shape_type &	shape_impl () noexcept

const inner_shape_type &	shape_impl () const noexcept

inner_strides_type &	strides_impl () noexcept

const inner_strides_type &	strides_impl () const noexcept

inner_backstrides_type &	backstrides_impl () noexcept

const inner_backstrides_type &	backstrides_impl () const noexcept

void	reshape_impl (S &&shape, std::true_type, layout_type layout=base_type::static_layout)

void	reshape_impl (S &&shape, std::false_type, layout_type layout=base_type::static_layout)

layout_type &	mutable_layout () noexcept

Protected Member Functions inherited from xt::xcontainer< D >
	xcontainer (const xcontainer &)=default

xcontainer &	operator= (const xcontainer &)=default

	xcontainer (xcontainer &&)=default

xcontainer &	operator= (xcontainer &&)=default

container_iterator	data_xbegin () noexcept

const_container_iterator	data_xbegin () const noexcept

container_iterator	data_xend (layout_type l, size_type offset) noexcept

const_container_iterator	data_xend (layout_type l, size_type offset) const noexcept

derived_type &	derived_cast () &noexcept

const derived_type &	derived_cast () const &noexcept

derived_type	derived_cast () &&noexcept

Protected Member Functions inherited from xt::xcontainer_semantic< xarray_container< EC, L, SC, Tag > >
	xcontainer_semantic (const xcontainer_semantic &)=default

	xcontainer_semantic (xcontainer_semantic &&)=default

xcontainer_semantic &	operator= (const xcontainer_semantic &)=default

xcontainer_semantic &	operator= (xcontainer_semantic &&)=default

derived_type &	operator= (const xexpression< E > &)

Protected Member Functions inherited from xt::xsemantic_base< D >
	xsemantic_base (const xsemantic_base &)=default

xsemantic_base &	operator= (const xsemantic_base &)=default

	xsemantic_base (xsemantic_base &&)=default

xsemantic_base &	operator= (xsemantic_base &&)=default

template<class E >
derived_type &	operator= (const xexpression< E > &)

Detailed Description

template<class EC, layout_type L, class SC, class Tag>
class xt::xarray_container< EC, L, SC, Tag >

Dense multidimensional container with tensor semantic.

The xarray_container class implements a dense multidimensional container with tensor semantic.

Template Parameters

EC	The type of the container holding the elements.
L	The layout_type of the container.
SC	The type of the containers holding the shape and the strides.
Tag	The expression tag.

See also: xarray, xstrided_container, xcontainer

Definition at line 82 of file xarray.hpp.

Member Typedef Documentation

◆ allocator_type

template<class EC , layout_type L, class SC , class Tag >

using xt::xarray_container< EC, L, SC, Tag >::allocator_type = typename base_type::allocator_type

Definition at line 93 of file xarray.hpp.

◆ backstrides_type

template<class EC , layout_type L, class SC , class Tag >

using xt::xarray_container< EC, L, SC, Tag >::backstrides_type = typename base_type::backstrides_type

Definition at line 102 of file xarray.hpp.

◆ base_type

template<class EC , layout_type L, class SC , class Tag >

using xt::xarray_container< EC, L, SC, Tag >::base_type = xstrided_container<self_type>

Definition at line 89 of file xarray.hpp.

◆ const_pointer

template<class EC , layout_type L, class SC , class Tag >

using xt::xarray_container< EC, L, SC, Tag >::const_pointer = typename base_type::const_pointer

Definition at line 98 of file xarray.hpp.

◆ const_reference

template<class EC , layout_type L, class SC , class Tag >

using xt::xarray_container< EC, L, SC, Tag >::const_reference = typename base_type::const_reference

Definition at line 96 of file xarray.hpp.

◆ expression_tag

template<class EC , layout_type L, class SC , class Tag >

using xt::xarray_container< EC, L, SC, Tag >::expression_tag = Tag

Definition at line 106 of file xarray.hpp.

◆ extension_base

template<class EC , layout_type L, class SC , class Tag >

using xt::xarray_container< EC, L, SC, Tag >::extension_base = extension::xarray_container_base_t<EC, L, SC, Tag>

Definition at line 91 of file xarray.hpp.

◆ inner_backstrides_type

template<class EC , layout_type L, class SC , class Tag >

using xt::xarray_container< EC, L, SC, Tag >::inner_backstrides_type = typename base_type::inner_backstrides_type

Definition at line 104 of file xarray.hpp.

◆ inner_shape_type

template<class EC , layout_type L, class SC , class Tag >

using xt::xarray_container< EC, L, SC, Tag >::inner_shape_type = typename base_type::inner_shape_type

Definition at line 100 of file xarray.hpp.

◆ inner_strides_type

template<class EC , layout_type L, class SC , class Tag >

using xt::xarray_container< EC, L, SC, Tag >::inner_strides_type = typename base_type::inner_strides_type

Definition at line 103 of file xarray.hpp.

◆ pointer

template<class EC , layout_type L, class SC , class Tag >

using xt::xarray_container< EC, L, SC, Tag >::pointer = typename base_type::pointer

Definition at line 97 of file xarray.hpp.

◆ reference

template<class EC , layout_type L, class SC , class Tag >

using xt::xarray_container< EC, L, SC, Tag >::reference = typename base_type::reference

Definition at line 95 of file xarray.hpp.

◆ self_type

template<class EC , layout_type L, class SC , class Tag >

using xt::xarray_container< EC, L, SC, Tag >::self_type = xarray_container<EC, L, SC, Tag>

Definition at line 88 of file xarray.hpp.

◆ semantic_base

template<class EC , layout_type L, class SC , class Tag >

using xt::xarray_container< EC, L, SC, Tag >::semantic_base = xcontainer_semantic<self_type>

Definition at line 90 of file xarray.hpp.

◆ shape_type

template<class EC , layout_type L, class SC , class Tag >

using xt::xarray_container< EC, L, SC, Tag >::shape_type = typename base_type::shape_type

Definition at line 99 of file xarray.hpp.

◆ storage_type

template<class EC , layout_type L, class SC , class Tag >

using xt::xarray_container< EC, L, SC, Tag >::storage_type = typename base_type::storage_type

Definition at line 92 of file xarray.hpp.

◆ strides_type

template<class EC , layout_type L, class SC , class Tag >

using xt::xarray_container< EC, L, SC, Tag >::strides_type = typename base_type::strides_type

Definition at line 101 of file xarray.hpp.

◆ temporary_type

template<class EC , layout_type L, class SC , class Tag >

using xt::xarray_container< EC, L, SC, Tag >::temporary_type = typename semantic_base::temporary_type

Definition at line 105 of file xarray.hpp.

◆ value_type

template<class EC , layout_type L, class SC , class Tag >

using xt::xarray_container< EC, L, SC, Tag >::value_type = typename base_type::value_type

Definition at line 94 of file xarray.hpp.

Constructor & Destructor Documentation

◆ xarray_container() [1/14]

template<class EC , layout_type L, class SC , class Tag >

xt::xarray_container< EC, L, SC, Tag >::xarray_container ( )

inline

Allocates an uninitialized xarray_container that holds 0 element.

Definition at line 281 of file xarray.hpp.

◆ xarray_container() [2/14]

template<class EC , layout_type L, class SC , class Tag >

xt::xarray_container< EC, L, SC, Tag >::xarray_container	(	const shape_type &	shape,
		layout_type	l = L )

inlineexplicit

Allocates an uninitialized xarray_container with the specified shape and layout_type.

Parameters

shape	the shape of the xarray_container
l	the layout_type of the xarray_container

Definition at line 294 of file xarray.hpp.

◆ xarray_container() [3/14]

template<class EC , layout_type L, class SC , class Tag >

xt::xarray_container< EC, L, SC, Tag >::xarray_container	(	const shape_type &	shape,
		const_reference	value,
		layout_type	l = L )

inlineexplicit

Allocates an xarray_container with the specified shape and layout_type.

Elements are initialized to the specified value.

Parameters

shape	the shape of the xarray_container
value	the value of the elements
l	the layout_type of the xarray_container

Definition at line 308 of file xarray.hpp.

◆ xarray_container() [4/14]

template<class EC , layout_type L, class SC , class Tag >

xt::xarray_container< EC, L, SC, Tag >::xarray_container	(	const shape_type &	shape,
		const strides_type &	strides )

inlineexplicit

Allocates an uninitialized xarray_container with the specified shape and strides.

Parameters

shape	the shape of the xarray_container
strides	the strides of the xarray_container

Definition at line 325 of file xarray.hpp.

◆ xarray_container() [5/14]

template<class EC , layout_type L, class SC , class Tag >

xt::xarray_container< EC, L, SC, Tag >::xarray_container	(	const shape_type &	shape,
		const strides_type &	strides,
		const_reference	value )

inlineexplicit

Allocates an uninitialized xarray_container with the specified shape and strides.

Elements are initialized to the specified value.

Parameters

shape	the shape of the xarray_container
strides	the strides of the xarray_container
value	the value of the elements

Definition at line 339 of file xarray.hpp.

◆ xarray_container() [6/14]

template<class EC , layout_type L, class SC , class Tag >

xt::xarray_container< EC, L, SC, Tag >::xarray_container	(	storage_type &&	storage,
		inner_shape_type &&	shape,
		inner_strides_type &&	strides )

inlineexplicit

Allocates an xarray_container by moving specified data, shape and strides.

Parameters

storage	the data for the xarray_container
shape	the shape of the xarray_container
strides	the strides of the xarray_container

Definition at line 371 of file xarray.hpp.

◆ xarray_container() [7/14]

template<class EC , layout_type L, class SC , class Tag >

xt::xarray_container< EC, L, SC, Tag >::xarray_container ( const value_type & t )

inline

Allocates an xarray_container that holds a single element initialized to the specified value.

Parameters

t	the value of the element

Definition at line 356 of file xarray.hpp.

◆ xarray_container() [8/14]

template<class EC , layout_type L, class SC , class Tag >

xt::xarray_container< EC, L, SC, Tag >::xarray_container ( nested_initializer_list_t< value_type, 1 > t )

inline

Allocates a one-dimensional xarray_container.

Parameters

t	the elements of the xarray_container

Definition at line 392 of file xarray.hpp.

◆ xarray_container() [9/14]

template<class EC , layout_type L, class SC , class Tag >

xt::xarray_container< EC, L, SC, Tag >::xarray_container ( nested_initializer_list_t< value_type, 2 > t )

inline

Allocates a two-dimensional xarray_container.

Parameters

t	the elements of the xarray_container

Definition at line 405 of file xarray.hpp.

◆ xarray_container() [10/14]

template<class EC , layout_type L, class SC , class Tag >

xt::xarray_container< EC, L, SC, Tag >::xarray_container ( nested_initializer_list_t< value_type, 3 > t )

inline

Allocates a three-dimensional xarray_container.

Parameters

t	the elements of the xarray_container

Definition at line 418 of file xarray.hpp.

◆ xarray_container() [11/14]

template<class EC , layout_type L, class SC , class Tag >

xt::xarray_container< EC, L, SC, Tag >::xarray_container ( nested_initializer_list_t< value_type, 4 > t )

inline

Allocates a four-dimensional xarray_container.

Parameters

t	the elements of the xarray_container

Definition at line 431 of file xarray.hpp.

◆ xarray_container() [12/14]

template<class EC , layout_type L, class SC , class Tag >

xt::xarray_container< EC, L, SC, Tag >::xarray_container ( nested_initializer_list_t< value_type, 5 > t )

inline

Allocates a five-dimensional xarray_container.

Parameters

t	the elements of the xarray_container

Definition at line 444 of file xarray.hpp.

◆ xarray_container() [13/14]

template<class EC , layout_type L, class SC , class Tag >

template<std::size_t N>

xt::xarray_container< EC, L, SC, Tag >::xarray_container ( xtensor_container< EC, N, L, Tag > && rhs )

inlineexplicit

Definition at line 468 of file xarray.hpp.

◆ xarray_container() [14/14]

template<class EC , layout_type L, class SC , class Tag >

template<class E >

xt::xarray_container< EC, L, SC, Tag >::xarray_container ( const xexpression< E > & e )

inline

The extended copy constructor.

Definition at line 501 of file xarray.hpp.

Member Function Documentation

◆ from_shape()

template<class EC , layout_type L, class SC , class Tag >

template<class S >

xarray_container< EC, L, SC, Tag > xt::xarray_container< EC, L, SC, Tag >::from_shape ( S && s )

inline

Allocates and returns an xarray_container with the specified shape.

Parameters

s	the shape of the xarray_container

Definition at line 460 of file xarray.hpp.

◆ operator=() [1/2]

template<class EC , layout_type L, class SC , class Tag >

template<class E >

auto xt::xarray_container< EC, L, SC, Tag >::operator= ( const xexpression< E > & e ) -> self_type&

inline

The extended assignment operator.

Definition at line 518 of file xarray.hpp.

◆ operator=() [2/2]

template<class EC , layout_type L, class SC , class Tag >

template<std::size_t N>

xarray_container< EC, L, SC, Tag > & xt::xarray_container< EC, L, SC, Tag >::operator= ( xtensor_container< EC, N, L, Tag > && rhs )

inline

Definition at line 482 of file xarray.hpp.

Friends And Related Symbol Documentation

◆ xcontainer< xarray_container< EC, L, SC, Tag > >

template<class EC , layout_type L, class SC , class Tag >

friend class xcontainer< xarray_container< EC, L, SC, Tag > >

friend

Definition at line 150 of file xarray.hpp.

Member Data Documentation

◆ rank

template<class EC , layout_type L, class SC , class Tag >

constexpr std::size_t xt::xarray_container< EC, L, SC, Tag >::rank = SIZE_MAX

staticconstexpr

Definition at line 107 of file xarray.hpp.

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

/home/runner/work/xtensor/xtensor/include/xtensor/xarray.hpp

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Friends

Extended copy semantic

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ allocator_type

◆ backstrides_type

◆ base_type

◆ const_pointer

◆ const_reference

◆ expression_tag

◆ extension_base

◆ inner_backstrides_type

◆ inner_shape_type

◆ inner_strides_type

◆ pointer

◆ reference

◆ self_type

◆ semantic_base

◆ shape_type

◆ storage_type

◆ strides_type

◆ temporary_type

◆ value_type

Constructor & Destructor Documentation

◆ xarray_container() [1/14]

◆ xarray_container() [2/14]

◆ xarray_container() [3/14]

◆ xarray_container() [4/14]

◆ xarray_container() [5/14]

◆ xarray_container() [6/14]

◆ xarray_container() [7/14]

◆ xarray_container() [8/14]

◆ xarray_container() [9/14]

◆ xarray_container() [10/14]

◆ xarray_container() [11/14]

◆ xarray_container() [12/14]

◆ xarray_container() [13/14]

◆ xarray_container() [14/14]

Member Function Documentation

◆ from_shape()

◆ operator=() [1/2]

◆ operator=() [2/2]

Friends And Related Symbol Documentation

◆ xcontainer< xarray_container< EC, L, SC, Tag > >

Member Data Documentation

◆ rank