aie Namespace Reference

Detailed Description

Base namespace for AIE operations and types.

Namespaces
namespace	operators
namespace	sync

Classes
class	accum
	Type for vector accumulators. More...
struct	arch
	Structure used to represent the AIE architecture being compiled against. More...
struct	binary_op
struct	binary_op< Parent1, Parent2, Operation::Max >
struct	binary_op< Parent1, Parent2, Operation::Min >
struct	binary_op< Parent1, Parent2, Operation::Sign >
struct	binary_op< Parent1, Parent2, Operation::Zero >
struct	binary_op_common
class	circular_iterator
	Implements an iterator that wraps around when it reaches the end of the buffer and, thus, has no end. More...
class	filter_mode
	Enables precomputation of the filter element selection. More...
class	interleave_unzip_mode
	Enables precomputation of the interleave element selection. More...
class	interleave_zip_mode
	Enables precomputation of the interleave element selection. More...
struct	is_accum_op
struct	is_accum_op< binary_op< Parent1, Parent2, Op > >
struct	is_accum_op< unary_op< Parent, Op > >
struct	is_binary_op
struct	is_binary_op< binary_op< Parent1, Parent2, Op > >
struct	is_complex_op
struct	is_complex_op< binary_op< Parent1, Parent2, Op > >
struct	is_complex_op< unary_op< Parent, Op > >
struct	is_elem
struct	is_elem_op
struct	is_elem_op< binary_op< Parent1, Parent2, Op > >
struct	is_elem_op< unary_op< Parent, Op > >
struct	is_lut
struct	is_lut< lut< ParallelAccesses, OffsetType, SlopeType > >
struct	is_mmul
struct	is_mmul< mmul< M, K, N, TypeA, TypeB, AccumTag > >
struct	is_mmul_op
struct	is_real_op
struct	is_same_vector
struct	is_same_vector< unaligned_vector_ref< T, N, Resource >, Vec >
struct	is_same_vector< vector< T, N >, vector< T, N > >
struct	is_same_vector< vector< T1, N1 >, unaligned_vector_ref< T2, N2, Resource > >
struct	is_same_vector< vector< T1, N1 >, vector_ref< T2, N2, Resource > >
struct	is_same_vector< vector_ref< T, N, Resource >, Vec >
struct	is_sparse_vector_op
struct	is_sparse_vector_op< binary_op< Parent1, Parent2, Op > >
struct	is_sparse_vector_op< unary_op< Parent, Op > >
struct	is_unary_op
struct	is_unary_op< unary_op< Parent, Op > >
struct	is_valid_elem_op
struct	is_valid_mul_op
struct	is_valid_mul_op< binary_op< Parent1, Parent2, Op >, T2 >
struct	is_valid_mul_op< T, binary_op< Parent1, Parent2, Op > >
struct	is_valid_mul_op< T, unary_op< Parent, Op > >
struct	is_valid_mul_op< unary_op< Parent, Op >, T2 >
struct	is_valid_size
struct	is_valid_size< T, T2 >
struct	is_vector_op
struct	is_vector_op< binary_op< Parent1, Parent2, Op > >
struct	is_vector_op< unary_op< Parent, Op > >
struct	linear_approx
struct	lut
	Abstraction to represent a LUT that is stored in memory, instantiated with pointer(s) to the already appropriately populated memory and the number of elements. More...
class	mask
	Type for vector element masks. More...
struct	mmul
	Type that encapsulates a blocked matrix multiplication C = A x B. More...
struct	op_result_helper
struct	op_result_helper< binary_op< Parent1, Parent2, ParentOp >, Op >
struct	op_result_helper< Parent, Operation::None >
struct	op_result_helper< unaligned_vector_ref< T, Elems, Resource >, Op >
struct	op_result_helper< unary_op< Parent, ParentOp >, Op >
struct	op_result_helper< vector_elem_const_ref< T, Elems >, Op >
struct	op_result_helper< vector_elem_ref< T, Elems >, Op >
struct	op_result_helper< vector_ref< T, Elems, Resource >, Op >
struct	op_value_type_helper
struct	op_value_type_helper< binary_op< Parent1, Parent2, Op > >
struct	op_value_type_helper< mmul< M, K, N, TypeA, TypeB, AccumTag > >
struct	op_value_type_helper< sparse_vector< T, Elems > >
struct	op_value_type_helper< unaligned_vector_ref< T, Elems, Resource > >
struct	op_value_type_helper< unary_op< Parent, Op > >
struct	op_value_type_helper< vector< T, Elems > >
struct	op_value_type_helper< vector_elem_const_ref< T, Elems > >
struct	op_value_type_helper< vector_elem_ref< T, Elems > >
struct	op_value_type_helper< vector_ref< T, Elems, Resource > >
struct	operand_base_type
struct	operand_base_type< binary_op< Parent1, Parent2, Op > >
struct	operand_base_type< unary_op< Parent, Op > >
struct	operand_base_type< vector_elem_const_ref< T, Elems > >
struct	operand_base_type< vector_elem_ref< T, Elems > >
struct	parallel_lookup
class	pattern_iterator
class	random_circular_iterator
	Implements an iterator that wraps around when it reaches the end or the beginning of the buffer and, thus, has no end. More...
class	restrict_vector_iterator
struct	result_type_helper
struct	result_type_helper< T >
struct	sliding_mul_ch_ops
struct	sliding_mul_ops
	This type provides a parametrized multiplication that implements the following compute pattern: More...
struct	sliding_mul_sym_ops
struct	sliding_mul_sym_uct_ops
class	sparse_vector
	Type for sparse vector registers. More...
class	sparse_vector_input_buffer_stream
	Implements an input stream that reads sparse vectors from a memory buffer. More...
class	tensor_descriptor
struct	tensor_dim
class	tile
struct	tile_id
	Identifies a particular tile within the AIE array. More...
struct	tlast
	Type used to wrap objects read/written from/to streams that also encapsulates TLAST information. More...
class	unaligned_vector_input_buffer_stream
	Implements an input stream that reads from a memory buffer with vector granularity. More...
class	unaligned_vector_iterator
	Implements an iterator that traverses an array using vectors instead of scalar values. More...
class	unaligned_vector_output_buffer_stream
	Implements an output stream that writes into a memory buffer with vector granularity. More...
class	unaligned_vector_ref
	Type for references to vector registers. More...
struct	unary_op
struct	unary_op< Parent, Operation::Abs >
struct	unary_op< Parent, Operation::Acc_Add >
struct	unary_op< Parent, Operation::Acc_Sub >
struct	unary_op< Parent, Operation::Conj >
struct	unary_op< Parent, Operation::None >
struct	unary_op< Parent, Operation::Transpose >
struct	unary_op_common
class	vector
	Type for vector registers. More...
class	vector_circular_iterator
	Implements a vector iterator that wraps around when it reaches the end of the buffer and, thus, has no end. More...
class	vector_elem_const_ref
	Constant reference to vector element. More...
class	vector_elem_ref
	Reference to vector element. More...
class	vector_input_buffer_stream
	Implements an input stream that reads from a memory buffer with vector granularity. More...
class	vector_iterator
	Implements an iterator that traverses an array using vectors instead of scalar values. More...
class	vector_output_buffer_stream
	Implements an output stream that writes into a memory buffer with vector granularity. More...
class	vector_random_circular_iterator
	Implements a vector iterator that wraps around when it reaches the end or the beginning of the buffer and, thus, has no end. More...
class	vector_ref
	Type for references to vector registers. More...

Concepts
concept	TLast
	Concept for tlast objects passed to << and >> operators with streams.
concept	Mmul
concept	MmulOrOp
concept	TupleLike
	Accepts any type implementing tuple interface.
concept	ParallelLUT
	Concept for parallel access LUT types.
concept	ElemBaseType
	Concept for all the basic types that can be used in operations and as vector element type.
concept	Elem
	Concept for element operands.
concept	ComplexElem
	Concept similar to aie::Elem, but it only accepts complex types.
