General-purpose owning tensor with immediate or deferred mdspan metadata. More...

#include <basic_tensor.hpp>

Public Types
using	accessor_factory_type = AccessorFactory

using	accessor_type = typename accessor_factory_type::template accessor_t< element_type >

using	backend_selector_type = typename storage_policy::backend_selector_type

using	const_accessor_type = typename accessor_factory_type::template accessor_t< element_type const >

using	const_device_accessor_type = detail::tensor_device_accessor_t< accessor_factory_type, element_type const >

using	const_mdspan_type = stdex::mdspan< element_type const, extents_type, layout_policy, const_accessor_type >

using	device_accessor_type = detail::tensor_device_accessor_t< accessor_factory_type, element_type >

using	element_type = ElementType

using	extents_type = Extents

using	handle_type = typename const_accessor_type::data_handle_type

using	index_type = typename extents_type::index_type

using	layout_policy = LayoutPolicy

using	layout_type = layout_policy

using	mapping_type = typename layout_policy::template mapping< extents_type >

using	mdspan_type = stdex::mdspan< element_type, extents_type, layout_policy, accessor_type >

using	mutable_handle_type = typename accessor_type::data_handle_type

template<typename NewExtents >
using	rebind_extents_type = Tensor< element_type, NewExtents::rank(), storage_policy, layout_policy, accessor_factory_type, NewExtents >
	Rebind this owning tensor configuration to another extents type.

template<typename NewLayoutPolicy >
using	rebind_layout_type = Tensor< element_type, Rank, storage_policy, NewLayoutPolicy, accessor_factory_type, extents_type >
	Rebind this owning tensor configuration to another layout policy.

using	size_type = uni20::size_type

using	storage_policy = StoragePolicy

using	storage_type = typename storage_policy::template storage_t< element_type >

using	value_type = std::remove_cv_t< element_type >

Public Member Functions
auto	accessor () const noexcept -> const_accessor_type
	Construct the tensor's read-only accessor.

auto	accessor () noexcept -> accessor_type
	Construct the tensor's mutable accessor.

auto	cols () const noexcept
	Return the matrix column count for rank-two tensors.

auto	data () const noexcept -> element_type const requires(immediately_readable &&(std::same_as< layout_type, stdex::layout_left >\|\|std::same_as< layout_type, stdex::layout_right >) &&is_default_accessor_v< const_accessor_type > &&std::same_as< handle_type, element_type const >)
	Return contiguous read-only element storage for a canonical tensor.

auto	data () noexcept -> element_type requires(immediately_writable &&(std::same_as< layout_type, stdex::layout_left >\|\|std::same_as< layout_type, stdex::layout_right >) &&is_default_accessor_v< accessor_type > &&std::same_as< mutable_handle_type, element_type >)
	Return contiguous mutable element storage for a canonical tensor.

auto	device_accessor () const noexcept -> const_device_accessor_type
	Construct the accessor stored in a read-only mdspec.

auto	device_accessor () noexcept -> device_accessor_type
	Construct the accessor stored in a mutable mdspec.

auto	extent (size_type axis) const noexcept
	Return one tensor extent.

auto	extents () const noexcept -> extents_type const &
	Return the tensor extents.

auto	handle () const noexcept -> handle_type
	Return the tensor's const storage handle.

auto	mapping () const noexcept -> mapping_type const &
	Return the tensor mapping.

auto	mdspan () const noexcept -> const_mdspan_type
	Resolve a read-only mdspan over the owned storage.

auto	mdspan () noexcept -> mdspan_type
	Resolve a writable mdspan over the owned storage.

auto	mdspec () const noexcept
	Return read-only mdspan metadata for explicit data-handle acquisition.

auto	mdspec () noexcept
	Return mutable mdspan metadata for explicit data-handle acquisition.

auto	mutable_handle () noexcept -> mutable_handle_type
	Return the tensor's mutable storage handle.

Tensor &	operator= (Tensor &&other)=default
	Move-assign tensor storage and descriptor state.

Tensor &	operator= (Tensor const &other)=default
	Copy-assign tensor storage and descriptor state.

template<class... Index> requires (sizeof...(Index) == extents_type::rank() && immediately_readable)
decltype(auto)	operator[] (Index... indices) const noexcept
	Access a const tensor element.

template<class... Index> requires (sizeof...(Index) == extents_type::rank() && immediately_writable)
decltype(auto)	operator[] (Index... indices) noexcept
	Access a mutable tensor element.

decltype(auto)	operator[] (std::array< index_type, extents_type::rank()> const &indices) const noexcept
	Access a const tensor element through an index array.

decltype(auto)	operator[] (std::array< index_type, extents_type::rank()> const &indices) noexcept
	Access a mutable tensor element through an index array.

accessor_factory_type	release_accessor_factory () &&noexcept(std::is_nothrow_move_constructible_v< accessor_factory_type >)
	Transfer the accessor-factory state out of this tensor.

storage_type	release_storage () &&noexcept(std::is_nothrow_move_constructible_v< storage_type >)
	Transfer the underlying storage container out of this tensor.

template<class Placement > requires (std::copy_constructible<accessor_factory_type> && std::is_nothrow_swappable_v<mapping_type> && std::is_nothrow_swappable_v<storage_type> && std::is_nothrow_swappable_v<accessor_factory_type> && requires(Placement const& required_placement, std::size_t count) { { storage_policy::template make_storage<element_type>(required_placement, count, StorageInitialization::Uninitialized) } -> std::same_as<storage_type>; })
void	replace (extents_type const &exts, Placement const &placement)
	Replace tensor shape and storage to satisfy a placement requirement.