concept	RealElem
	Concept similar to aie::Elem, but it only accepts real (i.e.
concept	ElemOrOp
	Concept that allows aie::Elem or an element operation modifier.
concept	Vector
	Concept for vector types.
concept	ComplexVector
	Similar to aie::Vector, but it only accepts vectors with complex element types.
concept	RealVector
	Similar to aie::Vector, but it only accepts vectors with real element types.
concept	VectorOrOp
	Concept that allows aie::Vector or a vector operation modifier.
concept	SparseVector
	Concept for vector types.
concept	SparseVectorOrOp
	Concept that allows aie::SparseVector or a vector operation modifier.
concept	Accum
	Concept for accumulator types.
concept	AccumOrOp
	Concept that allows aie::Accum or an accumulator operation modifier.
concept	Mask
	Concept for mask types.
concept	DecoratedElemBaseType
	Concept for the pointers to basic types that can be used in operations and as vector element type.
concept	AccumElemBaseType
	Concept for the supported accumulator element types.
concept	NativeVectorType
concept	NativeAccumType

Typedefs
using	AccumClass = detail::AccumClass
template<unsigned MinAccumBits, unsigned Elems>
using	cfp_accum = accum< detail::accum_tag_t< AccumClass::CFP, detail::to_native_accum_bits< AccumClass::CFP, MinAccumBits >()>, Elems >
template<typename T >
using	cfr = detail::cfr< T >
template<unsigned MinAccumBits, unsigned Elems>
using	cint_accum = accum< detail::accum_tag_t< AccumClass::CInt, detail::to_native_accum_bits< AccumClass::CInt, MinAccumBits >()>, Elems >
template<typename T , size_t Size = dynamic_extent, aie_dm_resource Resource = aie_dm_resource::none>
using	const_circular_iterator = circular_iterator< const T, Size, Resource >
	Same as circular_iterator, but the contents of the iterated array cannot be modified.
template<typename T , unsigned Steps>
using	const_pattern_iterator = pattern_iterator< std::add_const_t< T >, Steps >
template<typename T , size_t Size, aie_dm_resource Resource = aie_dm_resource::none>
using	const_random_circular_iterator = random_circular_iterator< const T, Size, Resource >
	Same as random_circular_iterator, but the contents of the iterated array cannot be modified.
template<typename T , unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none>
using	const_restrict_vector_iterator = restrict_vector_iterator< const std::remove_const_t< T >, Elems, Resource >
template<typename T , unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none>
using	const_unaligned_vector_iterator = unaligned_vector_iterator< const std::remove_const_t< T >, Elems, Resource >
	Same as unaligned_vector_iterator, but the contents of the iterated array cannot be modified.
template<typename T , unsigned Elems, size_t Size = dynamic_extent, aie_dm_resource Resource = aie_dm_resource::none>
using	const_vector_circular_iterator = vector_circular_iterator< const T, Elems, Size, Resource >
	Same as circular_iterator, but the contents of the iterated array cannot be modified.
template<typename T , unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none>
using	const_vector_iterator = vector_iterator< const std::remove_const_t< T >, Elems, Resource >
	Same as vector_iterator, but the contents of the iterated array cannot be modified.
template<typename T , unsigned Elems, size_t Size, aie_dm_resource Resource = aie_dm_resource::none>
using	const_vector_random_circular_iterator = vector_random_circular_iterator< const T, Elems, Size, Resource >
	Same as vector_random_circular_iterator, but the contents of the iterated array cannot be modified.
using	dim_2d = detail::dim_2d
using	dim_3d = detail::dim_3d
template<size_t... Extents>
using	extents = detail::extents< Extents... >
template<unsigned Vectorization, unsigned Radix, typename Input , typename Output = Input, typename Twiddle = detail::default_twiddle_type_t<Input, Output>>
using	fft_dit = detail::fft_dit< Vectorization, detail::fft_get_stage< Vectorization, Radix, Input, Output, Twiddle >(), Radix, Input, Output, Twiddle >
	Type that encapsulates the functionality for decimation-in-time FFTs.
template<unsigned MinAccumBits, unsigned Elems>
using	fp_accum = accum< detail::accum_tag_t< AccumClass::FP, detail::to_native_accum_bits< AccumClass::FP, MinAccumBits >()>, Elems >
template<unsigned MinAccumBits, unsigned Elems>
using	int_accum = accum< detail::accum_tag_t< AccumClass::Int, detail::to_native_accum_bits< AccumClass::Int, MinAccumBits >()>, Elems >
template<typename T , size_t... Extents>
using	mdspan = detail::basic_mdspan< T, extents< Extents... >, void, detail::accessor_basic< T > >
template<typename T , Operation Op>
using	op_result_type_t = typename op_result_helper< T, Op >::type
template<typename T >
using	op_value_type_t = typename op_value_type_helper< aie_dm_resource_remove_t< T > >::type
template<typename T >
using	operand_base_type_t = typename operand_base_type< Utils::remove_all_t< T > >::type
template<typename T , size_t... Extents>
using	restrict_mdspan = detail::basic_mdspan< T, extents< Extents... >, void, detail::accessor_restrict< T > >
template<typename T , size_t Extents1 = dynamic_extent>
using	restrict_span = restrict_span_1d< T, Extents1 >
template<typename T , size_t Extents1 = dynamic_extent>
using	restrict_span_1d = restrict_mdspan< T, Extents1 >
template<typename T , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent>
using	restrict_span_2d = restrict_mdspan< T, Extents1, Extents2 >
template<typename T , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent>
using	restrict_span_3d = restrict_mdspan< T, Extents1, Extents2, Extents3 >
template<typename T , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent, size_t Extents4 = dynamic_extent>
using	restrict_span_4d = restrict_mdspan< T, Extents1, Extents2, Extents3, Extents4 >
template<typename T , typename TileExtents , size_t... Extents>
using	restrict_tiled_mdspan = detail::basic_tiled_mdspan< T, TileExtents, extents< Extents... >, void, detail::accessor_restrict< T > >
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent>
using	restrict_tiled_span = tiled_span_1d< T, TileExtents, Extents1 >
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent>
using	restrict_tiled_span_1d = tiled_mdspan< T, TileExtents, Extents1 >
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent>
using	restrict_tiled_span_2d = tiled_mdspan< T, TileExtents, Extents1, Extents2 >
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent>
using	restrict_tiled_span_3d = tiled_mdspan< T, TileExtents, Extents1, Extents2, Extents3 >
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent, size_t Extents4 = dynamic_extent>
using	restrict_tiled_span_4d = tiled_mdspan< T, TileExtents, Extents1, Extents2, Extents3, Extents4 >
template<typename T >
using	result_type_t = typename result_type_helper< T >::type
template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using	sliding_mul_ch_x_ops = sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, 1, CoeffType, DataType, AccumTag >
template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using	sliding_mul_ch_xy_ops = sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStep, DataStep, CoeffType, DataType, AccumTag >
template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using	sliding_mul_ch_y_ops = sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, 1, DataStepY, CoeffType, DataType, AccumTag >
template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using	sliding_mul_sym_x_ops = sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, 1, CoeffType, DataType, AccumTag >
template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepXY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using	sliding_mul_sym_xy_ops = sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepXY, DataStepXY, CoeffType, DataType, AccumTag >
template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using	sliding_mul_sym_y_ops = sliding_mul_sym_ops< Lanes, Points, CoeffStep, 1, DataStepY, CoeffType, DataType, AccumTag >
template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using	sliding_mul_x_ops = sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, 1, CoeffType, DataType, AccumTag >
	Similar to sliding_mul_ops, but DataStepY is always 1.
template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepXY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using	sliding_mul_xy_ops = sliding_mul_ops< Lanes, Points, CoeffStep, DataStepXY, DataStepXY, CoeffType, DataType, AccumTag >
	Similar to sliding_mul_ops, but DataStepX is equal to DataStepY.
template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using	sliding_mul_y_ops = sliding_mul_ops< Lanes, Points, CoeffStep, 1, DataStepY, CoeffType, DataType, AccumTag >
	Similar to sliding_mul_ops, but DataStepX is always 1.
using	sliding_window_dim_1d = detail::sliding_window_dim_1d
using	sliding_window_dim_2d = detail::sliding_window_dim_2d
using	sliding_window_dim_3d = detail::sliding_window_dim_3d
template<typename T , size_t Extents1 = dynamic_extent>
using	span = span_1d< T, Extents1 >
template<typename T , size_t Extents1 = dynamic_extent>
using	span_1d = mdspan< T, Extents1 >
template<typename T , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent>
using	span_2d = mdspan< T, Extents1, Extents2 >
template<typename T , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent>
using	span_3d = mdspan< T, Extents1, Extents2, Extents3 >
template<typename T , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent, size_t Extents4 = dynamic_extent>
using	span_4d = mdspan< T, Extents1, Extents2, Extents3, Extents4 >
template<typename T , typename TileExtents , size_t... Extents>
using	tiled_mdspan = detail::basic_tiled_mdspan< T, TileExtents, extents< Extents... >, void, detail::accessor_basic< T > >
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent>
using	tiled_span = tiled_span_1d< T, TileExtents, Extents1 >
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent>
using	tiled_span_1d = tiled_mdspan< T, TileExtents, Extents1 >
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent>
using	tiled_span_2d = tiled_mdspan< T, TileExtents, Extents1, Extents2 >
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent>
using	tiled_span_3d = tiled_mdspan< T, TileExtents, Extents1, Extents2, Extents3 >
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent, size_t Extents4 = dynamic_extent>
using	tiled_span_4d = tiled_mdspan< T, TileExtents, Extents1, Extents2, Extents3, Extents4 >

Enumerations
enum class	Operation {   None , Acc_Add , Acc_Sub , Abs ,   Conj , Transpose , Max , Min ,   Sign , Zero }
enum class	rounding_mode : unsigned {   floor = rnd_floor , ceil = rnd_ceil , positive_inf = rnd_pos_inf , negative_inf = rnd_neg_inf ,   symmetric_inf = rnd_sym_inf , symmetric_zero = rnd_sym_zero , conv_even = rnd_conv_even , conv_odd = rnd_conv_odd ,   symmetric_floor = rnd_sym_floor , symmetric_ceil = rnd_sym_ceil }
enum class	saturation_mode : unsigned { none = 0 , truncate = 1 , saturate = 1 , symmetric = 3 }

Functions
static bfloat16	abs (bfloat16 a)
template<Elem E>
constexpr auto	abs (const E &a) -> operand_base_type_t< E >
	Compute the absolute value of a value.
static int4_t	abs (const int4_t &a)
static uint4_t	abs (const uint4_t &a)
template<Vector Vec>
constexpr auto	abs (const Vec &v) -> aie_dm_resource_remove_t< Vec >
	Compute the absolute value for each element in the given vector.
template<ComplexElem E>
constexpr auto	abs_square (const E &v) -> detail::utils::get_complex_component_type_t< operand_base_type_t< E > >
	Compute the absolute square of a scalar complex value.
template<typename TR = int32, ComplexVector Vec> requires (Utils::is_one_of_v<TR, int32, int16>)
constexpr auto	abs_square (const Vec &v, int shift=0)
	Compute the absolute square of each element in the given complex vector.
template<unsigned Elems> requires (arch::is(arch::AIE) || (arch::is(arch::AIE_ML) && __AIE_API_COMPLEX_FP32_EMULATION__ == 1))
constexpr vector< float, Elems >	abs_square (const vector< cfloat, Elems > &v)
	Compute the absolute square of each element in the given complex vector.
template<detail::NativeAccumType T>
	accum (T) -> accum< typename detail::native_accum_traits< T >::value_type, detail::native_accum_traits< T >::size >
	Template deduction guidelines for aie::accum.
template<unsigned Lanes, AccumOrOp Acc, Vector VecCoeff, Vector VecData, size_t N> requires ((N >= 1) && Acc::size() == Lanes && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	accumulate (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const std::array< VecData, N > &data) -> operand_base_type_t< Acc >
	Performs a weighted addition over multiple vectors and accumulates the result into an existing accumulator.
template<unsigned Lanes, AccumOrOp Acc, Vector VecCoeff, Vector VecData, Vector... NextVecData> requires ((is_same_vector_v<VecData, NextVecData> && ...) && Acc::size() == Lanes && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	accumulate (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, const NextVecData &...next_data) -> operand_base_type_t< Acc >
	Performs a weighted addition over multiple vectors and accumulates the result into an existing accumulator.
template<unsigned Lanes, unsigned CoeffStart = 0, AccumElemBaseType AccumTag = accauto, Vector VecCoeff, Vector VecData, Vector... NextVecData>
auto	accumulate (const VecCoeff &coeff, const VecData &data, const NextVecData &...next_data)
template<unsigned Lanes, AccumElemBaseType AccumTag = accauto, Vector VecCoeff, Vector VecData, size_t N> requires (N >= 1)
auto	accumulate (const VecCoeff &coeff, unsigned coeff_start, const std::array< VecData, N > &data) -> accum< detail::accum_tag_or_default_t< AccumTag, typename VecCoeff::value_type, typename VecData::value_type >, Lanes >
	Performs a weighted addition over multiple vectors.
template<unsigned Lanes, AccumElemBaseType AccumTag = accauto, Vector VecCoeff, Vector VecData, Vector... NextVecData> requires ((is_same_vector_v<VecData, NextVecData> && ...))
auto	accumulate (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, const NextVecData &...next_data) -> accum< detail::accum_tag_or_default_t< AccumTag, typename VecCoeff::value_type, typename VecData::value_type >, Lanes >
	Performs a weighted addition over multiple vectors.
template<AccumOrOp Acc, Vector Vec> requires (Acc::size() == Vec::size())
auto	add (const Acc &acc, const Vec &v) -> result_type_t< Acc >
	Returns an accumulator with the element-wise addition of the input accumulator and vector.
template<AccumOrOp Acc, Elem E>
auto	add (const Acc &acc, E a) -> result_type_t< Acc >
	Returns an accumulator with the addition of a value to all the elements of the input vector.
template<AccumOrOp Acc1, AccumOrOp Acc2> requires (arch::is(arch::AIE_ML) && is_same_accum_v<result_type_t<Acc1>, result_type_t<Acc2>>)
auto	add (const Acc1 &acc1, const Acc2 &acc2) -> result_type_t< Acc1 >
	Returns an accumulator with the element-wise addition of the two input accumulators.
template<Vector Vec, Elem E> requires (is_valid_elem_op_v<typename Vec::value_type, E>)
auto	add (const Vec &v, E a) -> aie_dm_resource_remove_t< Vec >
	Returns a vector with the addition of a value to all the elements of the input vector.
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
auto	add (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
	Returns a vector with the element-wise addition of the two input vectors.
template<Elem E, Vector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
auto	add (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
	Returns a vector with the addition of a value to all the elements of the input vector.
template<typename T > requires (detail::is_floating_point_v<T>)
T	add (T a, T b)
template<Vector Vec>
Vec::value_type	add_reduce (const Vec &v)
template<Vector Vec, Vector... Others>
auto	add_reduce_v (const Vec &v, const Others &... others) -> aie_dm_resource_remove_t< Vec >
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	begin (adf::io_buffer< T, Dir, Config > &port)
	Returns a foward iterator over given io buffer.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	begin (const adf::io_buffer< T, Dir, Config > &port)
	Returns a foward const iterator over given io buffer.
template<aie_dm_resource Resource, typename T >
constexpr auto	begin (T *base, size_t n)
	Returns an iterator for the array described by the given address and size.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , unsigned Elems>
constexpr auto	begin (T(&base)[Elems])
	Returns an iterator for the given statically-sized array.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	begin_circular (adf::io_buffer< T, Dir, Config > &port)
	Returns a foward circular iterator over given io buffer.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	begin_circular (const adf::io_buffer< T, Dir, Config > &port)
	Returns a const foward circular iterator over given io buffer.
template<size_t Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T >
constexpr circular_iterator< T, Elems, Resource >	begin_circular (T *base)
	Returns a circular iterator for the array described by the given address and size.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T >
constexpr circular_iterator< T, dynamic_extent, Resource >	begin_circular (T *base, size_t n)
	Returns a circular iterator for the array described by the given address and size.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , size_t Elems>
constexpr circular_iterator< T, Elems, Resource >	begin_circular (T(&base)[Elems])
	Returns a circular iterator for the given statically-sized array.
template<unsigned Steps, typename T , typename... Offsets>
constexpr auto	begin_pattern (T *base, Offsets &&... offsets)
	Returns a forward iterator for the array described by the given address.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	begin_random_circular (adf::io_buffer< T, Dir, Config > &port)
	Returns a random iterator over given io buffer.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	begin_random_circular (const adf::io_buffer< T, Dir, Config > &port)
	Returns a random const iterator over given io buffer.
template<size_t Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T >
constexpr random_circular_iterator< T, Elems, Resource >	begin_random_circular (T *base)
	Returns a random-access circular iterator for the array described by the given address and size.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T >
constexpr random_circular_iterator< T, dynamic_extent, Resource >	begin_random_circular (T *base, size_t n)
	Returns a random-access circular iterator for the array described by the given address and size.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , size_t Elems>
constexpr random_circular_iterator< T, Elems, Resource >	begin_random_circular (T(&base)[Elems])
	Returns a random-access circular iterator for the array described by the given address and size.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	begin_restrict_vector (adf::io_buffer< T, Dir, Config > &port)
	Returns a restrict vector iterator over given io buffer.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	begin_restrict_vector (const adf::io_buffer< T, Dir, Config > &port)
	Returns a const restrict vector iterator over given io buffer.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>
constexpr const_restrict_vector_iterator< T, Elems, Resource >	begin_restrict_vector (const T *base)
	Same as begin_vector, but the given pointer is considered restrict.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>
constexpr restrict_vector_iterator< T, Elems, Resource >	begin_restrict_vector (T *base)
	Same as begin_vector, but the given pointer is considered restrict.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>
constexpr unaligned_vector_iterator< T, Elems, Resource >	begin_unaligned_vector (T *base)
	Returns a vector iterator starting at the given address.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	begin_vector (adf::io_buffer< T, Dir, Config > &port)
	Returns a vector iterator over given io buffer.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	begin_vector (const adf::io_buffer< T, Dir, Config > &port)
	Returns a const vector iterator over given io buffer.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>
constexpr const_vector_iterator< T, Elems, Resource >	begin_vector (const T *base)
	Returns a vector iterator starting at the given address.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>
constexpr vector_iterator< T, Elems, Resource >	begin_vector (T *base)
	Returns a vector iterator starting at the given address.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	begin_vector_circular (adf::io_buffer< T, Dir, Config > &port)
	Returns a vector circular iterator over given io buffer.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	begin_vector_circular (const adf::io_buffer< T, Dir, Config > &port)
	Returns a const vector circular iterator over given io buffer.
template<unsigned Elems, size_t ArrayElems, aie_dm_resource Resource = aie_dm_resource::none, typename T >
constexpr vector_circular_iterator< T, Elems, ArrayElems, Resource >	begin_vector_circular (T *base)
	Returns a circular iterator for the array described by the given address and size.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T >
constexpr vector_circular_iterator< T, Elems, dynamic_extent, Resource >	begin_vector_circular (T *base, size_t n)
	Returns a circular iterator for the array described by the given address and size.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T , size_t ArrayElems>
constexpr vector_circular_iterator< T, Elems, ArrayElems, Resource >	begin_vector_circular (T(&base)[ArrayElems])
	Returns a circular iterator for the array described by the given address and size.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	begin_vector_random_circular (adf::io_buffer< T, Dir, Config > &port)
	Returns a vector random circular iterator over given io buffer.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	begin_vector_random_circular (const adf::io_buffer< T, Dir, Config > &port)
	Returns a const vector random circular iterator over given io buffer.
template<unsigned Elems, size_t ArrayElems, aie_dm_resource Resource = aie_dm_resource::none, typename T >
constexpr vector_random_circular_iterator< T, Elems, ArrayElems, Resource >	begin_vector_random_circular (T *base)
	Returns a circular iterator for the array described by the given address and size.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T >
constexpr vector_random_circular_iterator< T, Elems, dynamic_extent, Resource >	begin_vector_random_circular (T *base, size_t n)
	Returns a circular iterator for the array described by the given address and size.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T , size_t ArrayElems>
constexpr vector_random_circular_iterator< T, Elems, ArrayElems, Resource >	begin_vector_random_circular (T(&base)[ArrayElems])
	Returns a circular iterator for the array described by the given address and size.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType... Types>
constexpr auto	begin_vectors (Types *...ptrs)
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2> && (!detail::is_complex_v<typename Vec1::value_type>) && (!detail::is_floating_point_v<typename Vec1::value_type>))
auto	bit_and (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
	Returns a vector with the bit-wise AND of the elements of the two input vectors.
template<Elem E, Vector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type> && (!detail::is_complex_v<typename Vec::value_type>) && (!detail::is_floating_point_v<typename Vec::value_type>))
auto	bit_and (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
	Returns a vector with the bit-wise AND of a value and all the elements of the input vector.
template<Vector Vec> requires ((!detail::is_complex_v<typename Vec::value_type>) && (!detail::is_floating_point_v<typename Vec::value_type>))
auto	bit_not (const Vec &v) -> aie_dm_resource_remove_t< Vec >
	Returns a vector with the bit-wise NEG of the elements of the input vector.
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2> && (!detail::is_complex_v<typename Vec1::value_type>) && (!detail::is_floating_point_v<typename Vec1::value_type>))
auto	bit_or (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
	Returns a vector with the bit-wise OR of the elements of the two input vectors.
template<Elem E, Vector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type> && (!detail::is_complex_v<typename Vec::value_type>) && (!detail::is_floating_point_v<typename Vec::value_type>))
auto	bit_or (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
	Returns a vector with the bit-wise OR of a value and all the elements of the input vector.
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2> && (!detail::is_complex_v<typename Vec1::value_type>) && (!detail::is_floating_point_v<typename Vec1::value_type>))
auto	bit_xor (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
	Returns a vector with the bit-wise XOR of the elements of the two input vectors.
template<Elem E, Vector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type> && (!detail::is_complex_v<typename Vec::value_type>) && (!detail::is_floating_point_v<typename Vec::value_type>))
auto	bit_xor (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
	Returns a vector with the bit-wise XOR of a value and all the elements of the input vector.
template<Elem E, unsigned Elems = native_vector_length_v<E>>
vector< operand_base_type_t< E >, Elems >	broadcast (E a)
	Returns a vector whose elements are initialized to the given value.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	cbegin (const adf::io_buffer< T, Dir, Config > &port)
	Returns a foward const iterator over given io buffer.
template<aie_dm_resource Resource, typename T >
constexpr auto	cbegin (const T *base, size_t n)
	Returns an iterator for the constant array described by the given address and size.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	cbegin_circular (const adf::io_buffer< T, Dir, Config > &port)
	Returns a const foward iterator over given io buffer.
template<size_t Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T >
constexpr const_circular_iterator< T, Elems, Resource >	cbegin_circular (const T *base)
	Similar to begin_circular, but the returned iterator is constant.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T >
constexpr const_circular_iterator< T, dynamic_extent, Resource >	cbegin_circular (const T *base, size_t n)
	Similar to begin_circular, but the returned iterator is constant.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , size_t Elems>
constexpr const_circular_iterator< T, Elems, Resource >	cbegin_circular (const T(&base)[Elems])
	Similar to begin_circular, but the returned iterator is constant.
template<unsigned Steps, typename T , typename... Offsets>
constexpr const_pattern_iterator< T, Steps >	cbegin_pattern (const T *base, Offsets &&... offsets)
	Similar to begin_pattern, but the returned iterator is constant.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	cbegin_random_circular (const adf::io_buffer< T, Dir, Config > &port)
	Returns a random const iterator over given io buffer.
template<size_t Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T >
constexpr const_random_circular_iterator< T, Elems, Resource >	cbegin_random_circular (const T *base)
	Similar to begin_random_circular, but the returned iterator is constant.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T >
constexpr const_random_circular_iterator< T, dynamic_extent, Resource >	cbegin_random_circular (const T *base, size_t n)
	Similar to begin_random_circular, but the returned iterator is constant.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , size_t Elems>
constexpr const_random_circular_iterator< T, Elems >	cbegin_random_circular (const T(&base)[Elems])
	Similar to begin_random_circular, but the returned iterator is constant.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	cbegin_restrict_vector (const adf::io_buffer< T, Dir, Config > &port)
	Returns a const restrict vector iterator over given io buffer.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>
constexpr const_restrict_vector_iterator< T, Elems, Resource >	cbegin_restrict_vector (const T *base)
	Same as begin_vector, but the given pointer is considered restrict.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>
constexpr const_unaligned_vector_iterator< T, Elems, Resource >	cbegin_unaligned_vector (T *base)
	Returns a vector iterator starting at the given address.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	cbegin_vector (const adf::io_buffer< T, Dir, Config > &port)
	Returns a const vector iterator over given io buffer.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>
constexpr const_vector_iterator< T, Elems, Resource >	cbegin_vector (const T *base)
	Same as begin_vector.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	cbegin_vector_circular (const adf::io_buffer< T, Dir, Config > &port)
	Returns a const vector circular iterator over given io buffer.
template<unsigned Elems, size_t ArrayElems, aie_dm_resource Resource = aie_dm_resource::none, typename T >
constexpr const_vector_circular_iterator< T, Elems, ArrayElems, Resource >	cbegin_vector_circular (const T *base)
	Similar to begin_circular, but the returned iterator is constant.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T >
constexpr const_vector_circular_iterator< T, Elems, dynamic_extent, Resource >	cbegin_vector_circular (const T *base, size_t n)
	Similar to begin_circular, but the returned iterator is constant.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T , size_t ArrayElems>
constexpr const_vector_circular_iterator< T, Elems, ArrayElems, Resource >	cbegin_vector_circular (const T(&base)[ArrayElems])
	Similar to begin_circular, but the returned iterator is constant.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T , typename Dir , typename Config >
constexpr auto	cbegin_vector_random_circular (const adf::io_buffer< T, Dir, Config > &port)
	Returns a const vector random circular iterator over given io buffer.
template<unsigned Elems, size_t ArrayElems, aie_dm_resource Resource = aie_dm_resource::none, typename T >
constexpr const_vector_random_circular_iterator< T, Elems, ArrayElems, Resource >	cbegin_vector_random_circular (const T *base)
	Similar to begin_circular, but the returned iterator is constant.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T >
constexpr const_vector_random_circular_iterator< T, Elems, dynamic_extent, Resource >	cbegin_vector_random_circular (const T *base, size_t n)
	Similar to begin_circular, but the returned iterator is constant.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T , size_t ArrayElems>
constexpr const_vector_random_circular_iterator< T, Elems, ArrayElems, Resource >	cbegin_vector_random_circular (const T(&base)[ArrayElems])
	Similar to begin_circular, but the returned iterator is constant.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType... Types>
constexpr auto	cbegin_vectors (const Types *...ptrs)
template<aie_dm_resource Resource = aie_dm_resource::none, typename T >
constexpr auto	cend (const T *base, size_t n)
	Returns an iterator that points at the end of the constant array described by the given address and size.
template<RealVector Vec, RealVector VecL, RealVector VecH> requires (is_same_vector_v<Vec, VecL> && is_same_vector_v<Vec, VecH>)
auto	clamp (const Vec &v, const VecL &lo, const VecH &hi) -> aie_dm_resource_remove_t< Vec >
	Returns a vector whose elements are within specified lower and upper limits.
template<RealVector Vec, RealElem E1, RealElem E2> requires (is_valid_elem_op_v<E1, typename Vec::value_type> && is_valid_elem_op_v<E2, typename Vec::value_type>)
auto	clamp (const Vec &v, E1 lo, E2 hi) -> aie_dm_resource_remove_t< Vec >
	Returns a vector whose elements are within specified lower and upper limits.
template<Accum Acc, Accum... Accums> requires ((is_same_accum_v<Acc, Accums> && ...))
auto	concat (const Acc &acc, const Accums &...accums) -> accum< typename Acc::value_type, Acc::size() *(1+sizeof...(Accums))>
	Concatenate the contents of all input accumulators into a larger accumulator.
template<TupleLike T> requires (std::tuple_size_v<T> > 1)
auto	concat (const T &t)
	Concatenate the contents of all input vectors/accumulators wrapped in a aie::TupleLike object.
template<Vector Vec, Vector... Vectors> requires ((is_same_vector_v<Vec, Vectors> && ...))
auto	concat (const Vec &v, const Vectors &...vectors) -> vector< typename Vec::value_type, Vec::size() *(1+sizeof...(Vectors))>
	Concatenate the contents of all input vectors into a larger vector.
template<ComplexElem E>
constexpr auto	conj (const E &a) -> operand_base_type_t< E >
	Compute the conjugate in the given complex value.
template<ComplexVector Vec>
auto	conj (const Vec &v) -> aie_dm_resource_remove_t< Vec >
	Compute the conjugate for each element in the given vector of complex elements.
template<Elem E, Vector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
bool	contains (E a, const Vec &v)
template<RealVector Vec> requires (arch::is(arch::AIE))
auto	cos (const Vec &v) -> aie_dm_resource_remove_t< Vec >
	Performs a cosine operation on all elements in the input vector.
template<typename E > requires (arch::is(arch::AIE) && (RealElem<E> || std::is_integral_v<E>))
auto	cos (E a)
	Performs a cosine operation on a single value.
template<ComplexVector Vec, ComplexElem E> requires (arch::is(arch::AIE) || (arch::is(arch::AIE_ML) && __AIE_API_COMPLEX_FP32_EMULATION__ == 1))
auto	div (const Vec &a, const E &b) -> accum< detail::accum_tag_for_mul_types< typename Vec::value_type, detail::utils::get_complex_component_type_t< E > >, Vec::size()>
	Returns the quotients of the element-wise division of a complex vector 'a' by a complex scalar 'b'.
template<ComplexVector Vec> requires (arch::is(arch::AIE) || (arch::is(arch::AIE_ML) && __AIE_API_COMPLEX_FP32_EMULATION__ == 1))
auto	div (const Vec &a, const Vec &b) -> accum< detail::accum_tag_for_mul_types< typename Vec::value_type, detail::utils::get_complex_component_type_t< typename Vec::value_type > >, Vec::size()>
	Returns the quotients of the element-wise division of two complex vectors 'a' and 'b'.
template<Vector Vec, RealElem E> requires ( detail::is_floating_point_v<typename Vec::value_type> && detail::is_valid_element_type_v<E> && detail::is_floating_point_v<E>)
auto	div (const Vec &a, E b) -> accum< detail::accum_tag_for_mul_types< typename Vec::value_type, E >, Vec::size()>
	Returns the quotients of the element-wise division of each value of the first input vector by a scalar.
template<Vector Vec1, RealVector Vec2> requires (Vec1::size() == Vec2::size() && detail::is_floating_point_v<typename Vec2::value_type>)
auto	div (const Vec1 &a, const Vec2 &b) -> accum< detail::accum_tag_for_mul_types< typename Vec1::value_type, typename Vec2::value_type >, Vec1::size()>
	Returns the quotients of the element-wise division of each value of the first input vector by the corresponding element in the second input vector.
float	div (float a, float b)
template<Vector Vec>
constexpr auto	downshift (const Vec &v, unsigned shift) -> aie_dm_resource_remove_t< Vec >
	Returns a vector with all values arithmetically downshifted by specified number of bits.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T >
constexpr auto	end (T *base, size_t n)
	Returns an iterator that points at the end of the array described by the given address and size.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , unsigned Elems>
constexpr auto	end (T(&base)[Elems])
	Returns an iterator that points at the end of the given statically-sized array.
template<Vector Vec, Elem E> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	eq (const Vec &v, E a)
	Compares a value with the elements of the input vector and returns a mask that says what elements in the vector are equal to the value.
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
mask< Vec1::size()>	eq (const Vec1 &v1, const Vec2 &v2)
	Compares the elements of the two input vectors and returns a mask that says what elements are equal.
template<Elem E, Vector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	eq (E a, const Vec &v)
	Compares a value with the elements of the input vector and returns a mask that says what elements in the vector are equal to the value.
template<typename T > requires (detail::is_floating_point_v<T>)
bool	eq (T a, T b)
	Compares the two input values and returns whether they are equal.
template<Vector Vec, Elem E> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
constexpr bool	equal (const Vec &v, E a)
	Return whether all the elements of the input vector are equal to the scalar.
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
constexpr bool	equal (const Vec1 &v1, const Vec2 &v2)
	Return whether all the elements of the two input vectors are equal.
template<Elem E, Vector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
constexpr bool	equal (E a, const Vec &v)
	Return whether all the elements of the input vector are equal to the scalar.
template<unsigned Vectorization, typename Input , typename Output , typename Twiddle > requires (arch::is(arch::AIE) && detail::is_floating_point_v<Input>)
void	fft_dit_r2_stage (const Input *__restrict x, const Twiddle *__restrict tw, unsigned n, bool inv, Output *__restrict out)
	A function to perform a single floating point radix 2 FFT stage.
template<unsigned Vectorization, typename Input , typename Output , typename Twiddle > requires (arch::is(arch::AIE, arch::AIE_ML))
void	fft_dit_r2_stage (const Input *__restrict x, const Twiddle *__restrict tw, unsigned n, unsigned shift_tw, unsigned shift, bool inv, Output *__restrict out)
	A function to perform a single radix 2 FFT stage.
template<unsigned Vectorization, typename Input , typename Output , typename Twiddle > requires (arch::is(arch::AIE) && detail::is_floating_point_v<Input>)
void	fft_dit_r3_stage (const Input *__restrict x, const Twiddle *__restrict tw0, const Twiddle *__restrict tw1, unsigned n, bool inv, Output *__restrict out)
	A function to perform a single floating point radix 3 FFT stage.
template<unsigned Vectorization, typename Input , typename Output , typename Twiddle > requires (arch::is(arch::AIE, arch::AIE_ML))
void	fft_dit_r3_stage (const Input *__restrict x, const Twiddle *__restrict tw0, const Twiddle *__restrict tw1, unsigned n, unsigned shift_tw, unsigned shift, bool inv, Output *__restrict out)
	A function to perform a single radix 3 FFT stage.
template<unsigned Vectorization, typename Input , typename Output , typename Twiddle > requires (arch::is(arch::AIE, arch::AIE_ML))
void	fft_dit_r4_stage (const Input *__restrict x, const Twiddle *__restrict tw0, const Twiddle *__restrict tw1, const Twiddle *__restrict tw2, unsigned n, unsigned shift_tw, unsigned shift, bool inv, Output *__restrict out)
	A function to perform a single radix 4 FFT stage.
template<unsigned Vectorization, typename Input , typename Output , typename Twiddle > requires (arch::is(arch::AIE) && detail::is_floating_point_v<Input>)
void	fft_dit_r5_stage (const Input *__restrict x, const Twiddle *__restrict tw0, const Twiddle *__restrict tw1, const Twiddle *__restrict tw2, const Twiddle *__restrict tw3, unsigned n, bool inv, Output *__restrict out)
	A function to perform a single floating point radix 5 FFT stage.
template<unsigned Vectorization, typename Input , typename Output , typename Twiddle > requires (arch::is(arch::AIE, arch::AIE_ML))
void	fft_dit_r5_stage (const Input *__restrict x, const Twiddle *__restrict tw0, const Twiddle *__restrict tw1, const Twiddle *__restrict tw2, const Twiddle *__restrict tw3, unsigned n, unsigned shift_tw, unsigned shift, bool inv, Output *out)
	A function to perform a single radix 5 FFT stage.
template<Vector Vec, ElemBaseType T, unsigned Elems> requires (std::is_same_v<typename Vec::value_type, T> && Vec::size() == Elems)
auto	filter (const Vec &v, filter_mode< T, Elems > mode) -> vector< T, Elems/2 >
	Returns a vector of half the size.
template<Vector Vec>
auto	filter_even (const Vec &v, unsigned chunk_size=1) -> vector< typename Vec::value_type, Vec::size()/2 >
	Returns a vector of half the size whose contents follow the following pattern.
template<Vector Vec>
auto	filter_odd (const Vec &v, unsigned chunk_size=1) -> vector< typename Vec::value_type, Vec::size()/2 >
	Returns a vector of half the size whose contents follow the following pattern.
template<AccumElemBaseType AccumTag, VectorOrOp Vec>
accum< AccumTag, Vec::size()>	from_vector (const Vec &v, int shift=0)
	Returns the values of the passed vector in an accumulator of the requested type after applying the requested upshift operation.
template<RealVector Vec, RealElem E> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	ge (const Vec &v, E a)
	Compares the elements of the input vector with a value and returns a mask that says if the elements in the vector are greater or equal than the value.
template<RealVector Vec1, RealVector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
mask< Vec1::size()>	ge (const Vec1 &v1, const Vec2 &v2)
	Compares the elements of the two input vectors and returns a mask that says what elements from the first vector are greater or equal than the corresponding elements in the second vector.
template<RealElem E, RealVector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	ge (E a, const Vec &v)
	Compares a value with the elements of the input vector and returns a mask that says if the value is greater or equal than the elements in the vector.
template<typename T > requires (detail::is_floating_point_v<T> && !detail::is_complex_v<T>)
bool	ge (T a, T b)
	Compares the two input values and returns whether the first value is larger or equal than the second value.
static rounding_mode	get_rounding ()
	Get the current rounding mode used in accumulator to vector conversions.
static saturation_mode	get_saturation ()
	Get the current saturation mode.
template<RealVector Vec, RealElem E> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	gt (const Vec &v, E a)
	Compares the elements of the input vector with a value and returns a mask that says if the elements in the vector are greater than the value.
template<RealVector Vec1, RealVector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
mask< Vec1::size()>	gt (const Vec1 &v1, const Vec2 &v2)
	Compares the elements of the two input vectors and returns a mask that says what elements from the first vector are greater than the corresponding elements in the second vector.
template<RealElem E, RealVector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	gt (E a, const Vec &v)
	Compares a value with the elements of the input vector and returns a mask that says if the value is greater than the elements in the vector.
template<typename T > requires (detail::is_floating_point_v<T> && !detail::is_complex_v<T>)
bool	gt (T a, T b)
	Compares the two input values and returns whether the first value is larger than the second value.
template<ComplexVector Vec>
auto	imag (const Vec &v) -> vector< detail::utils::get_complex_component_type_t< typename Vec::value_type >, Vec::size()>
	Gather and return the imaginary components of a complex vector.
template<ComplexElem Elem>
auto	imag (Elem e) -> detail::utils::get_complex_component_type_t< operand_base_type_t< Elem > >
	Return the imaginary component of a complex value.
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
auto	interleave_butterfly (const Vec1 &v1, const Vec2 &v2, unsigned chunk_size) -> std::pair< aie_dm_resource_remove_t< Vec1 >, aie_dm_resource_remove_t< Vec1 > >
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
auto	interleave_butterfly_half (const Vec1 &v1, const Vec2 &v2, unsigned chunk_size) -> std::pair< aie_dm_resource_remove_t< Vec1 >, aie_dm_resource_remove_t< Vec1 > >
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
auto	interleave_crossover (const Vec1 &v1, const Vec2 &v2, unsigned chunk_size) -> std::pair< aie_dm_resource_remove_t< Vec1 >, aie_dm_resource_remove_t< Vec1 > >
template<Vector Vec1, Vector Vec2, typename... Select> requires (is_same_vector_v<Vec1, Vec2> && sizeof...(Select) == Vec1::size())
auto	interleave_custom (const Vec1 &v1, const Vec2 &v2, Select... select) -> std::pair< aie_dm_resource_remove_t< Vec1 >, aie_dm_resource_remove_t< Vec1 > >
template<unsigned S0, unsigned S1, unsigned S2, unsigned S3, unsigned S4, unsigned S5, unsigned S6, unsigned S7, unsigned S8, unsigned S9, unsigned S10, unsigned S11, unsigned S12, unsigned S13, unsigned S14, unsigned S15, unsigned S16, unsigned S17, unsigned S18, unsigned S19, unsigned S20, unsigned S21, unsigned S22, unsigned S23, unsigned S24, unsigned S25, unsigned S26, unsigned S27, unsigned S28, unsigned S29, unsigned S30, unsigned S31, Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
auto	interleave_custom_static (const Vec1 &v1, const Vec2 &v2) -> std::pair< aie_dm_resource_remove_t< Vec1 >, aie_dm_resource_remove_t< Vec1 > >
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
auto	interleave_unzip (const Vec1 &v, const Vec2 &w, unsigned chunk_size) -> std::pair< aie_dm_resource_remove_t< Vec1 >, aie_dm_resource_remove_t< Vec1 > >
	Picks elements sequentially from the input vectors and writes them alternatively into the output vectors.
template<Vector Vec1, Vector Vec2, ElemBaseType T, unsigned Elems> requires (arch::is(arch::AIE_ML) && is_same_vector_v<Vec1, Vec2> && std::is_same_v<typename Vec1::value_type, T> && Vec1::size() == Elems)
auto	interleave_unzip (const Vec1 &v1, const Vec2 &v2, const interleave_unzip_mode< T, Elems > &mode) -> std::pair< aie_dm_resource_remove_t< Vec1 >, aie_dm_resource_remove_t< Vec1 > >
	Picks elements sequentially from the input vectors and writes them alternatively into the output vectors.
template<Vector Vec1, Vector Vec2, ElemBaseType T, unsigned Elems> requires (arch::is(arch::AIE_ML) && is_same_vector_v<Vec1, Vec2> && std::is_same_v<typename Vec1::value_type, T> && Vec1::size() == Elems)
auto	interleave_zip (const Vec1 &v, const Vec2 &w, const interleave_zip_mode< T, Elems > &mode) -> std::pair< aie_dm_resource_remove_t< Vec1 >, aie_dm_resource_remove_t< Vec1 > >
	Picks elements alternatively from the input vectors and writes them sequentially into the output vectors.
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
auto	interleave_zip (const Vec1 &v, const Vec2 &w, unsigned chunk_size) -> std::pair< aie_dm_resource_remove_t< Vec1 >, aie_dm_resource_remove_t< Vec1 > >
	Picks elements alternatively from the input vectors and writes them sequentially into the output vectors.
template<unsigned Elems> requires (arch::is(arch::AIE))
accum< accfloat, Elems >	inv (const accum< accfloat, Elems > &v)
template<Vector Vec>
auto	inv (const Vec &v) -> aie_dm_resource_remove_t< Vec >
template<RealElem E>
auto	inv (E a)
template<unsigned Elems> requires (arch::is(arch::AIE))
accum< accfloat, Elems >	invsqrt (const accum< accfloat, Elems > &v)
template<Vector Vec>
auto	invsqrt (const Vec &v) -> aie_dm_resource_remove_t< Vec >
template<Elem E>
auto	invsqrt (E a)
template<typename T , Elem E>
constexpr bool	is_ct_elem_zero (E a)
template<RealVector Vec, RealElem E> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	le (const Vec &v, E a)
	Compares the elements of the input vector with a value and returns a mask that says if the elements in the vector are smaller or equal than the value.
template<RealVector Vec1, RealVector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
mask< Vec1::size()>	le (const Vec1 &v1, const Vec2 &v2)
	Compares the elements of the two input vectors and returns a mask that says what elements from the first vector are smaller or equal than the corresponding elements in the second vector.
template<RealElem E, RealVector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	le (E a, const Vec &v)
	Compares a value with the elements of the input vector and returns a mask that says if the value is smaller or equal than the elements in the vector.
template<typename T > requires (detail::is_floating_point_v<T> && !detail::is_complex_v<T>)
bool	le (T a, T b)
	Compares the two input values and returns whether the first value is smaller or equal than the second value.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>
auto	load_floor_bytes_v (const T *ptr, size_t bytes) -> vector< aie_dm_resource_remove_t< T >, Elems >
	Load a vector of Elems size whose elements have type T.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>
auto	load_floor_v (const T *ptr, unsigned n=Elems) -> vector< aie_dm_resource_remove_t< T >, Elems >
	Load a vector of Elems size whose elements have type T.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>
auto	load_unaligned_v (const T *ptr, unsigned aligned_elems=1) -> vector< aie_dm_resource_remove_t< T >, Elems >
	Load a vector of Elems size whose elements have type T.
template<aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>
auto	load_unaligned_v (const T *ptr, unsigned aligned_elems=1) -> vector< aie_dm_resource_remove_t< T >, native_vector_length_v< T > >
	Load a vector whose elements have type T.
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>
auto	load_v (const T *ptr) -> vector< aie_dm_resource_remove_t< T >, Elems >
	Load a vector of Elems size whose elements have type T.
template<aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>
auto	load_v (const T *ptr) -> vector< aie_dm_resource_remove_t< T >, native_vector_length_v< T > >
	Load a vector whose elements have type T.
template<Vector Vec>
constexpr auto	logical_downshift (const Vec &v, unsigned shift) -> aie_dm_resource_remove_t< Vec >
	Returns a vector with all values logically downshifted by specified number of bits.
template<RealVector Vec, RealElem E> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	lt (const Vec &v, E a)
	Compares the elements of the input vector with a value and returns a mask that says if the elements in the vector are smaller than the value.
template<RealVector Vec1, RealVector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
mask< Vec1::size()>	lt (const Vec1 &v1, const Vec2 &v2)
	Compares the elements of the two input vectors and returns a mask that says what elements from the first vector are smaller than the corresponding elements in the second vector.
template<RealElem E, RealVector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	lt (E a, const Vec &v)
	Compares a value with the elements of the input vector and returns a mask that says if the value is smaller than the elements in the vector.
template<typename T > requires (detail::is_floating_point_v<T> && !detail::is_complex_v<T>)
bool	lt (T a, T b)
	Compares the two input values and returns whether the first value is smaller than the second value.
template<AccumOrOp Acc, VectorOrOp Vec, ElemOrOp E> requires (is_valid_size_v<Acc, Vec, E> && is_valid_mul_op_v<typename Vec::value_type, E>)
constexpr auto	mac (const Acc &acc, const Vec &v, E a) -> operand_base_type_t< Acc >
	Returns an accumulator with the element-wise multiply-add of input vector, value and accumulator.
template<AccumOrOp Acc, VectorOrOp Vec1, VectorOrOp Vec2> requires (is_valid_size_v<Acc, Vec1, Vec2> && is_valid_mul_op_v<typename Vec1::value_type, typename Vec2::value_type>)
constexpr auto	mac (const Acc &acc, const Vec1 &v1, const Vec2 &v2) -> operand_base_type_t< Acc >
	Returns an accumulator with the element-wise multiply-add of the two input vectors and accumulator.
template<AccumOrOp Acc, ElemOrOp E, VectorOrOp Vec> requires (is_valid_size_v<Acc, E, Vec> && is_valid_mul_op_v<E, typename Vec::value_type>)
constexpr auto	mac (const Acc &acc, E a, const Vec &v) -> operand_base_type_t< Acc >
	Returns an accumulator with the element-wise multiply-add of value, input vector and accumulator.
template<typename TR , typename T1 , typename T2 > requires (detail::is_floating_point_v<T1> && detail::is_floating_point_v<T2> && std::is_same_v<decltype(mul(a, b)), TR>)
TR	mac (TR c, T1 a, T2 b)
template<AccumOrOp Acc, Vector Vec> requires (Vec::size() == Acc::size())
constexpr auto	mac_square (const Acc &acc, const Vec &v)
	Returns an accumulator with the addition or subtraction of the given accumulator and the element-wise square of the input vector.
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , typename TensorDescriptor >
constexpr auto	make_restrict_tensor_buffer_stream (T *__restrict base, const TensorDescriptor &tensor_desc)
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , typename TensorDescriptor >
constexpr auto	make_tensor_buffer_stream (const T *base, const TensorDescriptor &tensor_desc)
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , typename TensorDescriptor >
constexpr auto	make_tensor_buffer_stream (T *base, const TensorDescriptor &tensor_desc)
template<typename T , unsigned Elems, typename... Args> requires (arch::is(arch::AIE_ML) && (std::is_same_v<Args, tensor_dim> && ...))
constexpr auto	make_tensor_descriptor (Args &&... args)
template<typename T , unsigned Elems, typename... Args> requires (arch::is(arch::AIE_ML) && (std::is_same_v<Args, tensor_dim> && ...))
constexpr auto	make_tensor_descriptor_bytes (Args &&... args)
template<typename T , unsigned Elems, typename... Args>
constexpr auto	make_tensor_descriptor_from_native (Args &&... args)
template<typename T , unsigned Elems, typename... Args>
constexpr auto	make_tensor_descriptor_from_native_bytes (Args &&... args)
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>
auto	make_unaligned_vector_input_buffer_stream (const T *ptr) -> unaligned_vector_input_buffer_stream< T, Elems, Resource >
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>
auto	make_unaligned_vector_output_buffer_stream (T *ptr) -> unaligned_vector_output_buffer_stream< T, Elems, Resource >
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>
auto	make_vector_input_buffer_stream (const T *ptr) -> vector_input_buffer_stream< T, Elems, Resource >
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>
auto	make_vector_output_buffer_stream (T *ptr) -> vector_output_buffer_stream< T, Elems, Resource >
template<RealVector Vec, RealElem E> requires (is_valid_elem_op_v<typename Vec::value_type, E>)
auto	max (const Vec &v, E a) -> aie_dm_resource_remove_t< Vec >
	Compares the elements of the input vector with a value and returns a vector with the maximum values.
template<RealVector Vec, RealElem E> requires (arch::is(arch::AIE_ML) && is_valid_elem_op_v<typename Vec::value_type, E>)
auto	max (const Vec &v, E a, bool sign) -> aie_dm_resource_remove_t< Vec >
	Compares the elements of the input vector with a value and returns a vector with the maximum values.
template<RealVector Vec1, RealVector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
auto	max (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
	Compares the elements of the two input vectors and returns a vector with the maximum values.
template<RealVector Vec1, RealVector Vec2> requires (arch::is(arch::AIE_ML) && is_same_vector_v<Vec1, Vec2>)
auto	max (const Vec1 &v1, const Vec2 &v2, bool sign) -> aie_dm_resource_remove_t< Vec1 >
	Compares the elements of the two input vectors and returns a vector with the maximum values.
template<RealElem E, RealVector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
auto	max (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
	Compares a value with the elements of the input vector and returns a vector with the maximum values.
template<RealElem E, RealVector Vec> requires (arch::is(arch::AIE_ML) && is_valid_elem_op_v<E, typename Vec::value_type>)
auto	max (E a, const Vec &v, bool sign) -> aie_dm_resource_remove_t< Vec >
	Compares a value with the elements of the input vector and returns a vector with the maximum values.
template<typename T > requires (detail::is_floating_point_v<T>)
T	max (T a, T b)
	Compares the two input values and returns the maximum value.
template<RealVector Vec1, RealVector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
auto	max_cmp (const Vec1 &v1, const Vec2 &v2) -> std::tuple< aie_dm_resource_remove_t< Vec1 >, mask< Vec1::size()> >
template<RealVector Vec>
Vec::value_type	max_reduce (const Vec &v)
template<RealVector Vec, RealElem E> requires (is_valid_elem_op_v<typename Vec::value_type, E>)
auto	maxdiff (const Vec &v, E a) -> aie_dm_resource_remove_t< Vec >
	Compares the elements of the input vector with a value and returns a vector whose values are their difference if it is positive, or zero otherwise.
template<RealVector Vec, RealElem E> requires (arch::is(arch::AIE_ML) && is_valid_elem_op_v<typename Vec::value_type, E>)
auto	maxdiff (const Vec &v, E a, bool sign) -> aie_dm_resource_remove_t< Vec >
	Compares the elements of the input vector with a value and returns a vector whose values are their difference if it is positive, or zero otherwise.
template<RealVector Vec1, RealVector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
auto	maxdiff (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
	Compares the elements of the two input vectors and returns a vector whose values are their difference if it is positive, or zero otherwise.
template<RealVector Vec1, RealVector Vec2> requires (arch::is(arch::AIE_ML) && is_same_vector_v<Vec1, Vec2>)
auto	maxdiff (const Vec1 &v1, const Vec2 &v2, bool sign) -> aie_dm_resource_remove_t< Vec1 >
	Compares the elements of the two input vectors and returns a vector whose values are their difference if it is positive, or zero otherwise.
template<RealElem E, RealVector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
auto	maxdiff (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
	Compares a value with the elements of the input vector and returns a vector whose values are their difference if it is positive, or zero otherwise.
template<RealElem E, RealVector Vec> requires (arch::is(arch::AIE_ML) && is_valid_elem_op_v<E, typename Vec::value_type>)
auto	maxdiff (E a, const Vec &v, bool sign) -> aie_dm_resource_remove_t< Vec >
	Compares a value with the elements of the input vector and returns a vector whose values are their difference if it is positive, or zero otherwise.
template<RealVector Vec, RealElem E> requires (is_valid_elem_op_v<typename Vec::value_type, E>)
auto	min (const Vec &v, E a) -> aie_dm_resource_remove_t< Vec >
	Compares the elements of the input vector with a value and returns a vector with the minimum values.
template<RealVector Vec, RealElem E> requires (arch::is(arch::AIE_ML) && is_valid_elem_op_v<typename Vec::value_type, E>)
auto	min (const Vec &v, E a, bool sign) -> aie_dm_resource_remove_t< Vec >
	Compares the elements of the input vector with a value and returns a vector with the minimum values.
template<RealVector Vec1, RealVector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
auto	min (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
	Compares the elements of the two input vectors and returns a vector with the minimum values.
template<RealVector Vec1, RealVector Vec2> requires (arch::is(arch::AIE_ML) && is_same_vector_v<Vec1, Vec2>)
auto	min (const Vec1 &v1, const Vec2 &v2, bool sign) -> aie_dm_resource_remove_t< Vec1 >
	Compares the elements of the two input vectors and returns a vector with the minimum values.
template<RealElem E, RealVector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
auto	min (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
	Compares a value with the elements of the input vector and returns a vector with the minimum values.
template<RealElem E, RealVector Vec> requires (arch::is(arch::AIE_ML) && is_valid_elem_op_v<E, typename Vec::value_type>)
auto	min (E a, const Vec &v, bool sign) -> aie_dm_resource_remove_t< Vec >
	Compares a value with the elements of the input vector and returns a vector with the minimum values.
template<typename T > requires (detail::is_floating_point_v<T>)
T	min (T a, T b)
	Compares the two input values and returns the minimum value.
template<RealVector Vec1, RealVector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
auto	min_cmp (const Vec1 &v1, const Vec2 &v2) -> std::tuple< aie_dm_resource_remove_t< Vec1 >, mask< Vec1::size()> >
template<RealVector Vec>
Vec::value_type	min_reduce (const Vec &v)
template<unsigned M, unsigned K, unsigned N, typename Acc , Vector VecA, Vector VecB> requires ((Acc::accum_type::size() == M * N) && (VecA::size() == M * K) && (VecB::size() == K * N) && is_valid_mul_op_v<typename VecA::value_type, typename VecB::value_type> && is_mmul_v<Acc>)
auto	mmac_fn (Acc &c, const VecA &a, const VecB &b)
template<unsigned M, unsigned K, unsigned N, Accum Acc, Vector VecA, Vector VecB> requires ((Acc::size() == M * N) && (VecA::size() == M * K) && (VecB::size() == K * N) && is_valid_mul_op_v<typename VecA::value_type, typename VecB::value_type>)
auto	mmac_fn (const Acc &c, const VecA &a, const VecB &b)
template<unsigned M, unsigned K, unsigned N, AccumElemBaseType AccumTag = accauto, Vector VecA, Vector VecB> requires ((VecA::size() == M * K) && (VecB::size() == K * N) && is_valid_mul_op_v<typename VecA::value_type, typename VecB::value_type>)
auto	mmul_fn (const VecA &a, const VecB &b)
template<Accum Acc, VectorOrOp Vec, ElemOrOp E> requires (is_valid_size_v<Acc, Vec, E> && is_valid_mul_op_v<typename Vec::value_type, E>)
constexpr auto	msc (const Acc &acc, const Vec &v, E a) -> aie_dm_resource_remove_t< Acc >
	Returns an accumulator with the element-wise multiply-add of input vector, value and accumulator.
template<Accum Acc, VectorOrOp Vec1, VectorOrOp Vec2> requires (is_valid_size_v<Acc, Vec1, Vec2> && is_valid_mul_op_v<typename Vec1::value_type, typename Vec2::value_type>)
constexpr auto	msc (const Acc &acc, const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Acc >
	Returns an accumulator with the element-wise multiply-add of the two input vectors and accumulator.
template<Accum Acc, ElemOrOp E, VectorOrOp Vec> requires (is_valid_size_v<Acc, E, Vec> && is_valid_mul_op_v<E, typename Vec::value_type>)
constexpr auto	msc (const Acc &acc, E a, const Vec &v) -> aie_dm_resource_remove_t< Acc >
	Returns an accumulator with the element-wise multiply-add of value, input vector and accumulator.
template<typename TR , typename T1 , typename T2 > requires (detail::is_floating_point_v<T1> && detail::is_floating_point_v<T2> && std::is_same_v<decltype(mul(a, b)), TR>)
TR	msc (TR c, T1 a, T2 b)
template<Accum Acc, Vector Vec> requires (Vec::size() == Acc::size())
constexpr auto	msc_square (const Acc &acc, const Vec &v)
	Returns an accumulator with the subtraction of the given accumulator and the element-wise square of the input vector.
template<VectorOrOp Vec, ElemOrOp E> requires (is_valid_size_v<E, Vec> && is_valid_mul_op_v<typename Vec::value_type, E>)
constexpr auto	mul (const Vec &v, E a)
	Returns an accumulator with the element-wise multiplication of a value and all the elements of a vector.
template<AccumElemBaseType AccumTag, VectorOrOp Vec, ElemOrOp E> requires (is_valid_size_v<Vec, E> && is_valid_mul_op_v<typename Vec::value_type, E>)
constexpr auto	mul (const Vec &v, E a) -> accum< AccumTag, Vec::size()>
	Returns an accumulator of the requested type with the element-wise multiplication of a value and all the elements of the input vector.
template<VectorOrOp Vec1, VectorOrOp Vec2> requires (is_valid_size_v<Vec1, Vec2> && is_valid_mul_op_v<typename Vec1::value_type, typename Vec2::value_type>)
constexpr auto	mul (const Vec1 &v1, const Vec2 &v2)
	Returns an accumulator with the element-wise multiplication of the two input vectors.
template<AccumElemBaseType AccumTag, VectorOrOp Vec1, VectorOrOp Vec2> requires (is_valid_size_v<Vec1, Vec2> && is_valid_mul_op_v<typename Vec1::value_type, typename Vec2::value_type>)
constexpr auto	mul (const Vec1 &v1, const Vec2 &v2) -> accum< AccumTag, Vec1::size()>
	Returns an accumulator of the requested type with the element-wise multiplication of the two input vectors.
template<ElemOrOp E, VectorOrOp Vec> requires (is_valid_size_v<E, Vec> && is_valid_mul_op_v<E, typename Vec::value_type>)
constexpr auto	mul (E a, const Vec &v)
	Returns an accumulator with the element-wise multiplication of a value and all the elements of a vector.
template<AccumElemBaseType AccumTag, ElemOrOp E, VectorOrOp Vec> requires (is_valid_size_v<Vec, E> && is_valid_mul_op_v<E, typename Vec::value_type>)
constexpr auto	mul (E a, const Vec &v) -> accum< AccumTag, Vec::size()>
	Returns an accumulator of the requested type with the element-wise multiplication of a value and all the elements of the input vector.
template<typename T1 , typename T2 > requires (detail::is_floating_point_v<T1> && detail::is_floating_point_v<T2>)
auto	mul (T1 a, T2 b)
template<AccumElemBaseType AccumTag, Vector Vec>
Vec::value_type	mul_reduce (const Vec &v)
template<Vector Vec>
constexpr Vec::value_type	mul_reduce (const Vec &v)
template<Vector Vec>
constexpr auto	mul_square (const Vec &v)
	Returns an accumulator with the element-wise square of the input vector.
template<AccumElemBaseType AccumTag, Vector Vec>
constexpr auto	mul_square (const Vec &v) -> accum< AccumTag, Vec::size()>
	Returns an accumulator of the requested type with the element-wise square of the input vector.
template<Elem E>
constexpr auto	neg (const E &a) -> operand_base_type_t< E >
	For values with signed types, return the input value with the sign flipped.
template<Vector Vec>
constexpr auto	neg (const Vec &v) -> aie_dm_resource_remove_t< Vec >
	For vectors with signed types, return a vector whose elements are the same as in the given vector but with the sign flipped.
template<VectorOrOp Vec, ElemOrOp E> requires (is_valid_mul_op_v<typename Vec::value_type, E>)
constexpr auto	negmul (const Vec &v, E a)
	Returns an accumulator with the negate of the element-wise multiplication of all the elements of the input vector and a value.
template<AccumElemBaseType AccumTag, VectorOrOp Vec, ElemOrOp E> requires (is_valid_mul_op_v<typename Vec::value_type, E>)
constexpr auto	negmul (const Vec &v, E a) -> accum< AccumTag, Vec::size()>
	Returns an accumulator of the requested type with the negate of the element-wise multiplication of all the elements of the input vector and a value.
template<VectorOrOp Vec1, VectorOrOp Vec2> requires ((Vec1::size() == Vec2::size()) && is_valid_mul_op_v<typename Vec1::value_type, typename Vec2::value_type>)
constexpr auto	negmul (const Vec1 &v1, const Vec2 &v2)
	Returns an accumulator with the negate of the element-wise multiplication of the two input vectors.
template<AccumElemBaseType AccumTag, VectorOrOp Vec1, VectorOrOp Vec2> requires (Vec1::size() == Vec2::size() && is_valid_mul_op_v<typename Vec1::value_type, typename Vec2::value_type>)
constexpr auto	negmul (const Vec1 &v1, const Vec2 &v2) -> accum< AccumTag, Vec1::size()>
	Returns an accumulator of the requested type with the negate of the element-wise multiplication of the two input vectors.
template<ElemOrOp E, VectorOrOp Vec> requires (is_valid_mul_op_v<E, typename Vec::value_type>)
constexpr auto	negmul (E a, const Vec &v)
	Returns an accumulator with the negate of the element-wise multiplication of a value and all the elements of the input vector.
template<AccumElemBaseType AccumTag, ElemOrOp E, VectorOrOp Vec> requires (is_valid_mul_op_v<E, typename Vec::value_type>)
constexpr auto	negmul (E a, const Vec &v) -> accum< AccumTag, Vec::size()>
	Returns an accumulator of the requested type with the negate of the element-wise multiplication of a value and all the elements of the input vector.
template<Vector Vec, Elem E> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	neq (const Vec &v, E a)
	Compares a value with the elements of the input vector and returns a mask that says what elements in the vector are different than the value.
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
mask< Vec1::size()>	neq (const Vec1 &v1, const Vec2 &v2)
	Compares the elements of the two input vectors and returns a mask that says what elements are different.
template<Elem E, Vector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	neq (E a, const Vec &v)
	Compares a value with the elements of the input vector and returns a mask that says what elements in the vector are different than the value.
template<typename T > requires (detail::is_floating_point_v<T>)
bool	neq (T a, T b)
	Compares the two input values and returns whether they are not equal.
template<Vector Vec, Elem E> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
constexpr bool	not_equal (const Vec &v, E a)
	Return whether some the elements of the input vector are not equal to the scalar.
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
constexpr bool	not_equal (const Vec1 &v1, const Vec2 &v2)
	Return whether some elements in the two input vectors are not equal.
template<Elem E, Vector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
constexpr bool	not_equal (E a, const Vec &v)
	Return whether some the elements of the input vector are not equal to the scalar.
template<typename T > requires (RealVector<T> || RealElem<T> || is_real_op_v<T>)
constexpr unary_op< T, Operation::Abs >	op_abs (const T &e)
	Returns an absolute operation modifier for the given vector or element.
template<Accum Acc>
constexpr unary_op< Acc, Operation::Acc_Add >	op_add (const Acc &acc)
	Returns an addition operation modifier for the given accumulator.
template<typename T > requires (ComplexVector<T> || ComplexElem<T> || is_complex_op_v<T>)
constexpr unary_op< T, Operation::Conj >	op_conj (const T &e)
	Returns a conjugate operation modifier for the given complex vector or element.
template<VectorOrOp Vec1, VectorOrOp Vec2>
constexpr binary_op< Vec1, Vec2, Operation::Max >	op_max (const Vec1 &a, const Vec2 &b)
	Returns a maximum operation modifier for the given pair of vectors or elements.
template<VectorOrOp Vec1, VectorOrOp Vec2>
constexpr binary_op< Vec1, Vec2, Operation::Min >	op_min (const Vec1 &a, const Vec2 &b)
	Returns a minimum operation modifier for the given pair of vectors or elements.
template<typename T > requires (Vector<T> || SparseVector<T> || Elem<T> || Accum<T>)
constexpr unary_op< T, Operation::None >	op_none (const T &e)
	Returns an empty operation modifier for the given vector, vector element or accumulator.
template<typename T > requires ((Vector<T> || SparseVector<T> || Elem<T> || Accum<T> || is_op_v<T>) && (!detail::is_complex_v<typename T::value_type>) && (!detail::is_floating_point_v<typename T::value_type>))
constexpr binary_op< T, bool, Operation::Sign >	op_sign (const T &e, bool is_signed)
	Returns dynamically signed/unsigned operation modifier for the vector or element, based on the boolean parameter.
template<Accum Acc>
constexpr unary_op< Acc, Operation::Acc_Sub >	op_sub (const Acc &acc)
	Returns a subtraction operation modifier for the given accumulator.
template<Accum Acc>
constexpr binary_op< Acc, bool, Operation::Zero >	op_zero (const Acc &acc, bool to_zero)
	Zeroes out the given accumulator or not depending on the zero parameter.
template<typename T1 , typename T2 > requires (detail::is_vector_elem_ref_v<T1> || detail::is_vector_elem_ref_v<T2>)
constexpr auto	operator& (T1 v1, T2 v2)
template<typename T1 , typename T2 > requires (detail::is_vector_elem_ref_v<T1> || detail::is_vector_elem_ref_v<T2>)
constexpr auto	operator+ (T1 v1, T2 v2)
template<typename T1 , typename T2 > requires (detail::is_vector_elem_ref_v<T1> || detail::is_vector_elem_ref_v<T2>)
constexpr auto	operator- (T1 v1, T2 v2)
template<typename T > requires (detail::is_vector_elem_ref_v<T>)
constexpr auto	operator<< (T v, int n) -> typename T::value_type
template<typename T > requires (detail::is_vector_elem_ref_v<T>)
constexpr auto	operator<< (T v, unsigned n) -> typename T::value_type
template<typename T > requires (detail::is_vector_elem_ref_v<T>)
constexpr auto	operator>> (T v, int n) -> typename T::value_type
template<typename T > requires (detail::is_vector_elem_ref_v<T>)
constexpr auto	operator>> (T v, unsigned n) -> typename T::value_type
template<typename T1 , typename T2 > requires (detail::is_vector_elem_ref_v<T1> || detail::is_vector_elem_ref_v<T2>)
constexpr auto	operator^ (T1 v1, T2 v2)
template<typename T1 , typename T2 > requires (detail::is_vector_elem_ref_v<T1> || detail::is_vector_elem_ref_v<T2>)
constexpr auto	operator| (T1 v1, T2 v2)
template<typename T > requires (detail::is_vector_elem_ref_v<T>)
constexpr auto	operator~ (T v)
template<VectorOrOp Vec, typename T2 = Utils::get_prev_integer_type_t<typename Vec::value_type>> requires (!detail::is_floating_point_v<Vec>)
auto	pack (const Vec &v) -> vector< T2, Vec::size()>
	Returns a conversion of the passed vector to the next smaller integer datatype, with the same number of elements.
template<unsigned N>
void	print (const aie::mask< N > &m, bool nl=false, const char *prefix=nullptr)
	Displays the contents of a mask.
template<typename C > requires (Vector<C> || Accum<C>)
void	print (const C &c, bool nl=false, const char *prefix=nullptr)
	Displays the contents of a vector or an accumulator.
template<typename T , unsigned Elems> requires (!detail::is_floating_point_v<T>)
void	print_fixed (const aie::vector< T, Elems > &v, int scale, bool nl=false, const char *prefix=nullptr)
	Displays the contents of a vector integers represented as real numbers in fixed point.
template<typename Matrix > requires (Vector<Matrix> || Accum<Matrix>)
void	print_matrix (const Matrix &m, unsigned cols, const char *prefix=nullptr)
	Displays the contents of a vector or accumulator, arranged in a matrix layout.
template<ComplexVector Vec>
auto	real (const Vec &v) -> vector< detail::utils::get_complex_component_type_t< typename Vec::value_type >, Vec::size()>
	Gather and return the real components of a complex vector.
template<ComplexElem Elem>
auto	real (Elem e) -> detail::utils::get_complex_component_type_t< operand_base_type_t< Elem > >
	Return the real component of a complex value.
template<Vector Vec>
Vec::value_type	reduce_add (const Vec &v)
	Returns sum of the elements in the input vector.
template<Vector Vec, Vector... Others>
auto	reduce_add_v (const Vec &v, const Others &... others) -> aie_dm_resource_remove_t< Vec >
	Returns the sums of the elements in the input vectors.
template<RealVector Vec>
Vec::value_type	reduce_max (const Vec &v)
	Returns the element from the input vector with the largest value.
template<RealVector Vec>
Vec::value_type	reduce_min (const Vec &v)
	Returns the element from the input vector with the smallest value.
template<AccumElemBaseType AccumTag, Vector Vec>
Vec::value_type	reduce_mul (const Vec &v)
template<Vector Vec>
constexpr Vec::value_type	reduce_mul (const Vec &v)
template<Vector Vec>
auto	reverse (const Vec &v) -> aie_dm_resource_remove_t< Vec >
	Returns a vector whose contents are the same as the input vector, but in reverse order.
template<Vector Vec, Elem E> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
auto	saturating_add (const Vec &v, E a) -> aie_dm_resource_remove_t< Vec >
	Returns a vector with the addition of a value to all the elements of the input vector.
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2> && !detail::is_floating_point_v<typename Vec1::value_type>)
auto	saturating_add (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
	Returns a vector with the element-wise addition of the two input vectors.
template<Elem E, Vector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
auto	saturating_add (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
	Returns a vector with the addition of a value to all the elements of the input vector.
template<Vector Vec, Elem E> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
auto	saturating_sub (const Vec &v, E a) -> aie_dm_resource_remove_t< Vec >
	Returns a vector with the subtraction of the elements of the input vector and a value.
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2> && !detail::is_floating_point_v<typename Vec1::value_type>)
auto	saturating_sub (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
	Returns a vector with the element-wise subtraction of the two input vectors.
template<Elem E, Vector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
auto	saturating_sub (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
	Returns a vector with the subtraction of a value to all the elements of the input vector.
template<Elem E1, Elem E2, Mask M> requires (is_valid_elem_op_v<E1, E2>)
vector< operand_base_type_t< E1 >, M::size()>	select (const E1 &a, const E2 &b, const M &m)
	Combines the values of the input vector and value into a vector of the same size by using a mask that specifies which is the source input for each element of the output vector.
template<Vector Vec, Elem E, Mask M> requires (is_valid_elem_op_v<E, typename Vec::value_type> && Vec::size() == M::size())
auto	select (const Vec &v, E a, const M &m) -> aie_dm_resource_remove_t< Vec >
	Combines the values of the input vector and value into a vector of the same size by using a mask that specifies which is the source input for each element of the output vector.
template<Vector Vec1, Vector Vec2, Mask M> requires (is_same_vector_v<Vec1, Vec2> && Vec1::size() == M::size())
auto	select (const Vec1 &v1, const Vec2 &v2, const M &m) -> aie_dm_resource_remove_t< Vec1 >
	Combines the values of the two input vectors into a vector of the same size by using a mask that specifies which is the source input for each element of the output vector.
template<Elem E, Vector Vec, Mask M> requires (is_valid_elem_op_v<E, typename Vec::value_type> && Vec::size() == M::size())
auto	select (E a, const Vec &v, const M &m) -> aie_dm_resource_remove_t< Vec >
	Combines the values of the input value and vector into a vector of the same size by using a mask that specifies which is the source input for each element of the output vector.
static void	set_rounding (rounding_mode m)
	Set the rounding mode used in accumulator to vector conversions.
static void	set_saturation (saturation_mode m)
	Set the saturation mode.
template<Vector Vec>
auto	shuffle_down (const Vec &v, unsigned n) -> aie_dm_resource_remove_t< Vec >
	Returns a vector whose contents are the same as the input vector, but shifted down by n.
template<Vector Vec>
auto	shuffle_down_fill (const Vec &v, const Vec &fill, unsigned n) -> aie_dm_resource_remove_t< Vec >
	Returns a vector whose contents are the same as the input vector, but shifted down by n.
template<Vector Vec>
auto	shuffle_down_replicate (const Vec &v, unsigned n) -> aie_dm_resource_remove_t< Vec >
	Returns a vector whose contents are the same as the input vector, but shifted down by n.
template<Vector Vec>
auto	shuffle_down_rotate (const Vec &v, unsigned n) -> aie_dm_resource_remove_t< Vec >
	Returns a vector whose contents are the same as the input vector, but shifted down by n (elements wrap around):
template<Vector Vec>
auto	shuffle_up (const Vec &v, unsigned n) -> aie_dm_resource_remove_t< Vec >
	Returns a vector whose contents are the same as the input vector, but shifted up by n.
template<Vector Vec>
auto	shuffle_up_fill (const Vec &v, const Vec &fill, unsigned n) -> aie_dm_resource_remove_t< Vec >
	Returns a vector whose contents are the same as the input vector, but shifted up by n.
template<Vector Vec>
auto	shuffle_up_replicate (const Vec &v, unsigned n) -> aie_dm_resource_remove_t< Vec >
	Returns a vector whose contents are the same as the input vector, but shifted up by n.
template<Vector Vec>
auto	shuffle_up_rotate (const Vec &v, unsigned n) -> aie_dm_resource_remove_t< Vec >
	Returns a vector whose contents are the same as the input vector, but shifted up by n (elements wrap around):
template<RealVector Vec> requires (arch::is(arch::AIE))
auto	sin (const Vec &v) -> aie_dm_resource_remove_t< Vec >
	Performs a sine operation on all elements in the input vector.
template<typename E > requires (arch::is(arch::AIE) && (RealElem<E> || std::is_integral_v<E>))
auto	sin (E a)
	Performs a sine operation on a single value.
template<RealVector Vec> requires (arch::is(arch::AIE))
auto	sincos (const Vec &v) -> std::pair< aie_dm_resource_remove_t< Vec >, aie_dm_resource_remove_t< Vec > >
	Same as sin and cos, but performs both operations and returns a std::pair of vectors of result values.
template<typename E > requires (arch::is(arch::AIE) && (RealElem<E> || std::is_integral_v<E>))
auto	sincos (E a)
	Performs both sin and cos, and returns both values as an std::pair (sin first, then cos).
template<RealVector Vec> requires (arch::is(arch::AIE))
auto	sincos_complex (const Vec &v) -> vector< std::conditional_t< Vec::is_floating_point(), cfloat, cint16 >, Vec::size()>
	Same as sincos, but returns both values as the real and imaginary parts in a vector of complex values (cos in the real part, sin in the imaginary).
template<typename E > requires (arch::is(arch::AIE) && (RealElem<E> || std::is_integral_v<E>))
auto	sincos_complex (E a) -> std::conditional_t< detail::is_floating_point_v< operand_base_type_t< E > >, cfloat, cint16 >
	Same as sincos, but returns both values as the real and imaginary parts of a complex number (cos in the real part, sin in the imaginary part).
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))
auto	sliding_mac (const Acc &acc, const VecCoeff &coeff, const VecData &data, unsigned data_start)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))
auto	sliding_mac (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))
auto	sliding_mac_antisym (const Acc &acc, const VecCoeff &coeff, const VecData &data, unsigned data_start)
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))
auto	sliding_mac_antisym (const Acc &acc, const VecCoeff &coeff, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))
auto	sliding_mac_antisym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))
auto	sliding_mac_antisym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))
auto	sliding_mac_antisym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))
auto	sliding_mac_antisym_uct (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))
auto	sliding_mac_antisym_uct (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start, unsigned uct_shift)
template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE_ML) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Outputs * Channels))
auto	sliding_mac_ch (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))
auto	sliding_mac_sym (const Acc &acc, const VecCoeff &coeff, const VecData &data, unsigned data_start)
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))
auto	sliding_mac_sym (const Acc &acc, const VecCoeff &coeff, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))
auto	sliding_mac_sym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))
auto	sliding_mac_sym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))
auto	sliding_mac_sym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))
auto	sliding_mac_sym_uct (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))
auto	sliding_mac_sym_uct (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start, unsigned uct_shift)
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	sliding_mul (const VecCoeff &coeff, const VecData &data, unsigned data_start)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	sliding_mul (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	sliding_mul_antisym (const VecCoeff &coeff, const VecData &data, unsigned data_start)
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, typename VecCoeff , typename VecData > requires (arch::is(arch::AIE) && VectorOrOp<VecCoeff> && VectorOrOp<VecData> && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	sliding_mul_antisym (const VecCoeff &coeff, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	sliding_mul_antisym (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	sliding_mul_antisym (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	sliding_mul_antisym (const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	sliding_mul_antisym_uct (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	sliding_mul_antisym_uct (const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start, unsigned uct_shift)
template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE_ML) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	sliding_mul_ch (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	sliding_mul_sym (const VecCoeff &coeff, const VecData &data, unsigned data_start)
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, typename VecCoeff , typename VecData > requires (arch::is(arch::AIE) && VectorOrOp<VecCoeff> && VectorOrOp<VecData> && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	sliding_mul_sym (const VecCoeff &coeff, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	sliding_mul_sym (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	sliding_mul_sym (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	sliding_mul_sym (const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	sliding_mul_sym_uct (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData> requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
auto	sliding_mul_sym_uct (const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start, unsigned uct_shift)
template<detail::NativeSparseVector T>
	sparse_vector (T) -> sparse_vector< typename detail::native_vector_traits< T >::value_type, detail::native_vector_traits< T >::size >
	Template deduction guidelines for aie::sparse_vector.
template<unsigned Elems> requires (arch::is(arch::AIE))
accum< accfloat, Elems >	sqrt (const accum< accfloat, Elems > &v)
template<Vector Vec>
auto	sqrt (const Vec &v) -> aie_dm_resource_remove_t< Vec >
template<Elem E>
auto	sqrt (E a)
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T1, ElemBaseType T2> requires (std::is_same_v<T2, aie_dm_resource_remove_t<T1>>)
T1 *	store_unaligned_v (T1 *ptr, const vector< T2, Elems > &v, unsigned aligned_elems=1)
	Store a vector of Elems size whose elements have type T.
template<aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T1, ElemBaseType T2, unsigned Elems> requires (std::is_same_v<aie_dm_resource_remove_t<T1>, aie_dm_resource_remove_t<T2>>)
T1 *	store_v (T1 *ptr, const vector< T2, Elems > &v)
	Store a vector of Elems size whose elements have type T.
template<AccumOrOp Acc, Vector Vec> requires (Acc::size() == Vec::size())
constexpr auto	sub (const Acc &acc, const Vec &v) -> result_type_t< Acc >
	Returns an accumulator with the element-wise subtraction of the input accumulator and vector.
template<AccumOrOp Acc, Elem E>
auto	sub (const Acc &acc, E a) -> result_type_t< Acc >
	Returns an accumulator with the subtraction of all the elements of the input accumulator and a value.
template<AccumOrOp Acc1, AccumOrOp Acc2> requires (arch::is(arch::AIE_ML) && is_same_accum_v<result_type_t<Acc1>, result_type_t<Acc2>>)
auto	sub (const Acc1 &acc1, const Acc2 &acc2) -> result_type_t< Acc1 >
	Returns an accumulator with the element-wise subtraction of the two input accumulators.
template<Vector Vec, Elem E> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
auto	sub (const Vec &v, E a) -> aie_dm_resource_remove_t< Vec >
	Returns a vector with the subtraction of the elements of the input vector and a value.
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
auto	sub (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
	Returns a vector with the element-wise subtraction of the two input vectors.
template<Elem E, Vector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
auto	sub (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
	Returns a vector with the subtraction of a value and all the elements of the input vector.
template<typename T > requires (detail::is_floating_point_v<T>)
T	sub (T a, T b)
static rounding_mode	swap_rounding (rounding_mode m)
	Set the rounding mode used in accumulator to vector conversions and return the previously set mode.
static saturation_mode	swap_saturation (saturation_mode m)
	Set the saturation mode and return the previously set mode.
template<typename T >
	tlast (const T &, bool) -> tlast< const T &, bool >
template<typename T >
	tlast (T &, bool &) -> tlast< T &, bool & >
template<typename TR = cint32> requires (arch::is(arch::AIE, arch::AIE_ML) && Utils::is_one_of_v<TR, cint16, cint32>)
auto	to_fixed (cfloat a, int shift=0)
	Convert a floating point value into a fixed-point value.
template<typename TR = int32, unsigned Elems> requires (arch::is(arch::AIE_ML))
auto	to_fixed (const vector< bfloat16, Elems > &v, int shift=0) -> vector< TR, Elems >
	Convert the elements in a bfloat16 vector into fixed-point values.
template<typename TR = cint32, unsigned Elems> requires ((arch::is(arch::AIE) || (arch::is(arch::AIE_ML) && __AIE_API_COMPLEX_FP32_EMULATION__ == 1)) && Utils::is_one_of_v<TR, cint16, cint32>)
auto	to_fixed (const vector< cfloat, Elems > &v, int shift=0) -> vector< TR, Elems >
	Convert the elements in a floating point vector into fixed-point values.
template<typename TR = int32, unsigned Elems> requires (Utils::is_one_of_v<TR, int16, int32>)
auto	to_fixed (const vector< float, Elems > &v, int shift=0) -> vector< TR, Elems >
	Convert the elements in a floating point vector into fixed-point values.
template<typename TR = int32> requires (Utils::is_one_of_v<TR, int8, int16, int32>)
auto	to_fixed (float a, int shift=0)
	Convert a floating point value into a fixed-point value.
template<typename TR = float, typename T , unsigned Elems> requires (Utils::is_one_of_v<T, int16, int32>)
auto	to_float (const vector< T, Elems > &v, int shift=0) -> vector< TR, Elems >
	Convert the elements in a real fixed-point vector into floating point values.
template<typename TR = cfloat, typename T , unsigned Elems> requires (Utils::is_one_of_v<T, cint16, cint32>)
auto	to_float (const vector< T, Elems > &v, int shift=0) -> vector< TR, Elems >
	Convert the elements in a complex fixed-point vector into floating point values.
template<typename TR = float>
auto	to_float (int a, int shift=0)
	Convert a fixed-point value into a floating point value.
template<typename TR = cfloat, typename T > requires (Utils::is_one_of_v<T, cint16, cint32>)
auto	to_float (T a, int shift=0)
	Convert a complex fixed-point value into a floating point value.
template<typename TR , typename T > requires (AccumOrOp<T> || MmulOrOp<T>)
vector< TR, T::size()>	to_vector (const T &acc, int shift=0)
	Returns the values of the passed accumulator in a vector of the requested type.
template<Vector Vec>
auto	transpose (const Vec &v, unsigned Row, unsigned Col) -> aie_dm_resource_remove_t< Vec >
	The input vector is interpreted as a row-major matrix of the dimensions specified by Row and Col, the function returns a vector ordered as the transpose of the specified matrix.
template<VectorOrOp Vec, typename T2 = Utils::get_next_integer_type_t<typename Vec::value_type>> requires (!detail::is_floating_point_v<Vec>)
auto	unpack (const Vec &v) -> vector< T2, Vec::size()>
	Returns a conversion of the passed vector to the next larger integer datatype, with the same number of elements.
template<Vector Vec>
constexpr auto	upshift (const Vec &v, unsigned shift) -> aie_dm_resource_remove_t< Vec >
	Returns a vector with all values upshifted by specified number of bits.
template<detail::NativeVectorType T>
	vector (T) -> vector< typename detail::native_vector_traits< T >::value_type, detail::native_vector_traits< T >::size >
	Template deduction guidelines for aie::vector.
template<ElemBaseType DstT, Accum Acc> requires (arch::is(arch::AIE_ML))
auto	vector_cast (const Acc &acc)
	Reinterpret an accumulator as a vector.
template<ElemBaseType DstT, Vector Vec>
auto	vector_cast (const Vec &v)
	Reinterpret a vector using a different element type.
template<AccumElemBaseType DstTag, Vector Vec> requires (arch::is(arch::AIE_ML))
auto	vector_cast (const Vec &v)
	Reinterpret a vector as an accumulator.
template<ElemBaseType T>
constexpr T	zero ()
	Returns the zero value for the requested data type.
template<ElemBaseType T, unsigned Elems = native_vector_length_v<T>>
vector< T, Elems >	zeros ()
	Returns a vector whose elements are initialized to zero.
template<AccumElemBaseType AccumTag, unsigned Elems = native_vector_length_v<AccumTag>>
accum< AccumTag, Elems >	zeros ()
	Returns a vector whose elements are initialized to zero.

Variables
constexpr size_t	dynamic_extent = std::numeric_limits<size_t>::max()
template<typename T >
static constexpr bool	is_accum_op_v = is_accum_op<T>::value
template<typename T >
static constexpr bool	is_binary_op_v = is_binary_op<T>::value
template<typename T >
static constexpr bool	is_complex_op_v = is_complex_op<T>::value
template<typename T >
static constexpr bool	is_elem_op_v = is_elem_op<T>::value
template<typename T >
static constexpr bool	is_lut_v = is_lut<T>::value()
template<typename T >
static constexpr bool	is_mmul_or_op_v
template<typename T >
static constexpr bool	is_mmul_v = is_mmul<T>::value
template<typename T >
static constexpr bool	is_op_v = is_unary_op_v<T> || is_binary_op_v<T>
template<typename T >
static constexpr bool	is_real_op_v = is_real_op<T>::value
template<Accum Acc1, Accum Acc2>
static constexpr bool	is_same_accum_v = std::is_same_v<aie_dm_resource_remove_t<Acc1>, aie_dm_resource_remove_t<Acc2>>
template<Vector Vec1, Vector Vec2>
static constexpr bool	is_same_vector_v = is_same_vector<aie_dm_resource_remove_t<Vec1>, aie_dm_resource_remove_t<Vec2>>::value
template<typename T >
static constexpr bool	is_sparse_vector_op_v = is_sparse_vector_op<T>::value
template<typename T >
static constexpr bool	is_unary_op_v = is_unary_op<T>::value
template<typename T1 , typename T2 >
static constexpr bool	is_valid_elem_op_v = is_valid_elem_op<T1, T2>::value
template<typename T , typename T2 >
static constexpr bool	is_valid_mul_op_v = is_valid_mul_op<T, T2>::value()
template<typename T , typename T2 , typename... Other>
static constexpr bool	is_valid_size_v = is_valid_size<T, T2, Other...>::value
template<typename T >
static constexpr bool	is_vector_op_v = is_vector_op<T>::value
static constexpr int	max_shift = detail::max_shift
static constexpr int	min_shift = detail::min_shift
template<typename T >
static constexpr unsigned	native_vector_length_v = detail::native_vector_length_v<T>
static constexpr unsigned	vector_decl_align = detail::vector_decl_align
	Specifies the minimum alignment requirement for vector loads and stores.
template<DecoratedElemBaseType T, unsigned Elems>
static constexpr unsigned	vector_ldst_align_v = detail::vector_ldst_align_v<T, Elems>
	Specifies the minimum alignment requirement for vector loads and stores.

---

Class Documentation

aie::binary_op

struct aie::binary_op

template<typename Parent1, typename Parent2, Operation Op>
struct aie::binary_op< Parent1, Parent2, Op >

aie::op_result_helper

struct aie::op_result_helper

template<typename T, Operation Op>
struct aie::op_result_helper< T, Op >

Class Members
typedef T	type

aie::op_result_helper< binary_op< Parent1, Parent2, ParentOp >, Op >

struct aie::op_result_helper< binary_op< Parent1, Parent2, ParentOp >, Op >

template<typename Parent1, typename Parent2, Operation ParentOp, Operation Op>
struct aie::op_result_helper< binary_op< Parent1, Parent2, ParentOp >, Op >

Class Members
typedef typename result_type, Op >::type	type

aie::op_result_helper< Parent, Operation::None >

struct aie::op_result_helper< Parent, Operation::None >

template<typename Parent>
struct aie::op_result_helper< Parent, Operation::None >

Class Members
typedef Parent	type

aie::op_result_helper< unaligned_vector_ref< T, Elems, Resource >, Op >

struct aie::op_result_helper< unaligned_vector_ref< T, Elems, Resource >, Op >

template<typename T, unsigned Elems, aie_dm_resource Resource, Operation Op>
requires (Op != Operation::None)
struct aie::op_result_helper< unaligned_vector_ref< T, Elems, Resource >, Op >

Class Members
typedef vector< T, Elems >	type

aie::op_result_helper< unary_op< Parent, ParentOp >, Op >

struct aie::op_result_helper< unary_op< Parent, ParentOp >, Op >

template<typename Parent, Operation ParentOp, Operation Op>
struct aie::op_result_helper< unary_op< Parent, ParentOp >, Op >

Class Members
typedef typename result_type, Op >::type	type

aie::op_result_helper< vector_elem_const_ref< T, Elems >, Op >

struct aie::op_result_helper< vector_elem_const_ref< T, Elems >, Op >

template<typename T, unsigned Elems, Operation Op>
requires (Op != Operation::None)
struct aie::op_result_helper< vector_elem_const_ref< T, Elems >, Op >

Class Members
typedef T	type

aie::op_result_helper< vector_elem_ref< T, Elems >, Op >

struct aie::op_result_helper< vector_elem_ref< T, Elems >, Op >

template<typename T, unsigned Elems, Operation Op>
requires (Op != Operation::None)
struct aie::op_result_helper< vector_elem_ref< T, Elems >, Op >

Class Members
typedef T	type

aie::op_result_helper< vector_ref< T, Elems, Resource >, Op >

struct aie::op_result_helper< vector_ref< T, Elems, Resource >, Op >

template<typename T, unsigned Elems, aie_dm_resource Resource, Operation Op>
requires (Op != Operation::None)
struct aie::op_result_helper< vector_ref< T, Elems, Resource >, Op >

Class Members
typedef vector< T, Elems >	type

aie::op_value_type_helper

struct aie::op_value_type_helper

template<typename T>
struct aie::op_value_type_helper< T >

Class Members
typedef T	type

aie::op_value_type_helper< binary_op< Parent1, Parent2, Op > >

struct aie::op_value_type_helper< binary_op< Parent1, Parent2, Op > >

template<typename Parent1, typename Parent2, Operation Op>
struct aie::op_value_type_helper< binary_op< Parent1, Parent2, Op > >

Class Members
typedef typename value_type	type

aie::op_value_type_helper< mmul< M, K, N, TypeA, TypeB, AccumTag > >

struct aie::op_value_type_helper< mmul< M, K, N, TypeA, TypeB, AccumTag > >

template<unsigned M, unsigned K, unsigned N, ElemBaseType TypeA, ElemBaseType TypeB, AccumElemBaseType AccumTag>
struct aie::op_value_type_helper< mmul< M, K, N, TypeA, TypeB, AccumTag > >

Class Members
typedef typename value_type	type

aie::op_value_type_helper< sparse_vector< T, Elems > >

struct aie::op_value_type_helper< sparse_vector< T, Elems > >

template<typename T, unsigned Elems>
struct aie::op_value_type_helper< sparse_vector< T, Elems > >

Class Members
typedef typename value_type	type

aie::op_value_type_helper< unaligned_vector_ref< T, Elems, Resource > >

struct aie::op_value_type_helper< unaligned_vector_ref< T, Elems, Resource > >

template<typename T, unsigned Elems, aie_dm_resource Resource>
struct aie::op_value_type_helper< unaligned_vector_ref< T, Elems, Resource > >

Class Members
typedef typename value_type	type

aie::op_value_type_helper< unary_op< Parent, Op > >

struct aie::op_value_type_helper< unary_op< Parent, Op > >

template<typename Parent, Operation Op>
struct aie::op_value_type_helper< unary_op< Parent, Op > >

Class Members
typedef typename value_type	type

aie::op_value_type_helper< vector< T, Elems > >

struct aie::op_value_type_helper< vector< T, Elems > >

template<typename T, unsigned Elems>
struct aie::op_value_type_helper< vector< T, Elems > >

Class Members
typedef typename value_type	type

aie::op_value_type_helper< vector_elem_const_ref< T, Elems > >

struct aie::op_value_type_helper< vector_elem_const_ref< T, Elems > >

template<typename T, unsigned Elems>
struct aie::op_value_type_helper< vector_elem_const_ref< T, Elems > >

Class Members
typedef typename value_type	type

aie::op_value_type_helper< vector_elem_ref< T, Elems > >

struct aie::op_value_type_helper< vector_elem_ref< T, Elems > >

template<typename T, unsigned Elems>
struct aie::op_value_type_helper< vector_elem_ref< T, Elems > >

Class Members
typedef typename value_type	type

aie::op_value_type_helper< vector_ref< T, Elems, Resource > >

struct aie::op_value_type_helper< vector_ref< T, Elems, Resource > >

template<typename T, unsigned Elems, aie_dm_resource Resource>
struct aie::op_value_type_helper< vector_ref< T, Elems, Resource > >

Class Members
typedef typename value_type	type

aie::operand_base_type

struct aie::operand_base_type

template<typename T>
struct aie::operand_base_type< T >

Class Members
typedef aie_dm_resource_remove_t< T >	type

aie::operand_base_type< binary_op< Parent1, Parent2, Op > >

struct aie::operand_base_type< binary_op< Parent1, Parent2, Op > >

template<typename Parent1, typename Parent2, Operation Op>
struct aie::operand_base_type< binary_op< Parent1, Parent2, Op > >

Class Members
typedef typename value_type	type

aie::operand_base_type< unary_op< Parent, Op > >

struct aie::operand_base_type< unary_op< Parent, Op > >

template<typename Parent, Operation Op>
struct aie::operand_base_type< unary_op< Parent, Op > >

Class Members
typedef typename value_type	type

aie::operand_base_type< vector_elem_const_ref< T, Elems > >

struct aie::operand_base_type< vector_elem_const_ref< T, Elems > >

template<typename T, unsigned Elems>
struct aie::operand_base_type< vector_elem_const_ref< T, Elems > >

Class Members
typedef T	type

aie::operand_base_type< vector_elem_ref< T, Elems > >

struct aie::operand_base_type< vector_elem_ref< T, Elems > >

template<typename T, unsigned Elems>
struct aie::operand_base_type< vector_elem_ref< T, Elems > >

Class Members
typedef T	type

aie::result_type_helper

struct aie::result_type_helper

template<typename T>
struct aie::result_type_helper< T >

aie::result_type_helper< T >

struct aie::result_type_helper< T >

template<Accum T>
requires is_op_v<T>
struct aie::result_type_helper< T >

Class Members
typedef T	type
typedef T	type
typedef operand_base_type_t< T >	type
typedef typename result_type	type

aie::tile_id

struct aie::tile_id

Identifies a particular tile within the AIE array.

Class Members
uint16_t	col
uint16_t	row

aie::unary_op

struct aie::unary_op

template<typename Parent, Operation Op>
struct aie::unary_op< Parent, Op >

Typedef Documentation

AccumClass

using aie::AccumClass = typedef detail::AccumClass

cfp_accum

template<unsigned MinAccumBits, unsigned Elems>

using aie::cfp_accum = typedef accum<detail::accum_tag_t<AccumClass::CFP, detail::to_native_accum_bits<AccumClass::CFP, MinAccumBits>()>, Elems>

cfr

template<typename T >

using aie::cfr = typedef detail::cfr<T>

cint_accum

template<unsigned MinAccumBits, unsigned Elems>

using aie::cint_accum = typedef accum<detail::accum_tag_t<AccumClass::CInt, detail::to_native_accum_bits<AccumClass::CInt, MinAccumBits>()>, Elems>

const_pattern_iterator

template<typename T , unsigned Steps>

using aie::const_pattern_iterator = typedef pattern_iterator<std::add_const_t<T>, Steps>

const_restrict_vector_iterator

template<typename T , unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none>

using aie::const_restrict_vector_iterator = typedef restrict_vector_iterator<const std::remove_const_t<T>, Elems, Resource>

dim_2d

using aie::dim_2d = typedef detail::dim_2d

dim_3d

using aie::dim_3d = typedef detail::dim_3d

extents

template<size_t... Extents>

using aie::extents = typedef detail::extents<Extents...>

fp_accum

template<unsigned MinAccumBits, unsigned Elems>

using aie::fp_accum = typedef accum<detail::accum_tag_t<AccumClass::FP, detail::to_native_accum_bits<AccumClass::FP, MinAccumBits>()>, Elems>

int_accum

template<unsigned MinAccumBits, unsigned Elems>

using aie::int_accum = typedef accum<detail::accum_tag_t<AccumClass::Int, detail::to_native_accum_bits<AccumClass::Int, MinAccumBits>()>, Elems>

mdspan

template<typename T , size_t... Extents>

using aie::mdspan = typedef detail::basic_mdspan<T, extents<Extents...>, void, detail::accessor_basic<T> >

op_result_type_t

template<typename T , Operation Op>

using aie::op_result_type_t = typedef typename op_result_helper<T, Op>::type

op_value_type_t

template<typename T >

using aie::op_value_type_t = typedef typename op_value_type_helper<aie_dm_resource_remove_t<T> >::type

operand_base_type_t

template<typename T >

using aie::operand_base_type_t = typedef typename operand_base_type<Utils::remove_all_t<T> >::type

restrict_mdspan

template<typename T , size_t... Extents>

using aie::restrict_mdspan = typedef detail::basic_mdspan<T, extents<Extents...>, void, detail::accessor_restrict<T> >

restrict_span

template<typename T , size_t Extents1 = dynamic_extent>

using aie::restrict_span = typedef restrict_span_1d<T, Extents1>

restrict_span_1d

template<typename T , size_t Extents1 = dynamic_extent>

using aie::restrict_span_1d = typedef restrict_mdspan<T, Extents1>

restrict_span_2d

template<typename T , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent>

using aie::restrict_span_2d = typedef restrict_mdspan<T, Extents1, Extents2>

restrict_span_3d

template<typename T , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent>

using aie::restrict_span_3d = typedef restrict_mdspan<T, Extents1, Extents2, Extents3>

restrict_span_4d

template<typename T , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent, size_t Extents4 = dynamic_extent>

using aie::restrict_span_4d = typedef restrict_mdspan<T, Extents1, Extents2, Extents3, Extents4>

restrict_tiled_mdspan

template<typename T , typename TileExtents , size_t... Extents>

using aie::restrict_tiled_mdspan = typedef detail::basic_tiled_mdspan<T, TileExtents, extents<Extents...>, void, detail::accessor_restrict<T> >

restrict_tiled_span

template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent>

using aie::restrict_tiled_span = typedef tiled_span_1d<T, TileExtents, Extents1>

restrict_tiled_span_1d

template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent>

using aie::restrict_tiled_span_1d = typedef tiled_mdspan<T, TileExtents, Extents1>

restrict_tiled_span_2d

template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent>

using aie::restrict_tiled_span_2d = typedef tiled_mdspan<T, TileExtents, Extents1, Extents2>

restrict_tiled_span_3d

template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent>

using aie::restrict_tiled_span_3d = typedef tiled_mdspan<T, TileExtents, Extents1, Extents2, Extents3>

restrict_tiled_span_4d

template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent, size_t Extents4 = dynamic_extent>

using aie::restrict_tiled_span_4d = typedef tiled_mdspan<T, TileExtents, Extents1, Extents2, Extents3, Extents4>

result_type_t

template<typename T >

using aie::result_type_t = typedef typename result_type_helper<T>::type

sliding_window_dim_1d

using aie::sliding_window_dim_1d = typedef detail::sliding_window_dim_1d

sliding_window_dim_2d

using aie::sliding_window_dim_2d = typedef detail::sliding_window_dim_2d

sliding_window_dim_3d

using aie::sliding_window_dim_3d = typedef detail::sliding_window_dim_3d

span

template<typename T , size_t Extents1 = dynamic_extent>

using aie::span = typedef span_1d<T, Extents1>

span_1d

template<typename T , size_t Extents1 = dynamic_extent>

using aie::span_1d = typedef mdspan<T, Extents1>

span_2d

template<typename T , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent>

using aie::span_2d = typedef mdspan<T, Extents1, Extents2>

span_3d

template<typename T , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent>

using aie::span_3d = typedef mdspan<T, Extents1, Extents2, Extents3>

span_4d

template<typename T , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent, size_t Extents4 = dynamic_extent>

using aie::span_4d = typedef mdspan<T, Extents1, Extents2, Extents3, Extents4>

tiled_mdspan

template<typename T , typename TileExtents , size_t... Extents>

using aie::tiled_mdspan = typedef detail::basic_tiled_mdspan<T, TileExtents, extents<Extents...>, void, detail::accessor_basic<T> >

tiled_span

template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent>

using aie::tiled_span = typedef tiled_span_1d<T, TileExtents, Extents1>

tiled_span_1d

template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent>

using aie::tiled_span_1d = typedef tiled_mdspan<T, TileExtents, Extents1>

tiled_span_2d

template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent>

using aie::tiled_span_2d = typedef tiled_mdspan<T, TileExtents, Extents1, Extents2>

tiled_span_3d

template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent>

using aie::tiled_span_3d = typedef tiled_mdspan<T, TileExtents, Extents1, Extents2, Extents3>

tiled_span_4d

template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent, size_t Extents4 = dynamic_extent>

using aie::tiled_span_4d = typedef tiled_mdspan<T, TileExtents, Extents1, Extents2, Extents3, Extents4>

Enumeration Type Documentation

Operation

enum class aie::Operation

strong

Enumerator
None
Acc_Add
Acc_Sub
Abs
Conj
Transpose
Max
Min
Sign
Zero

rounding_mode

enum class aie::rounding_mode : unsigned

strong

Enumerator
floor	Always round towards negative infinity.
ceil	Always round towards positive infinity.
positive_inf	Round to nearest integer, with preference to positive infinity at half-way.
negative_inf	Round to nearest integer, with preference to negative infinity at half-way.
symmetric_inf	Round to nearest integer, with preference away from zero at half-way.
symmetric_zero	Round to nearest integer, with preference towards zero at half-way.
conv_even	Round to nearest integer, with preference to even numbers.
conv_odd	Round to nearest integer, with preference to odd numbers.
symmetric_floor	Always round towards zero.
symmetric_ceil	Always round away from zero.

saturation_mode

enum class aie::saturation_mode : unsigned

strong

Enumerator
none	Allows values to overflow.
truncate	Deprecated: use saturate instead.
saturate	Retain maximum/minimum value on positive/negative overflow. Limits depend on type bit-width and if it has sign.
symmetric	Retain maximum/minimum value on positive/negative overflow (signed types only). Max and min limits have exactly the same absolute value.

Function Documentation

abs() [1/3]

static bfloat16 aie::abs ( bfloat16  a )

inlinestatic

abs() [2/3]

static int4_t aie::abs ( const int4_t &  a )

inlinestatic

abs() [3/3]

static uint4_t aie::abs ( const uint4_t &  a )

inlinestatic

accum()

template<detail::NativeAccumType T>

aie::accum

(

T

)

-> accum< typename detail::native_accum_traits< T >::value_type, detail::native_accum_traits< T >::size >

Template deduction guidelines for aie::accum.

add()

template<typename T >
requires (detail::is_floating_point_v<T>)

T aie::add	(	T	a,
		T	b
	)

add_reduce()

template<Vector Vec>

Vec::value_type aie::add_reduce

(

const Vec &

v

)

add_reduce_v()

template<Vector Vec, Vector... Others>

auto aie::add_reduce_v	(	const Vec &	v,
		const Others &...	others
	)		-> aie_dm_resource_remove_t<Vec>

begin_vectors()

template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType... Types>

constexpr auto aie::begin_vectors ( Types *...  ptrs )

constexpr

cbegin_vectors()

template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType... Types>

constexpr auto aie::cbegin_vectors ( const Types *...  ptrs )

constexpr

concat()

template<TupleLike T>
requires (std::tuple_size_v<T> > 1)

auto aie::concat

(

const T &

t

)

Concatenate the contents of all input vectors/accumulators wrapped in a aie::TupleLike object.

The result is a larger vector/accumulator containing all the input elements combined.

All tuple members must have the exactly same type and size.

This overload is useful when joining the members of tuples returned by interleave operations:

aie::vector<int8, 64> even = ..., odd = ...;
aie::vector<int8, 128> mixed = aie::concat( aie::interleave_zip(even, odd, 1) );

Parameters

t	An object satisfying aie::TupleLike that contains the input vectors.

contains()

template<Elem E, Vector Vec>
requires (is_valid_elem_op_v<E, typename Vec::value_type>)

bool aie::contains	(	E	a,
		const Vec &	v
	)

div()

float aie::div ( float  a, float  b  )

inline

get_rounding()

static rounding_mode aie::get_rounding ( )

inlinestatic

Get the current rounding mode used in accumulator to vector conversions.

get_saturation()

static saturation_mode aie::get_saturation ( )

inlinestatic

Get the current saturation mode.

interleave_butterfly()

template<Vector Vec1, Vector Vec2>
requires (is_same_vector_v<Vec1, Vec2>)

auto aie::interleave_butterfly	(	const Vec1 &	v1,
		const Vec2 &	v2,
		unsigned	chunk_size
	)		-> std::pair<aie_dm_resource_remove_t<Vec1>, aie_dm_resource_remove_t<Vec1>>

interleave_butterfly_half()

template<Vector Vec1, Vector Vec2>
requires (is_same_vector_v<Vec1, Vec2>)

auto aie::interleave_butterfly_half	(	const Vec1 &	v1,
		const Vec2 &	v2,
		unsigned	chunk_size
	)		-> std::pair<aie_dm_resource_remove_t<Vec1>, aie_dm_resource_remove_t<Vec1>>

interleave_crossover()

template<Vector Vec1, Vector Vec2>
requires (is_same_vector_v<Vec1, Vec2>)

auto aie::interleave_crossover	(	const Vec1 &	v1,
		const Vec2 &	v2,
		unsigned	chunk_size
	)		-> std::pair<aie_dm_resource_remove_t<Vec1>, aie_dm_resource_remove_t<Vec1>>

interleave_custom()

template<Vector Vec1, Vector Vec2, typename... Select>
requires (is_same_vector_v<Vec1, Vec2> && sizeof...(Select) == Vec1::size())

auto aie::interleave_custom	(	const Vec1 &	v1,
		const Vec2 &	v2,
		Select...	select
	)		-> std::pair<aie_dm_resource_remove_t<Vec1>, aie_dm_resource_remove_t<Vec1>>

interleave_custom_static()

template<unsigned S0, unsigned S1, unsigned S2, unsigned S3, unsigned S4, unsigned S5, unsigned S6, unsigned S7, unsigned S8, unsigned S9, unsigned S10, unsigned S11, unsigned S12, unsigned S13, unsigned S14, unsigned S15, unsigned S16, unsigned S17, unsigned S18, unsigned S19, unsigned S20, unsigned S21, unsigned S22, unsigned S23, unsigned S24, unsigned S25, unsigned S26, unsigned S27, unsigned S28, unsigned S29, unsigned S30, unsigned S31, Vector Vec1, Vector Vec2>
requires (is_same_vector_v<Vec1, Vec2>)

auto aie::interleave_custom_static	(	const Vec1 &	v1,
		const Vec2 &	v2
	)		-> std::pair<aie_dm_resource_remove_t<Vec1>, aie_dm_resource_remove_t<Vec1>>

is_ct_elem_zero()

template<typename T , Elem E>

constexpr bool aie::is_ct_elem_zero ( E  a )

constexpr

mac()

template<typename TR , typename T1 , typename T2 >
requires (detail::is_floating_point_v<T1> && detail::is_floating_point_v<T2> && std::is_same_v<decltype(mul(a, b)), TR>)

TR aie::mac	(	TR	c,
		T1	a,
		T2	b
	)

make_restrict_tensor_buffer_stream()

template<aie_dm_resource Resource = aie_dm_resource::none, typename T , typename TensorDescriptor >

constexpr auto aie::make_restrict_tensor_buffer_stream ( T *__restrict  base, const TensorDescriptor &  tensor_desc  )

constexpr

make_tensor_buffer_stream() [1/2]

template<aie_dm_resource Resource = aie_dm_resource::none, typename T , typename TensorDescriptor >

constexpr auto aie::make_tensor_buffer_stream ( const T *  base, const TensorDescriptor &  tensor_desc  )

constexpr

make_tensor_buffer_stream() [2/2]

template<aie_dm_resource Resource = aie_dm_resource::none, typename T , typename TensorDescriptor >

constexpr auto aie::make_tensor_buffer_stream ( T *  base, const TensorDescriptor &  tensor_desc  )

constexpr

make_tensor_descriptor()

template<typename T , unsigned Elems, typename... Args>
requires (arch::is(arch::AIE_ML) && (std::is_same_v<Args, tensor_dim> && ...))

constexpr auto aie::make_tensor_descriptor ( Args &&...  args )

constexpr

make_tensor_descriptor_bytes()

template<typename T , unsigned Elems, typename... Args>
requires (arch::is(arch::AIE_ML) && (std::is_same_v<Args, tensor_dim> && ...))

constexpr auto aie::make_tensor_descriptor_bytes ( Args &&...  args )

constexpr

make_tensor_descriptor_from_native()

template<typename T , unsigned Elems, typename... Args>

constexpr auto aie::make_tensor_descriptor_from_native ( Args &&...  args )

constexpr

make_tensor_descriptor_from_native_bytes()

template<typename T , unsigned Elems, typename... Args>

constexpr auto aie::make_tensor_descriptor_from_native_bytes ( Args &&...  args )

constexpr

make_unaligned_vector_input_buffer_stream()

template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>

auto aie::make_unaligned_vector_input_buffer_stream

(

const T *

ptr

)

-> unaligned_vector_input_buffer_stream<T, Elems, Resource>

make_unaligned_vector_output_buffer_stream()

template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>

auto aie::make_unaligned_vector_output_buffer_stream

(

T *

ptr

)

-> unaligned_vector_output_buffer_stream<T, Elems, Resource>

make_vector_input_buffer_stream()

template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>

auto aie::make_vector_input_buffer_stream

(

const T *

ptr

)

-> vector_input_buffer_stream<T, Elems, Resource>

make_vector_output_buffer_stream()

template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T>

auto aie::make_vector_output_buffer_stream

(

T *

ptr

)

-> vector_output_buffer_stream<T, Elems, Resource>

max_cmp()

template<RealVector Vec1, RealVector Vec2>
requires (is_same_vector_v<Vec1, Vec2>)

auto aie::max_cmp	(	const Vec1 &	v1,
		const Vec2 &	v2
	)		-> std::tuple<aie_dm_resource_remove_t<Vec1>, mask<Vec1::size()>>

max_reduce()

template<RealVector Vec>

Vec::value_type aie::max_reduce

(

const Vec &

v

)

min_cmp()

template<RealVector Vec1, RealVector Vec2>
requires (is_same_vector_v<Vec1, Vec2>)

auto aie::min_cmp	(	const Vec1 &	v1,
		const Vec2 &	v2
	)		-> std::tuple<aie_dm_resource_remove_t<Vec1>, mask<Vec1::size()>>

min_reduce()

template<RealVector Vec>

Vec::value_type aie::min_reduce

(

const Vec &

v

)

mmac_fn() [1/2]

template<unsigned M, unsigned K, unsigned N, typename Acc , Vector VecA, Vector VecB>
requires ((Acc::accum_type::size() == M * N) && (VecA::size() == M * K) && (VecB::size() == K * N) && is_valid_mul_op_v<typename VecA::value_type, typename VecB::value_type> && is_mmul_v<Acc>)

auto aie::mmac_fn	(	Acc &	c,
		const VecA &	a,
		const VecB &	b
	)

mmac_fn() [2/2]

template<unsigned M, unsigned K, unsigned N, Accum Acc, Vector VecA, Vector VecB>
requires ((Acc::size() == M * N) && (VecA::size() == M * K) && (VecB::size() == K * N) && is_valid_mul_op_v<typename VecA::value_type, typename VecB::value_type>)

auto aie::mmac_fn	(	const Acc &	c,
		const VecA &	a,
		const VecB &	b
	)

mmul_fn()

template<unsigned M, unsigned K, unsigned N, AccumElemBaseType AccumTag = accauto, Vector VecA, Vector VecB>
requires ((VecA::size() == M * K) && (VecB::size() == K * N) && is_valid_mul_op_v<typename VecA::value_type, typename VecB::value_type>)

auto aie::mmul_fn	(	const VecA &	a,
		const VecB &	b
	)

msc()

template<typename TR , typename T1 , typename T2 >
requires (detail::is_floating_point_v<T1> && detail::is_floating_point_v<T2> && std::is_same_v<decltype(mul(a, b)), TR>)

TR aie::msc	(	TR	c,
		T1	a,
		T2	b
	)

mul()

template<typename T1 , typename T2 >
requires (detail::is_floating_point_v<T1> && detail::is_floating_point_v<T2>)

auto aie::mul	(	T1	a,
		T2	b
	)

mul_reduce() [1/2]

template<AccumElemBaseType AccumTag, Vector Vec>

Vec::value_type aie::mul_reduce

(

const Vec &

v

)

mul_reduce() [2/2]

template<Vector Vec>

constexpr Vec::value_type aie::mul_reduce ( const Vec &  v )

constexpr

operator&()

template<typename T1 , typename T2 >
requires (detail::is_vector_elem_ref_v<T1> || detail::is_vector_elem_ref_v<T2>)

constexpr auto aie::operator& ( T1  v1, T2  v2  )

constexpr

operator+()

template<typename T1 , typename T2 >
requires (detail::is_vector_elem_ref_v<T1> || detail::is_vector_elem_ref_v<T2>)

constexpr auto aie::operator+ ( T1  v1, T2  v2  )

constexpr

operator-()

template<typename T1 , typename T2 >
requires (detail::is_vector_elem_ref_v<T1> || detail::is_vector_elem_ref_v<T2>)

constexpr auto aie::operator- ( T1  v1, T2  v2  )

constexpr

operator<<() [1/2]

template<typename T >
requires (detail::is_vector_elem_ref_v<T>)

constexpr auto aie::operator<< ( T  v, int  n  ) -> typename T::value_type

constexpr

operator<<() [2/2]

template<typename T >
requires (detail::is_vector_elem_ref_v<T>)

constexpr auto aie::operator<< ( T  v, unsigned  n  ) -> typename T::value_type

constexpr

operator>>() [1/2]

template<typename T >
requires (detail::is_vector_elem_ref_v<T>)

constexpr auto aie::operator>> ( T  v, int  n  ) -> typename T::value_type

constexpr

operator>>() [2/2]

template<typename T >
requires (detail::is_vector_elem_ref_v<T>)

constexpr auto aie::operator>> ( T  v, unsigned  n  ) -> typename T::value_type

constexpr

operator^()

template<typename T1 , typename T2 >
requires (detail::is_vector_elem_ref_v<T1> || detail::is_vector_elem_ref_v<T2>)

constexpr auto aie::operator^ ( T1  v1, T2  v2  )

constexpr

operator|()

template<typename T1 , typename T2 >
requires (detail::is_vector_elem_ref_v<T1> || detail::is_vector_elem_ref_v<T2>)

constexpr auto aie::operator| ( T1  v1, T2  v2  )

constexpr

operator~()

template<typename T >
requires (detail::is_vector_elem_ref_v<T>)

constexpr auto aie::operator~ ( T  v )

constexpr

print() [1/2]

template<unsigned N>

void aie::print	(	const aie::mask< N > &	m,
		bool	nl = false,
		const char *	prefix = nullptr
	)

Displays the contents of a mask.

Parameters

[in]	m	The mask.
[in]	nl	Set to true in order to add a newline at the end.
[in]	prefix	Optional text to print before the first element.

print() [2/2]

template<typename C >
requires (Vector<C> || Accum<C>)

void aie::print	(	const C &	c,
		bool	nl = false,
		const char *	prefix = nullptr
	)

Displays the contents of a vector or an accumulator.

Parameters

[in]	c	A vector or an accumulator.
[in]	nl	Set to true to print add newline at the end.
[in]	prefix	Optional text to print before the first element.

print_fixed()

template<typename T , unsigned Elems>
requires (!detail::is_floating_point_v<T>)

void aie::print_fixed	(	const aie::vector< T, Elems > &	v,
		int	scale,
		bool	nl = false,
		const char *	prefix = nullptr
	)

Displays the contents of a vector integers represented as real numbers in fixed point.

Applies a scaling factor to each value before printing, which represents the exponent in a multiplication by a power of two: positive scale values will make the numbers larger while negative values will make the numbers smaller.

Parameters

[in]	v	The vector.
[in]	scale	Power-of-two exponent to apply to each value. Can be positive or negative.
[in]	nl	Set to true to print a newline after the last element.
[in]	prefix	Optional text to print before the first element.

print_matrix()

template<typename Matrix >
requires (Vector<Matrix> || Accum<Matrix>)

void aie::print_matrix	(	const Matrix &	m,
		unsigned	cols,
		const char *	prefix = nullptr
	)

Displays the contents of a vector or accumulator, arranged in a matrix layout.

Parameters

[in]	m	A vector or an accumulator.
[in]	cols	The number of columns in the matrix. Must be an exact divisor of the number of elements in m.
[in]	prefix	Optional text to print before the first element.

reduce_mul() [1/2]

template<AccumElemBaseType AccumTag, Vector Vec>

Vec::value_type aie::reduce_mul

(

const Vec &

v

)

reduce_mul() [2/2]

template<Vector Vec>

constexpr Vec::value_type aie::reduce_mul ( const Vec &  v )

constexpr

set_rounding()

static void aie::set_rounding ( rounding_mode  m )

inlinestatic

Set the rounding mode used in accumulator to vector conversions.

Parameters

m	Rounding mode to be set

set_saturation()

static void aie::set_saturation ( saturation_mode  m )

inlinestatic

Set the saturation mode.

Parameters

m	Saturation mode to be set

sliding_mac() [1/2]

template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))

auto aie::sliding_mac	(	const Acc &	acc,
		const VecCoeff &	coeff,
		const VecData &	data,
		unsigned	data_start
	)

sliding_mac() [2/2]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))

auto aie::sliding_mac	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start
	)

sliding_mac_antisym() [1/5]

template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))

auto aie::sliding_mac_antisym	(	const Acc &	acc,
		const VecCoeff &	coeff,
		const VecData &	data,
		unsigned	data_start
	)

sliding_mac_antisym() [2/5]

template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))

auto aie::sliding_mac_antisym	(	const Acc &	acc,
		const VecCoeff &	coeff,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start
	)

sliding_mac_antisym() [3/5]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))

auto aie::sliding_mac_antisym	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start
	)

sliding_mac_antisym() [4/5]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))

auto aie::sliding_mac_antisym	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	ldata_start,
		unsigned	rdata_start
	)

sliding_mac_antisym() [5/5]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))

auto aie::sliding_mac_antisym	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start
	)

sliding_mac_antisym_uct() [1/2]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))

auto aie::sliding_mac_antisym_uct	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start,
		unsigned	uct_shift
	)

sliding_mac_antisym_uct() [2/2]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))

auto aie::sliding_mac_antisym_uct	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start,
		unsigned	uct_shift
	)

sliding_mac_ch()

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE_ML) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Outputs * Channels))

auto aie::sliding_mac_ch	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start
	)

sliding_mac_sym() [1/5]

template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))

auto aie::sliding_mac_sym	(	const Acc &	acc,
		const VecCoeff &	coeff,
		const VecData &	data,
		unsigned	data_start
	)

sliding_mac_sym() [2/5]

template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))

auto aie::sliding_mac_sym	(	const Acc &	acc,
		const VecCoeff &	coeff,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start
	)

sliding_mac_sym() [3/5]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))

auto aie::sliding_mac_sym	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start
	)

sliding_mac_sym() [4/5]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))

auto aie::sliding_mac_sym	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	ldata_start,
		unsigned	rdata_start
	)

sliding_mac_sym() [5/5]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))

auto aie::sliding_mac_sym	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start
	)

sliding_mac_sym_uct() [1/2]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))