template<class Placement > requires (std::copy_constructible<accessor_factory_type> && std::is_nothrow_swappable_v<mapping_type> && std::is_nothrow_swappable_v<storage_type> && std::is_nothrow_swappable_v<accessor_factory_type> && requires(Placement const& required_placement, std::size_t count) { { storage_policy::template make_storage<element_type>(required_placement, count, StorageInitialization::Uninitialized) } -> std::same_as<storage_type>; })
void	replace (uninitialized_t, extents_type const &exts, Placement const &placement)
	Replace shape and placement with explicitly uninitialized storage.

void	replace_mapping (mapping_type mapping)
	Replace the tensor mapping without moving or reallocating storage.

void	reset_shape (extents_type const &exts)
	Replace the tensor shape and initialize its new elements to zero.

void	reset_shape (uninitialized_t, extents_type const &exts)
	Replace the shape with explicitly uninitialized storage.

auto	rows () const noexcept
	Return the matrix row count for rank-two tensors.

auto	size () const noexcept -> size_type
	Return the number of elements in the mapped storage span.

storage_type const &	storage () const noexcept
	Access the owned storage container.

storage_type &	storage () noexcept
	Access the owned storage container.

template<class Placement > requires requires(storage_type const& storage, Placement const& placement) { { storage_policy::storage_is_compatible(storage, placement) } -> std::convertible_to<bool>; }
bool	storage_is_compatible (Placement const &placement) const
	Report whether owned storage satisfies a placement requirement.

	Tensor ()
	Default-construct a rank-zero tensor with its one logical element set to zero.

	Tensor ()=default
	Default-construct an empty positive-rank tensor without allocated storage.

template<class... Args> requires (std::same_as<storage_policy, HostStorage> && requires(Precision p) { require_precision<value_type>(p); } && extents_type::rank_dynamic() == Rank && sizeof...(Args) == Rank + 1 && std::same_as<std::tuple_element_t<Rank, std::tuple<Args...>>, Precision> && detail::integral_prefix<std::tuple<Args...>>(std::make_index_sequence<Rank>{}))
	Tensor (Args... args)
	Construct a dynamically shaped tensor with a trailing Precision argument.

template<std::integral... DynamicExtents> requires (extents_type::rank() > 0 && extents_type::rank_dynamic() == extents_type::rank() && sizeof...(DynamicExtents) == extents_type::rank() && detail::DefaultTensorStorage<storage_type>)
	Tensor (DynamicExtents... dynamic_extents)
	Construct a fully dynamic tensor from one extent per axis.

	Tensor (extents_type const &exts, accessor_factory_type accessor_factory=accessor_factory_type{})
	Construct a zero-initialized tensor with default layout and accessor factory.

template<typename MappingBuilder > requires (layout::mapping_builder_for<MappingBuilder, layout_policy, extents_type> && (!std::same_as<std::remove_cvref_t<MappingBuilder>, accessor_factory_type>) && detail::DefaultTensorStorage<storage_type>)
	Tensor (extents_type const &exts, MappingBuilder &&mapping_builder, accessor_factory_type accessor_factory=accessor_factory_type{})
	Construct a tensor using a custom mapping builder.

	Tensor (extents_type const &exts, Precision p)
	Construct actual zeros at the supplied default working precision.

	Tensor (extents_type const &exts, std::array< index_type, extents_type::rank()> const &strides, accessor_factory_type accessor_factory=accessor_factory_type{})
	Construct a tensor from explicit extents and strides.

template<TensorView InputTensor> requires (tensor_mdspec_t<InputTensor>::rank() == extents_type::rank() && std::default_initializable<accessor_factory_type> && detail::DefaultTensorStorage<storage_type>)
	Tensor (InputTensor const &input)
	Materialize an independent owning tensor from a readable tensor view.

template<class Placement > requires requires(Placement const& placement, std::size_t count) { { storage_policy::template make_storage<element_type>(placement, count, StorageInitialization::Uninitialized) } -> std::same_as<storage_type>; }
	Tensor (Placement const &placement, extents_type const &exts, accessor_factory_type accessor_factory=accessor_factory_type{})
	Construct a tensor with storage satisfying a placement value.

	Tensor (Tensor &&other)=default
	Move-construct an owning tensor.

	Tensor (Tensor const &other)=default
	Copy-construct a tensor with independent owned storage.

template<class Policy = storage_policy, std::integral... DynamicExtents> requires (extents_type::rank() > 0 && extents_type::rank_dynamic() == extents_type::rank() && sizeof...(DynamicExtents) == extents_type::rank() && requires(typename Policy::context_type& context, std::size_t count) { { Policy::template make_storage<element_type>(context, count, StorageInitialization::Uninitialized) } -> std::same_as<storage_type>; })
	Tensor (typename Policy::context_type &context, DynamicExtents... dynamic_extents)
	Construct a fully dynamic tensor in an explicit storage context.

template<class Policy = storage_policy> requires requires(typename Policy::context_type& context, std::size_t count) { { Policy::template make_storage<element_type>(context, count, StorageInitialization::Uninitialized) } -> std::same_as<storage_type>; }
	Tensor (typename Policy::context_type &context, extents_type const &exts, accessor_factory_type accessor_factory=accessor_factory_type{})
	Construct a tensor in an explicit storage context.

	Tensor (uninitialized_t)
	Allocate the single rank-zero element without numerical initialization.