auto aie::sliding_mac_sym_uct	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start,
		unsigned	uct_shift
	)

sliding_mac_sym_uct() [2/2]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (Acc::size() == Lanes))

auto aie::sliding_mac_sym_uct	(	const Acc &	acc,
		const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start,
		unsigned	uct_shift
	)

sliding_mul() [1/2]

template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

auto aie::sliding_mul	(	const VecCoeff &	coeff,
		const VecData &	data,
		unsigned	data_start
	)

sliding_mul() [2/2]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

auto aie::sliding_mul	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start
	)

sliding_mul_antisym() [1/5]

template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

auto aie::sliding_mul_antisym	(	const VecCoeff &	coeff,
		const VecData &	data,
		unsigned	data_start
	)

sliding_mul_antisym() [2/5]

template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, typename VecCoeff , typename VecData >
requires (arch::is(arch::AIE) && VectorOrOp<VecCoeff> && VectorOrOp<VecData> && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

auto aie::sliding_mul_antisym	(	const VecCoeff &	coeff,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start
	)

sliding_mul_antisym() [3/5]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

auto aie::sliding_mul_antisym	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start
	)

sliding_mul_antisym() [4/5]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

auto aie::sliding_mul_antisym	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	ldata_start,
		unsigned	rdata_start
	)

sliding_mul_antisym() [5/5]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

auto aie::sliding_mul_antisym	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start
	)

sliding_mul_antisym_uct() [1/2]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

auto aie::sliding_mul_antisym_uct	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start,
		unsigned	uct_shift
	)

sliding_mul_antisym_uct() [2/2]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

auto aie::sliding_mul_antisym_uct	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start,
		unsigned	uct_shift
	)

sliding_mul_ch()

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE_ML) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

auto aie::sliding_mul_ch	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start
	)

sliding_mul_sym() [1/5]

template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

auto aie::sliding_mul_sym	(	const VecCoeff &	coeff,
		const VecData &	data,
		unsigned	data_start
	)

sliding_mul_sym() [2/5]

template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, typename VecCoeff , typename VecData >
requires (arch::is(arch::AIE) && VectorOrOp<VecCoeff> && VectorOrOp<VecData> && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

auto aie::sliding_mul_sym	(	const VecCoeff &	coeff,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start
	)

sliding_mul_sym() [3/5]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

auto aie::sliding_mul_sym	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start
	)

sliding_mul_sym() [4/5]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

auto aie::sliding_mul_sym	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	ldata_start,
		unsigned	rdata_start
	)

sliding_mul_sym() [5/5]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

auto aie::sliding_mul_sym	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start
	)