template<class... Args> requires (std::same_as<storage_policy, HostStorage> && requires(Precision p) { require_precision<value_type>(p); } && extents_type::rank_dynamic() == Rank && sizeof...(Args) == Rank + 1 && std::same_as<std::tuple_element_t<Rank, std::tuple<Args...>>, Precision> && detail::integral_prefix<std::tuple<Args...>>(std::make_index_sequence<Rank>{}))
	Tensor (uninitialized_t, Args... args)

template<std::integral... DynamicExtents> requires (extents_type::rank() > 0 && extents_type::rank_dynamic() == extents_type::rank() && sizeof...(DynamicExtents) == extents_type::rank() && detail::DefaultTensorStorage<storage_type>)
	Tensor (uninitialized_t, DynamicExtents... dynamic_extents)
	Allocate the requested tensor shape without numerical initialization.

	Tensor (uninitialized_t, extents_type const &exts, accessor_factory_type accessor_factory=accessor_factory_type{})
	Allocate the requested tensor shape without numerical initialization.

template<typename MappingBuilder > requires (layout::mapping_builder_for<MappingBuilder, layout_policy, extents_type> && (!std::same_as<std::remove_cvref_t<MappingBuilder>, accessor_factory_type>) && detail::DefaultTensorStorage<storage_type>)
	Tensor (uninitialized_t, extents_type const &exts, MappingBuilder &&mapping_builder, accessor_factory_type accessor_factory=accessor_factory_type{})
	Allocate the requested tensor shape without numerical initialization.

	Tensor (uninitialized_t, extents_type const &exts, Precision p)
	Allocate uninitialized elements with a compatible working precision.

	Tensor (uninitialized_t, extents_type const &exts, std::array< index_type, extents_type::rank()> const &strides, accessor_factory_type accessor_factory=accessor_factory_type{})
	Allocate the requested tensor shape without numerical initialization.

template<class Placement > requires requires(Placement const& placement, std::size_t count) { { storage_policy::template make_storage<element_type>(placement, count, StorageInitialization::Uninitialized) } -> std::same_as<storage_type>; }
	Tensor (uninitialized_t, Placement const &placement, extents_type const &exts, accessor_factory_type accessor_factory=accessor_factory_type{})
	Allocate the requested tensor shape without numerical initialization.

template<class Policy = storage_policy, std::integral... DynamicExtents> requires (extents_type::rank() > 0 && extents_type::rank_dynamic() == extents_type::rank() && sizeof...(DynamicExtents) == extents_type::rank() && requires(typename Policy::context_type& context, std::size_t count) { { Policy::template make_storage<element_type>(context, count, StorageInitialization::Uninitialized) } -> std::same_as<storage_type>; })
	Tensor (uninitialized_t, typename Policy::context_type &context, DynamicExtents... dynamic_extents)
	Allocate the requested tensor shape without numerical initialization.

template<class Policy = storage_policy> requires requires(typename Policy::context_type& context, std::size_t count) { { Policy::template make_storage<element_type>(context, count, StorageInitialization::Uninitialized) } -> std::same_as<storage_type>; }
	Tensor (uninitialized_t, typename Policy::context_type &context, extents_type const &exts, accessor_factory_type accessor_factory=accessor_factory_type{})
	Allocate the requested tensor shape without numerical initialization.

Static Public Member Functions
static Tensor	adopt_storage (mapping_type mapping, storage_type storage, accessor_factory_type accessor_factory=accessor_factory_type{})
	Adopt an existing storage container without reallocating it.

static constexpr auto	backend_selector () noexcept -> backend_selector_type
	Return the default backend selector associated with this tensor's storage.

static constexpr size_type	rank () noexcept
	Return the tensor rank.

static constexpr size_type	rank_dynamic () noexcept
	Return the number of dynamic extents.

Static Public Attributes
static constexpr bool	deferred_readable
	Whether const storage provides deferred read metadata.

static constexpr bool	deferred_writable
	Whether mutable storage provides deferred write metadata.

static constexpr bool	immediately_readable
	Whether const storage provides a readable data handle without acquisition.

static constexpr bool	immediately_writable
	Whether mutable storage provides a writable data handle without acquisition.

Detailed Description

template<typename ElementType, std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>
class uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >

General-purpose owning tensor with immediate or deferred mdspan metadata.

Template Parameters

ElementType	Value type stored by the tensor.
Rank	Static rank of the tensor.
StoragePolicy	Policy controlling ownership and allocation of the buffer.
LayoutPolicy	Layout policy that determines index ordering and stride computation.
AccessorFactory	Factory that produces accessors for the storage handle.
Extents	Extents type describing the tensor shape; fully dynamic by default.

Member Typedef Documentation

◆ accessor_factory_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::accessor_factory_type = AccessorFactory

◆ accessor_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::accessor_type = typename accessor_factory_type::template accessor_t<element_type>

◆ backend_selector_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::backend_selector_type = typename storage_policy::backend_selector_type

◆ const_accessor_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::const_accessor_type = typename accessor_factory_type::template accessor_t<element_type const>

◆ const_device_accessor_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::const_device_accessor_type = detail::tensor_device_accessor_t<accessor_factory_type, element_type const>

◆ const_mdspan_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::const_mdspan_type = stdex::mdspan<element_type const, extents_type, layout_policy, const_accessor_type>

◆ device_accessor_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::device_accessor_type = detail::tensor_device_accessor_t<accessor_factory_type, element_type>