sliding_mul_sym_uct() [1/2]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

auto aie::sliding_mul_sym_uct	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	data,
		unsigned	data_start,
		unsigned	uct_shift
	)

sliding_mul_sym_uct() [2/2]

template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (arch::is(arch::AIE) && is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

auto aie::sliding_mul_sym_uct	(	const VecCoeff &	coeff,
		unsigned	coeff_start,
		const VecData &	ldata,
		unsigned	ldata_start,
		const VecData &	rdata,
		unsigned	rdata_start,
		unsigned	uct_shift
	)

sparse_vector()

template<detail::NativeSparseVector T>

aie::sparse_vector

(

T

)

-> sparse_vector< typename detail::native_vector_traits< T >::value_type, detail::native_vector_traits< T >::size >

Template deduction guidelines for aie::sparse_vector.

sub()

template<typename T >
requires (detail::is_floating_point_v<T>)

T aie::sub	(	T	a,
		T	b
	)

swap_rounding()

static rounding_mode aie::swap_rounding ( rounding_mode  m )

inlinestatic

Set the rounding mode used in accumulator to vector conversions and return the previously set mode.

Parameters

m	Rounding mode to be set

swap_saturation()

static saturation_mode aie::swap_saturation ( saturation_mode  m )

inlinestatic

Set the saturation mode and return the previously set mode.

Parameters

m	Saturation mode to be set

tlast() [1/2]

template<typename T >

aie::tlast	(	const T &	,
		bool
	)		-> tlast< const T &, bool >

tlast() [2/2]

template<typename T >

aie::tlast	(	T &	,
		bool &
	)		-> tlast< T &, bool & >

to_float()

template<typename TR = cfloat, typename T , unsigned Elems>
requires (Utils::is_one_of_v<T, cint16, cint32>)

auto aie::to_float	(	const vector< T, Elems > &	v,
		int	shift = 0
	)		-> vector<TR, Elems>

Convert the elements in a complex fixed-point vector into floating point values.

Parameters

v	Input vector.
shift	Position of the point in the input values.

vector()

template<detail::NativeVectorType T>

aie::vector

(

T

)

-> vector< typename detail::native_vector_traits< T >::value_type, detail::native_vector_traits< T >::size >

Template deduction guidelines for aie::vector.

vector_cast()

template<AccumElemBaseType DstTag, Vector Vec>
requires (arch::is(arch::AIE_ML))

auto aie::vector_cast

(

const Vec &

v

)

Reinterpret a vector as an accumulator.

The returned accumulator has the same size in bits as the input vector.

Template Parameters

DstTag

Accumulator tag for the returned accumulator.

Parameters

v	Input vector.

zero()

template<ElemBaseType T>

constexpr T aie::zero ( )

constexpr

Returns the zero value for the requested data type.

Template Parameters

Requested

data type

zeros()

template<AccumElemBaseType AccumTag, unsigned Elems = native_vector_length_v<AccumTag>>

accum< AccumTag, Elems > aie::zeros

(

)

Returns a vector whose elements are initialized to zero.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = 0;

Template Parameters

AccumTag.	Accumulator tag.
Elems.	Size of the accumulator.

Variable Documentation

dynamic_extent

constexpr size_t aie::dynamic_extent = std::numeric_limits<size_t>::max()

inlineconstexpr

is_accum_op_v

template<typename T >

constexpr bool aie::is_accum_op_v = is_accum_op<T>::value

staticconstexpr

is_binary_op_v

template<typename T >

constexpr bool aie::is_binary_op_v = is_binary_op<T>::value

staticconstexpr

is_complex_op_v

template<typename T >

constexpr bool aie::is_complex_op_v = is_complex_op<T>::value

staticconstexpr

is_elem_op_v

template<typename T >

constexpr bool aie::is_elem_op_v = is_elem_op<T>::value

staticconstexpr

is_lut_v

template<typename T >

constexpr bool aie::is_lut_v = is_lut<T>::value()

staticconstexpr

is_mmul_or_op_v

template<typename T >

constexpr bool aie::is_mmul_or_op_v

staticconstexpr

Initial value:

=  is_mmul_v<aie_dm_resource_remove_t<T>> ||
                                         is_op_v<T>

is_mmul_v

template<typename T >

constexpr bool aie::is_mmul_v = is_mmul<T>::value

staticconstexpr

is_op_v

template<typename T >

constexpr bool aie::is_op_v = is_unary_op_v<T> || is_binary_op_v<T>

staticconstexpr

is_real_op_v

template<typename T >

constexpr bool aie::is_real_op_v = is_real_op<T>::value

staticconstexpr

is_same_accum_v

template<Accum Acc1, Accum Acc2>

constexpr bool aie::is_same_accum_v = std::is_same_v<aie_dm_resource_remove_t<Acc1>, aie_dm_resource_remove_t<Acc2>>

staticconstexpr

is_same_vector_v

template<Vector Vec1, Vector Vec2>

constexpr bool aie::is_same_vector_v = is_same_vector<aie_dm_resource_remove_t<Vec1>, aie_dm_resource_remove_t<Vec2>>::value

staticconstexpr

is_sparse_vector_op_v

template<typename T >

constexpr bool aie::is_sparse_vector_op_v = is_sparse_vector_op<T>::value

staticconstexpr

is_unary_op_v

template<typename T >

constexpr bool aie::is_unary_op_v = is_unary_op<T>::value

staticconstexpr

is_valid_elem_op_v

template<typename T1 , typename T2 >

constexpr bool aie::is_valid_elem_op_v = is_valid_elem_op<T1, T2>::value

staticconstexpr

is_valid_mul_op_v

template<typename T , typename T2 >

constexpr bool aie::is_valid_mul_op_v = is_valid_mul_op<T, T2>::value()

staticconstexpr

is_valid_size_v

template<typename T , typename T2 , typename... Other>

constexpr bool aie::is_valid_size_v = is_valid_size<T, T2, Other...>::value

staticconstexpr

is_vector_op_v

template<typename T >

constexpr bool aie::is_vector_op_v = is_vector_op<T>::value

staticconstexpr

max_shift

constexpr int aie::max_shift = detail::max_shift

staticconstexpr

min_shift

constexpr int aie::min_shift = detail::min_shift

staticconstexpr

native_vector_length_v

template<typename T >

constexpr unsigned aie::native_vector_length_v = detail::native_vector_length_v<T>

staticconstexpr