◆ element_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::element_type = ElementType

◆ extents_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::extents_type = Extents

◆ handle_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::handle_type = typename const_accessor_type::data_handle_type

◆ index_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::index_type = typename extents_type::index_type

◆ layout_policy

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::layout_policy = LayoutPolicy

◆ layout_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::layout_type = layout_policy

◆ mapping_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::mapping_type = typename layout_policy::template mapping<extents_type>

◆ mdspan_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::mdspan_type = stdex::mdspan<element_type, extents_type, layout_policy, accessor_type>

◆ mutable_handle_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::mutable_handle_type = typename accessor_type::data_handle_type

◆ rebind_extents_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<typename NewExtents >

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::rebind_extents_type = Tensor<element_type, NewExtents::rank(), storage_policy, layout_policy, accessor_factory_type, NewExtents>

Rebind this owning tensor configuration to another extents type.

◆ rebind_layout_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<typename NewLayoutPolicy >

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::rebind_layout_type = Tensor<element_type, Rank, storage_policy, NewLayoutPolicy, accessor_factory_type, extents_type>

Rebind this owning tensor configuration to another layout policy.

◆ size_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::size_type = uni20::size_type

◆ storage_policy

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::storage_policy = StoragePolicy

◆ storage_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::storage_type = typename storage_policy::template storage_t<element_type>

◆ value_type

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

using uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::value_type = std::remove_cv_t<element_type>

Constructor & Destructor Documentation

◆ Tensor() [1/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor ( )

default

Default-construct an empty positive-rank tensor without allocated storage.

◆ Tensor() [2/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor ( )

inline

Default-construct a rank-zero tensor with its one logical element set to zero.

◆ Tensor() [3/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor ( uninitialized_t )

inlineexplicit

Allocate the single rank-zero element without numerical initialization.

◆ Tensor() [4/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor ( Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents > const & other )

default

Copy-construct a tensor with independent owned storage.

Tensor elements, mapping, and accessor-factory state are copied. Resolved mdspans are constructed on demand from this tensor's own storage.

Parameters

other Source tensor to copy.

◆ Tensor() [5/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor ( Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents > && other )

default

Move-construct an owning tensor.

Existing non-owning views and mdspans into the source must not be used after ownership is transferred.

Parameters

other Source tensor to move from.

◆ Tensor() [6/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<TensorView InputTensor>
requires (tensor_mdspec_t<InputTensor>::rank() == extents_type::rank() && std::default_initializable<accessor_factory_type> && detail::DefaultTensorStorage<storage_type>)

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor ( InputTensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents > const & input )

inlineexplicit

Materialize an independent owning tensor from a readable tensor view.

The destination's scalar, extents, storage, layout, and accessor policies are fixed by this specialization. Values are copied through the ordinary backend-dispatch path.

Template Parameters

InputTensor Readable tensor-level source with matching static rank.

Parameters

input Source tensor view whose values are materialized.

◆ Tensor() [7/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor	(	extents_type const &	exts,
		accessor_factory_type	accessor_factory = `accessor_factory_type{}`
	)

inlineexplicit

Construct a zero-initialized tensor with default layout and accessor factory.

Parameters

exts	Extents that describe the tensor shape.
accessor_factory	Factory used to create the accessor for the storage handle.

◆ Tensor() [8/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor	(	extents_type const &	exts,
		Precision	p
	)

inlineexplicit

Construct actual zeros at the supplied default working precision.

Fixed scalar types require their native precision and store no precision metadata.

◆ Tensor() [9/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor	(	uninitialized_t	,
		extents_type const &	exts,
		Precision	p
	)

inlineexplicit

Allocate uninitialized elements with a compatible working precision.

Runtime scalars are unset placeholders; fixed scalars require native precision.

◆ Tensor() [10/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<class... Args>
requires (std::same_as<storage_policy, HostStorage> && requires(Precision p) { require_precision<value_type>(p); } && extents_type::rank_dynamic() == Rank && sizeof...(Args) == Rank + 1 && std::same_as<std::tuple_element_t<Rank, std::tuple<Args...>>, Precision> && detail::integral_prefix<std::tuple<Args...>>(std::make_index_sequence<Rank>{}))

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor ( Args... args )

inlineexplicit

Construct a dynamically shaped tensor with a trailing Precision argument.

◆ Tensor() [11/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<class... Args>
requires (std::same_as<storage_policy, HostStorage> && requires(Precision p) { require_precision<value_type>(p); } && extents_type::rank_dynamic() == Rank && sizeof...(Args) == Rank + 1 && std::same_as<std::tuple_element_t<Rank, std::tuple<Args...>>, Precision> && detail::integral_prefix<std::tuple<Args...>>(std::make_index_sequence<Rank>{}))

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor	(	uninitialized_t	,
		Args...	args
	)

inlineexplicit

◆ Tensor() [12/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor	(	uninitialized_t	,
		extents_type const &	exts,
		accessor_factory_type	accessor_factory = `accessor_factory_type{}`
	)

inlineexplicit

Allocate the requested tensor shape without numerical initialization.

◆ Tensor() [13/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<class Policy = storage_policy>
requires requires(typename Policy::context_type& context, std::size_t count) { { Policy::template make_storage<element_type>(context, count, StorageInitialization::Uninitialized) } -> std::same_as<storage_type>; }

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor	(	typename Policy::context_type &	context,
		extents_type const &	exts,
		accessor_factory_type	accessor_factory = `accessor_factory_type{}`
	)

inlineexplicit

Construct a tensor in an explicit storage context.

Context-bound storage policies use this form to retain device placement without hiding allocation or transfer decisions.

Template Parameters

Policy Context-bound storage policy; defaults to this Tensor's policy.

Parameters

context	Context used by the storage policy to allocate the buffer.
exts	Extents that describe the tensor shape.
accessor_factory	Factory used to create the accessor for the storage handle.

◆ Tensor() [14/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<class Policy = storage_policy>
requires requires(typename Policy::context_type& context, std::size_t count) { { Policy::template make_storage<element_type>(context, count, StorageInitialization::Uninitialized) } -> std::same_as<storage_type>; }

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor	(	uninitialized_t	,
		typename Policy::context_type &	context,
		extents_type const &	exts,
		accessor_factory_type	accessor_factory = `accessor_factory_type{}`
	)

inlineexplicit

Allocate the requested tensor shape without numerical initialization.

◆ Tensor() [15/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<class Placement >
requires requires(Placement const& placement, std::size_t count) { { storage_policy::template make_storage<element_type>(placement, count, StorageInitialization::Uninitialized) } -> std::same_as<storage_type>; }

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor	(	Placement const &	placement,
		extents_type const &	exts,
		accessor_factory_type	accessor_factory = `accessor_factory_type{}`
	)

inlineexplicit

Construct a tensor with storage satisfying a placement value.

The storage policy interprets the placement and resolves any allocation resources needed to construct the buffer.

Template Parameters

Placement Storage-policy placement value.

Parameters

placement	Required storage placement.
exts	Extents that describe the tensor shape.
accessor_factory	Factory used to create the accessor for the storage handle.

◆ Tensor() [16/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<class Placement >
requires requires(Placement const& placement, std::size_t count) { { storage_policy::template make_storage<element_type>(placement, count, StorageInitialization::Uninitialized) } -> std::same_as<storage_type>; }

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor	(	uninitialized_t	,
		Placement const &	placement,
		extents_type const &	exts,
		accessor_factory_type	accessor_factory = `accessor_factory_type{}`
	)

inlineexplicit

Allocate the requested tensor shape without numerical initialization.

◆ Tensor() [17/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<std::integral... DynamicExtents>
requires (extents_type::rank() > 0 && extents_type::rank_dynamic() == extents_type::rank() && sizeof...(DynamicExtents) == extents_type::rank() && detail::DefaultTensorStorage<storage_type>)

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor ( DynamicExtents... dynamic_extents )

inlineexplicit

Construct a fully dynamic tensor from one extent per axis.

This convenience form is available when every extent is dynamic and keeps rank-specific aliases ergonomic without adding wrapper classes solely for constructors.

Template Parameters

DynamicExtents Integral extent arguments, one per tensor axis.

Parameters

dynamic_extents Tensor extents in axis order.

◆ Tensor() [18/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<std::integral... DynamicExtents>
requires (extents_type::rank() > 0 && extents_type::rank_dynamic() == extents_type::rank() && sizeof...(DynamicExtents) == extents_type::rank() && detail::DefaultTensorStorage<storage_type>)

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor	(	uninitialized_t	,
		DynamicExtents...	dynamic_extents
	)

inlineexplicit

Allocate the requested tensor shape without numerical initialization.

◆ Tensor() [19/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<class Policy = storage_policy, std::integral... DynamicExtents>
requires (extents_type::rank() > 0 && extents_type::rank_dynamic() == extents_type::rank() && sizeof...(DynamicExtents) == extents_type::rank() && requires(typename Policy::context_type& context, std::size_t count) { { Policy::template make_storage<element_type>(context, count, StorageInitialization::Uninitialized) } -> std::same_as<storage_type>; })

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor	(	typename Policy::context_type &	context,
		DynamicExtents...	dynamic_extents
	)

inlineexplicit

Construct a fully dynamic tensor in an explicit storage context.

Template Parameters

Policy	Context-bound storage policy; defaults to this Tensor's policy.
DynamicExtents	Integral extent arguments, one per tensor axis.

Parameters

context	Context used by the storage policy to allocate the buffer.
dynamic_extents	Tensor extents in axis order.

◆ Tensor() [20/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<class Policy = storage_policy, std::integral... DynamicExtents>
requires (extents_type::rank() > 0 && extents_type::rank_dynamic() == extents_type::rank() && sizeof...(DynamicExtents) == extents_type::rank() && requires(typename Policy::context_type& context, std::size_t count) { { Policy::template make_storage<element_type>(context, count, StorageInitialization::Uninitialized) } -> std::same_as<storage_type>; })

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor	(	uninitialized_t	,
		typename Policy::context_type &	context,
		DynamicExtents...	dynamic_extents
	)

inlineexplicit

Allocate the requested tensor shape without numerical initialization.

◆ Tensor() [21/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<typename MappingBuilder >
requires (layout::mapping_builder_for<MappingBuilder, layout_policy, extents_type> && (!std::same_as<std::remove_cvref_t<MappingBuilder>, accessor_factory_type>) && detail::DefaultTensorStorage<storage_type>)

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor	(	extents_type const &	exts,
		MappingBuilder &&	mapping_builder,
		accessor_factory_type	accessor_factory = `accessor_factory_type{}`
	)

inlineexplicit

Construct a tensor using a custom mapping builder.

Template Parameters

MappingBuilder Callable that returns a mapping compatible with the layout policy.

Parameters

exts	Extents that describe the tensor shape.
mapping_builder	Builder used to derive the mapping from the extents.
accessor_factory	Factory used to create the accessor for the storage handle.

◆ Tensor() [22/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<typename MappingBuilder >
requires (layout::mapping_builder_for<MappingBuilder, layout_policy, extents_type> && (!std::same_as<std::remove_cvref_t<MappingBuilder>, accessor_factory_type>) && detail::DefaultTensorStorage<storage_type>)

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor	(	uninitialized_t	,
		extents_type const &	exts,
		MappingBuilder &&	mapping_builder,
		accessor_factory_type	accessor_factory = `accessor_factory_type{}`
	)

inlineexplicit

Allocate the requested tensor shape without numerical initialization.

◆ Tensor() [23/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor	(	extents_type const &	exts,
		std::array< index_type, extents_type::rank()> const &	strides,
		accessor_factory_type	accessor_factory = `accessor_factory_type{}`
	)

inlineexplicit

Construct a tensor from explicit extents and strides.

Parameters

exts	Extents that describe the tensor shape.
strides	Stride specification per dimension for the layout mapping.
accessor_factory	Factory used to create the accessor for the storage handle.

◆ Tensor() [24/24]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::Tensor	(	uninitialized_t	,
		extents_type const &	exts,
		std::array< index_type, extents_type::rank()> const &	strides,
		accessor_factory_type	accessor_factory = `accessor_factory_type{}`
	)

inlineexplicit

Allocate the requested tensor shape without numerical initialization.

Member Function Documentation

◆ accessor() [1/2]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

auto uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::accessor ( ) const -> const_accessor_type

inlinenoexcept

Construct the tensor's read-only accessor.

Returns: Accessor used to construct read-only resolved mdspans.

◆ accessor() [2/2]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

auto uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::accessor ( ) -> accessor_type

inlinenoexcept

Construct the tensor's mutable accessor.

Returns: Accessor used to construct writable resolved mdspans.

◆ adopt_storage()

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

static Tensor uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::adopt_storage	(	mapping_type	mapping,
		storage_type	storage,
		accessor_factory_type	accessor_factory = `accessor_factory_type{}`
	)

inlinestatic

Adopt an existing storage container without reallocating it.

The storage may contain padding or an unused tail, but its logical size must cover the mapping's required span. The caller is responsible for ensuring that the mapping and accessor factory are valid for the transferred allocation.

Parameters

mapping	Mapping to expose through the adopted tensor.
storage	Storage container whose ownership is transferred.
accessor_factory	Factory used to resolve mdspan accessors.

Returns: An owning tensor over the transferred storage.

◆ backend_selector()

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

static constexpr auto uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::backend_selector ( ) -> backend_selector_type

inlinestaticconstexprnoexcept

Return the default backend selector associated with this tensor's storage.

Returns: Ordered backend selector value for tensor-level dispatch.

◆ cols()

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

auto uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::cols ( ) const

inlinenoexcept

Return the matrix column count for rank-two tensors.

Returns: Second tensor extent.

◆ data() [1/2]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

auto uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::data ( ) const -> element_type const* requires(immediately_readable && (std::same_as<layout_type, stdex::layout_left> || std::same_as<layout_type, stdex::layout_right>) && is_default_accessor_v<const_accessor_type> && std::same_as<handle_type, element_type const*>)

inlinenoexcept

Return contiguous read-only element storage for a canonical tensor.

This convenience is available only for immediately accessible layout_left or layout_right tensors using the ordinary default accessor and a pointer data handle. Other tensors must preserve mapping and accessor semantics through mdspan() or explicit access acquisition.

Returns: Pointer to the first element in canonical contiguous storage.

◆ data() [2/2]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

auto uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::data ( ) -> element_type* requires(immediately_writable && (std::same_as<layout_type, stdex::layout_left> || std::same_as<layout_type, stdex::layout_right>) && is_default_accessor_v<accessor_type> && std::same_as<mutable_handle_type, element_type*>)

inlinenoexcept

Return contiguous mutable element storage for a canonical tensor.

This convenience is available only for immediately accessible layout_left or layout_right tensors using the ordinary default accessor and a pointer data handle. Other tensors must preserve mapping and accessor semantics through mdspan() or explicit access acquisition.

Returns: Pointer to the first element in canonical contiguous storage.

◆ device_accessor() [1/2]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

auto uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::device_accessor ( ) const -> const_device_accessor_type

inlinenoexcept

Construct the accessor stored in a read-only mdspec.

◆ device_accessor() [2/2]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

auto uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::device_accessor ( ) -> device_accessor_type

inlinenoexcept

Construct the accessor stored in a mutable mdspec.

◆ extent()

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

auto uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::extent ( size_type axis ) const

inlinenoexcept

Return one tensor extent.

Parameters

axis	Axis whose extent is requested.

Returns: Extent of the requested axis.

◆ extents()

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

auto uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::extents ( ) const -> extents_type const&

inlinenoexcept

Return the tensor extents.

Returns: Extents contained in the mapping.

◆ handle()

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

auto uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::handle ( ) const -> handle_type

inlinenoexcept

Return the tensor's const storage handle.

Returns: Handle addressing the beginning of the owned storage.

◆ mapping()

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

auto uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::mapping ( ) const -> mapping_type const&

inlinenoexcept

Return the tensor mapping.

Returns: Mapping containing extents and strides.

◆ mdspan() [1/2]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

auto uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::mdspan ( ) const -> const_mdspan_type

inlinenoexcept

Resolve a read-only mdspan over the owned storage.

Returns: Const mdspan preserving the tensor mapping and accessor semantics.

◆ mdspan() [2/2]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

auto uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::mdspan ( ) -> mdspan_type

inlinenoexcept

Resolve a writable mdspan over the owned storage.

Returns: Mutable mdspan preserving the tensor mapping and accessor semantics.

◆ mdspec() [1/2]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

auto uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::mdspec ( ) const

inlinenoexcept

Return read-only mdspan metadata for explicit data-handle acquisition.

Immediate storage returns the ordinary const mdspan. Descriptor-backed storage returns mdspec without acquiring its handle.

◆ mdspec() [2/2]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

auto uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::mdspec ( )

inlinenoexcept

Return mutable mdspan metadata for explicit data-handle acquisition.

Immediate storage returns the ordinary mdspan. Descriptor-backed storage returns mdspec without acquiring its handle.

◆ mutable_handle()

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

auto uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::mutable_handle ( ) -> mutable_handle_type

inlinenoexcept

Return the tensor's mutable storage handle.

Returns: Mutable handle addressing the beginning of the owned storage.

◆ operator=() [1/2]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

Tensor & uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::operator= ( Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents > && other )

default

Move-assign tensor storage and descriptor state.

Existing non-owning views and mdspans into either tensor must not be used after ownership is transferred.

Parameters

other Source tensor to move from.

Returns: Reference to *this.

◆ operator=() [2/2]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

Tensor & uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::operator= ( Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents > const & other )

default

Copy-assign tensor storage and descriptor state.

Parameters

other Source tensor to copy.

Returns: Reference to *this.

◆ operator[]() [1/4]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<class... Index>
requires (sizeof...(Index) == extents_type::rank() && immediately_readable)

decltype(auto) uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::operator[] ( Index... indices ) const

inlinenoexcept

Access a const tensor element.

◆ operator[]() [2/4]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<class... Index>
requires (sizeof...(Index) == extents_type::rank() && immediately_writable)

decltype(auto) uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::operator[] ( Index... indices )

inlinenoexcept

Access a mutable tensor element.

◆ operator[]() [3/4]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

decltype(auto) uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::operator[] ( std::array< index_type, extents_type::rank()> const & indices ) const

inlinenoexcept

Access a const tensor element through an index array.

Parameters

indices Coordinates for every tensor axis.

Returns: Const element reference.

◆ operator[]() [4/4]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

decltype(auto) uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::operator[] ( std::array< index_type, extents_type::rank()> const & indices )

inlinenoexcept

Access a mutable tensor element through an index array.

Parameters

indices Coordinates for every tensor axis.

Returns: Mutable element reference.

◆ rank()

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

static constexpr size_type uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::rank ( )

inlinestaticconstexprnoexcept

Return the tensor rank.

Returns: Static rank of the extents type.

◆ rank_dynamic()

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

static constexpr size_type uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::rank_dynamic ( )

inlinestaticconstexprnoexcept

Return the number of dynamic extents.

Returns: Static dynamic-rank count of the extents type.

◆ release_accessor_factory()

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

accessor_factory_type uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::release_accessor_factory ( ) &&

inlinenoexcept

Transfer the accessor-factory state out of this tensor.

This accompanies storage transfer when an owning operation rebinds the allocation to a different tensor descriptor.

Returns: The factory used to resolve accessors for the transferred storage.

◆ release_storage()

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

storage_type uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::release_storage ( ) &&

inlinenoexcept

Transfer the underlying storage container out of this tensor.

The mapping and accessor-factory state remain in the moved-from tensor. Existing views and mdspans into this tensor must not be used after the transfer.

Returns: The concrete storage container selected by storage_policy.

◆ replace() [1/2]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<class Placement >
requires (std::copy_constructible<accessor_factory_type> && std::is_nothrow_swappable_v<mapping_type> && std::is_nothrow_swappable_v<storage_type> && std::is_nothrow_swappable_v<accessor_factory_type> && requires(Placement const& required_placement, std::size_t count) { { storage_policy::template make_storage<element_type>(required_placement, count, StorageInitialization::Uninitialized) } -> std::same_as<storage_type>; })

void uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::replace	(	extents_type const &	exts,
		Placement const &	placement
	)

inline

Replace tensor shape and storage to satisfy a placement requirement.

The replacement discards current values and uses the storage policy to allocate for placement. Construction completes before the current tensor state is swapped.

Template Parameters

Placement Storage-policy placement value.

Parameters

exts	New tensor extents.
placement	Required storage placement.

◆ replace() [2/2]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<class Placement >
requires (std::copy_constructible<accessor_factory_type> && std::is_nothrow_swappable_v<mapping_type> && std::is_nothrow_swappable_v<storage_type> && std::is_nothrow_swappable_v<accessor_factory_type> && requires(Placement const& required_placement, std::size_t count) { { storage_policy::template make_storage<element_type>(required_placement, count, StorageInitialization::Uninitialized) } -> std::same_as<storage_type>; })

void uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::replace	(	uninitialized_t	,
		extents_type const &	exts,
		Placement const &	placement
	)

inline

Replace shape and placement with explicitly uninitialized storage.

◆ replace_mapping()

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

void uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::replace_mapping ( mapping_type mapping )

inline

Replace the tensor mapping without moving or reallocating storage.

Existing values are reinterpreted through the replacement mapping. The mapping's required span must fit the current allocation; higher-level operations establish any stronger ordering or contiguity requirements.

Parameters

mapping Replacement mapping over the existing allocation.

◆ reset_shape() [1/2]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

void uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::reset_shape ( extents_type const & exts )

inline

Replace the tensor shape and initialize its new elements to zero.

The replacement uses the storage policy's default mapping for the new extents and preserves accessor-factory state. The replacement is constructed before the current tensor changes; supported tensor state must be nothrow-swappable so the update provides the strong exception guarantee.

Parameters

exts	New tensor extents.

◆ reset_shape() [2/2]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

void uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::reset_shape	(	uninitialized_t	,
		extents_type const &	exts
	)

inline

Replace the shape with explicitly uninitialized storage.

◆ rows()

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

auto uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::rows ( ) const

inlinenoexcept

Return the matrix row count for rank-two tensors.

Returns: First tensor extent.

◆ size()

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

auto uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::size ( ) const -> size_type

inlinenoexcept

Return the number of elements in the mapped storage span.

Returns: Required span size of the tensor mapping.

◆ storage() [1/2]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

storage_type const & uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::storage ( ) const

inlinenoexcept

Access the owned storage container.

Returns: Constant reference to the underlying storage.

◆ storage() [2/2]

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

storage_type & uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::storage ( )

inlinenoexcept

Access the owned storage container.

Returns: Mutable reference to the underlying storage.

◆ storage_is_compatible()

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

template<class Placement >
requires requires(storage_type const& storage, Placement const& placement) { { storage_policy::storage_is_compatible(storage, placement) } -> std::convertible_to<bool>; }

bool uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::storage_is_compatible ( Placement const & placement ) const

inline

Report whether owned storage satisfies a placement requirement.

Template Parameters

Placement Storage-policy placement value.

Parameters

placement Required storage placement.

Returns: true when the current allocation may be retained.

Member Data Documentation

◆ deferred_readable

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

constexpr bool uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::deferred_readable

staticconstexpr

Initial value:

=

requires(storage_type const& storage) { storage_policy::make_data_descriptor(storage); }

uni20::Tensor::storage_type

typename storage_policy::template storage_t< element_type > storage_type

Definition basic_tensor.hpp:133

uni20::Tensor::storage

storage_type & storage() noexcept

Access the owned storage container.

Definition basic_tensor.hpp:542

Whether const storage provides deferred read metadata.

◆ deferred_writable

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

constexpr bool uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::deferred_writable

staticconstexpr

Initial value:

=

requires(storage_type& storage) { storage_policy::make_data_descriptor(storage); }

Whether mutable storage provides deferred write metadata.

◆ immediately_readable

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

constexpr bool uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::immediately_readable

staticconstexpr

Initial value:

= requires(storage_type const& storage) {
      { storage_policy::make_handle(storage) } -> std::convertible_to<handle_type>;
    }

Whether const storage provides a readable data handle without acquisition.

◆ immediately_writable

template<typename ElementType , std::size_t Rank, typename StoragePolicy = HostStorage, typename LayoutPolicy = stdex::layout_left, typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>, typename Extents = stdex::dextents<index_type, Rank>>

constexpr bool uni20::Tensor< ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents >::immediately_writable

staticconstexpr

Initial value:

= requires(storage_type& storage) {
      { storage_policy::make_handle(storage) } -> std::convertible_to<mutable_handle_type>;
    }

Whether mutable storage provides a writable data handle without acquisition.

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

basic_tensor.hpp

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Detailed Description

Member Typedef Documentation

◆ accessor_factory_type

◆ accessor_type

◆ backend_selector_type

◆ const_accessor_type

◆ const_device_accessor_type

◆ const_mdspan_type

◆ device_accessor_type

◆ element_type

◆ extents_type

◆ handle_type

◆ index_type

◆ layout_policy

◆ layout_type

◆ mapping_type

◆ mdspan_type

◆ mutable_handle_type

◆ rebind_extents_type

◆ rebind_layout_type

◆ size_type

◆ storage_policy

◆ storage_type

◆ value_type

Constructor & Destructor Documentation

◆ Tensor() [1/24]

◆ Tensor() [2/24]

◆ Tensor() [3/24]

◆ Tensor() [4/24]

◆ Tensor() [5/24]

◆ Tensor() [6/24]

◆ Tensor() [7/24]

◆ Tensor() [8/24]

◆ Tensor() [9/24]

◆ Tensor() [10/24]

◆ Tensor() [11/24]

◆ Tensor() [12/24]

◆ Tensor() [13/24]

◆ Tensor() [14/24]

◆ Tensor() [15/24]

◆ Tensor() [16/24]

◆ Tensor() [17/24]

◆ Tensor() [18/24]

◆ Tensor() [19/24]

◆ Tensor() [20/24]

◆ Tensor() [21/24]

◆ Tensor() [22/24]

◆ Tensor() [23/24]

◆ Tensor() [24/24]

Member Function Documentation

◆ accessor() [1/2]

◆ accessor() [2/2]

◆ adopt_storage()

◆ backend_selector()

◆ cols()

◆ data() [1/2]

◆ data() [2/2]

◆ device_accessor() [1/2]

◆ device_accessor() [2/2]

◆ extent()

◆ extents()

◆ handle()

◆ mapping()

◆ mdspan() [1/2]

◆ mdspan() [2/2]

◆ mdspec() [1/2]

◆ mdspec() [2/2]

◆ mutable_handle()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator[]() [1/4]

◆ operator[]() [2/4]

◆ operator[]() [3/4]

◆ operator[]() [4/4]

◆ rank()

◆ rank_dynamic()