aie::detail Namespace Reference

Namespaces
namespace	adf
namespace	sync
namespace	utils

Classes
struct	abs_bits
struct	abs_bits_impl
struct	abs_square_bits
struct	abs_square_bits_impl
struct	accessor_basic
struct	accessor_restrict
struct	accum_bits_for_tag
struct	accum_bits_for_tag< acc16 >
struct	accum_bits_for_tag< acc24 >
struct	accum_bits_for_tag< acc32 >
struct	accum_bits_for_tag< acc40 >
struct	accum_bits_for_tag< acc48 >
struct	accum_bits_for_tag< acc56 >
struct	accum_bits_for_tag< acc64 >
struct	accum_bits_for_tag< accfloat >
struct	accum_bits_for_tag< cacc16 >
struct	accum_bits_for_tag< cacc24 >
struct	accum_bits_for_tag< cacc32 >
struct	accum_bits_for_tag< cacc40 >
struct	accum_bits_for_tag< cacc48 >
struct	accum_bits_for_tag< cacc56 >
struct	accum_bits_for_tag< cacc64 >
struct	accum_class_for_mul_types
struct	accum_class_for_tag
struct	accum_class_for_tag< acc16 >
struct	accum_class_for_tag< acc24 >
struct	accum_class_for_tag< acc32 >
struct	accum_class_for_tag< acc40 >
struct	accum_class_for_tag< acc48 >
struct	accum_class_for_tag< acc56 >
struct	accum_class_for_tag< acc64 >
struct	accum_class_for_tag< accfloat >
struct	accum_class_for_tag< cacc16 >
struct	accum_class_for_tag< cacc24 >
struct	accum_class_for_tag< cacc32 >
struct	accum_class_for_tag< cacc40 >
struct	accum_class_for_tag< cacc48 >
struct	accum_class_for_tag< cacc56 >
struct	accum_class_for_tag< cacc64 >
struct	accum_class_for_type
struct	accum_native_type
struct	accum_tag
struct	accum_tag< AccumClass::CInt, 16 >
struct	accum_tag< AccumClass::CInt, 24 >
struct	accum_tag< AccumClass::CInt, 32 >
struct	accum_tag< AccumClass::CInt, 40 >
struct	accum_tag< AccumClass::CInt, 48 >
struct	accum_tag< AccumClass::CInt, 56 >
struct	accum_tag< AccumClass::CInt, 64 >
struct	accum_tag< AccumClass::FP, 32 >
struct	accum_tag< AccumClass::Int, 16 >
struct	accum_tag< AccumClass::Int, 24 >
struct	accum_tag< AccumClass::Int, 32 >
struct	accum_tag< AccumClass::Int, 40 >
struct	accum_tag< AccumClass::Int, 48 >
struct	accum_tag< AccumClass::Int, 56 >
struct	accum_tag< AccumClass::Int, 64 >
struct	accum_tag_or_default
struct	accum_to_vector_cast_bits
struct	accum_to_vector_cast_bits_impl
struct	accumulator
struct	add_memory_bank
struct	add_memory_bank< aie_dm_resource::a, T >
struct	add_memory_bank< aie_dm_resource::b, T >
struct	add_memory_bank< aie_dm_resource::c, T >
struct	add_memory_bank< aie_dm_resource::d, T >
struct	add_memory_bank< aie_dm_resource::stack, T >
struct	add_reduce_bits
struct	add_reduce_bits_impl
struct	add_reduce_v_bits
struct	add_reduce_v_bits_impl
struct	add_sub_accum_bits
struct	add_sub_accum_bits_impl
struct	add_sub_accum_vector_bits
struct	add_sub_accum_vector_bits_impl
struct	add_sub_bits
struct	add_sub_bits_impl
struct	adopt_lock_t
class	basic_mdspan
class	basic_mdspan< T, extents< Extents... >, LayoutPolicy, AccessorPolicy >
class	basic_tiled_mdspan
class	basic_tiled_mdspan< T, extents< TileExtents... >, extents< Extents... >, LayoutPolicy, AccessorPolicy >
struct	bit_bits
struct	bit_bits_impl
struct	broadcast_bits
struct	broadcast_bits_impl
struct	C_block
struct	C_block< TypeA, TypeB, AccumBits, Elems, 1 >
struct	C_block< TypeA, TypeB, AccumBits, Elems, 2 >
struct	C_block_larger_internal
struct	cfr
class	circular_iterator
struct	cmp_bits_impl
struct	cmp_impl
struct	compute_C_type
struct	compute_C_type< int8, int8 >
struct	compute_C_type< int8, uint8 >
struct	compute_C_type< uint8, int8 >
struct	compute_C_type< uint8, uint8 >
struct	compute_rank
struct	concat_accum_helper
struct	concat_vector_helper
struct	conj_bits
struct	conj_bits_impl
class	const_iterator
class	const_tile_iterator
struct	consume_terms
class	consumer_sem
struct	contains
struct	deduce_accauto_helper
struct	deduce_accauto_helper< Tag >
struct	deduce_accauto_helper< Tag1, Tag2 >
struct	default_accum_tag
struct	default_accum_tag_helper
struct	default_accum_tag_helper< 32, false >
struct	default_accum_tag_helper< 48 >
struct	default_accum_tag_helper< 64 >
struct	default_repr
struct	default_repr< 0 >
struct	default_repr< 1 >
struct	default_repr< 2 >
struct	default_twiddle_type
struct	dim_2d
struct	dim_3d
struct	elementary_bits
struct	elementary_bits_impl
struct	elementary_vector_bits
struct	elementary_vector_bits_impl
struct	equal
struct	equal_bits_impl
struct	fft_dit
struct	fft_dit_common
struct	fft_dit_stage
struct	filter_bits
struct	filter_bits_impl
struct	get_value_type
struct	get_value_type< vector< T, Elems > >
struct	interleave_bits_butterfly
struct	interleave_bits_butterfly_half
struct	interleave_bits_crossover
struct	interleave_bits_custom
struct	interleave_bits_custom_static
struct	interleave_bits_unzip
struct	interleave_bits_zip
struct	is_accum
struct	is_accum< accum< Tag, Elems > >
struct	is_complex
struct	is_floating_point
struct	is_integral
struct	is_mask
struct	is_mask<::aie::mask< Elems > >
struct	is_signed
struct	is_sparse_vector
struct	is_sparse_vector< sparse_vector< T, Elems > >
struct	is_tlast
struct	is_tlast< tlast< T, Bool > >
struct	is_tlast_type
struct	is_tlast_type< tlast< const vector< T, N > &, Bool >, T2 >
struct	is_tlast_type< tlast< T, Bool >, T2 >
struct	is_tlast_type< tlast< vector< T, N > &, Bool >, T2 >
struct	is_unsigned
struct	is_valid_accum_type
struct	is_valid_element_type
struct	is_valid_fft_op
struct	is_vector
struct	is_vector< vector< T, Elems > >
struct	is_vector_elem_ref
struct	is_vector_elem_ref< vector_elem_const_ref< T, Elems > >
struct	is_vector_elem_ref< vector_elem_ref< T, Elems > >
struct	is_vector_ref
struct	is_vector_ref< unaligned_vector_ref< T, Elems, Resource > >
struct	is_vector_ref< vector_ref< T, Elems, Resource > >
struct	iter_state
class	iterator
struct	iterator_stride
struct	iterator_stride< dynamic_extent >
struct	linear_approx
struct	load_unaligned_vector_helper
struct	load_vector_helper
struct	lut
struct	lut< 1, OffsetType, SlopeType >
struct	lut< 2, OffsetType, SlopeType >
struct	lut< 4, OffsetType, SlopeType >
struct	max_min_bits
struct	max_min_bits_impl
struct	max_min_bits_reduce_impl
struct	max_min_cmp_bits
struct	max_min_cmp_bits_impl
struct	max_min_reduce_bits
struct	mmul
struct	mul_bits
struct	mul_bits_impl
struct	mul_maxmin_bits
struct	mul_maxmin_bits_impl
struct	mul_reduce_bits
struct	mul_reduce_bits_impl
struct	native_vector_length
struct	native_vector_traits
struct	native_vector_type
struct	neg_bits
struct	neg_bits_impl
struct	not_equal
struct	parallel_lookup
class	pattern_iterator
class	producer_sem
class	random_circular_iterator
struct	random_circular_iterator_storage_dynamic
struct	random_circular_iterator_storage_static
class	restrict_tensor_buffer_stream
class	restrict_vector_iterator
struct	reverse
struct	reverse_impl
struct	schedule_1
struct	schedule_2
class	scoped_lock_impl
struct	select_bits
struct	select_bits_impl
struct	shift_bits
struct	shift_bits_impl
struct	shuffle_down_bits
struct	shuffle_down_bits_impl
struct	shuffle_down_bits_impl_scalar
struct	shuffle_down_fill_bits
struct	shuffle_down_fill_bits_impl
struct	shuffle_down_fill_bits_impl_scalar
struct	shuffle_down_replicate_bits
struct	shuffle_down_replicate_bits_impl
struct	shuffle_down_replicate_bits_impl_scalar
struct	shuffle_down_rotate_bits
struct	shuffle_down_rotate_bits_impl
struct	shuffle_down_rotate_bits_impl_scalar
struct	shuffle_up_bits
struct	shuffle_up_bits_impl
struct	shuffle_up_bits_impl_scalar
struct	shuffle_up_fill_bits
struct	shuffle_up_fill_bits_impl
struct	shuffle_up_fill_bits_impl_scalar
struct	shuffle_up_replicate_bits
struct	shuffle_up_replicate_bits_impl
struct	shuffle_up_replicate_bits_impl_scalar
struct	shuffle_up_rotate_bits
struct	shuffle_up_rotate_bits_impl
struct	shuffle_up_rotate_bits_impl_scalar
struct	sliding_mul_bits
struct	sliding_mul_bits_impl
struct	sliding_mul_ch_bits
struct	sliding_mul_ch_bits_impl
struct	sliding_mul_sym_bits
struct	sliding_mul_sym_bits_impl
struct	sliding_mul_sym_uct_bits
struct	sliding_mul_sym_uct_bits_impl
class	sliding_window_buffer_stream
struct	sliding_window_dim_1d
struct	sliding_window_dim_2d
struct	sliding_window_dim_3d
struct	span_extents
struct	span_extents< true, extents< Extents... > >
struct	span_extents_common
struct	span_extents_common< extents< Extents... > >
struct	span_indexer
class	sparse_vector
class	sparse_vector_input_buffer_stream
struct	square_bits
struct	square_bits_impl
struct	store_unaligned_vector_helper
struct	store_vector_helper
class	tensor_buffer_stream
struct	tile_id
class	tile_iterator
struct	tiled_span_extents
struct	tiled_span_extents< false, extents< TileExtents... >, Extents >
struct	tiled_span_extents< true, extents< TileExtents... >, extents< Extents... > >
struct	tiled_span_extents_common
struct	tiled_span_extents_common< extents< TileExtents... >, extents< Extents... > >
struct	tiled_span_indexer
struct	transpose_bits
struct	transpose_bits_impl
struct	transpose_bits_scalar
struct	type_bits
class	unaligned_vector_input_buffer_stream
class	unaligned_vector_iterator
class	unaligned_vector_output_buffer_stream
class	unaligned_vector_ref
class	vector_circular_iterator
class	vector_input_buffer_stream
class	vector_iterator
struct	vector_ldst_align
class	vector_output_buffer_stream
class	vector_random_circular_iterator
class	vector_ref
struct	vector_storage
struct	vector_to_accum_cast_bits
struct	vector_to_accum_cast_bits_impl
struct	zeros_acc_bits
struct	zeros_acc_bits_impl
struct	zeros_bits
struct	zeros_type_for_accum
struct	zeros_type_for_accum< AccumClass::CInt >
struct	zeros_type_for_accum< AccumClass::Int >

Typedefs
template<typename T , unsigned Elems>
using	abs = abs_bits< type_bits_v< T >, T, Elems >
template<typename T , typename TR , unsigned Elems>
using	abs_square = abs_square_bits< T, TR, Elems >
template<typename T >
using	accum_native_type_t = typename accum_native_type< T >::type
template<typename T1 , typename T2 , unsigned Bits = default_accum_bits<T1, T2>()>
using	accum_tag_for_mul_types = accum_tag_t< accum_class_for_mul_types_v< T1, T2 >, Bits >
template<typename T , unsigned Bits = default_accum_bits<T, T>()>
using	accum_tag_for_type = accum_tag_t< accum_class_for_type< T >::value(), Bits >
template<typename AccumTag , typename ... Tags>
using	accum_tag_or_default_t = typename accum_tag_or_default< AccumTag, Tags... >::type
template<AccumClass Class, unsigned Bits>
using	accum_tag_t = typename accum_tag< Class, Bits >::type
template<typename DstT , typename Tag , unsigned Elems>
using	accum_to_vector_cast = accum_to_vector_cast_bits< DstT, accum_class_for_tag_v< Tag >, accum_bits_for_tag_v< Tag >, Elems >
template<typename T , unsigned Elems>
using	add = add_sub_bits< type_bits_v< T >, T, Elems, AddSubOperation::Add >
template<AccumElemBaseType AccumTag, unsigned Elems>
using	add_accum = add_sub_accum_bits< accum_native_type_t< AccumTag >, Elems, AddSubOperation::Add >
template<unsigned AccumBits, typename T , unsigned Elems>
using	add_accum_vector = add_sub_accum_vector_bits< AccumBits, type_bits_v< T >, T, Elems, AddSubOperation::Add >
template<aie_dm_resource Resource, typename T >
using	add_memory_bank_t = typename add_memory_bank< Resource, T >::type
template<typename T , unsigned Elems>
using	add_reduce = add_reduce_bits< type_bits_v< T >, T, Elems >
template<typename T , unsigned Elems>
using	add_reduce_v = add_reduce_v_bits< type_bits_v< T >, T, Elems >
template<typename T , unsigned Elems, BitOp Op>
using	bit = bit_bits< type_bits_v< T >, T, Elems, Op >
template<typename T , unsigned Elems>
using	broadcast = broadcast_bits< type_bits_v< T >, T, Elems >
template<typename TypeA , typename TypeB >
using	compute_C_type_t = typename compute_C_type< TypeA, TypeB >::type
template<typename T , unsigned Elems>
using	conj = conj_bits< type_bits_v< T >, T, Elems >
template<typename T , size_t Elems, size_t Stride = 1, aie_dm_resource Resource = aie_dm_resource::none>
using	const_circular_iterator = circular_iterator< const T, Elems, Stride, Resource >
template<typename T , unsigned Steps>
using	const_pattern_iterator = pattern_iterator< const std::remove_const_t< T >, Steps >
template<typename T , size_t Elems, size_t Stride = 1, aie_dm_resource Resource = aie_dm_resource::none>
using	const_random_circular_iterator = random_circular_iterator< const T, Elems, Stride, Resource >
template<typename T , unsigned Elems, size_t Stride = 1, aie_dm_resource Resource = aie_dm_resource::none>
using	const_restrict_vector_iterator = restrict_vector_iterator< const std::remove_const_t< T >, Elems, Stride, Resource >
template<typename T , unsigned Elems, typename IterDescriptor , aie_dm_resource Resource = aie_dm_resource::none>
using	const_sliding_window_buffer_stream = sliding_window_buffer_stream< const std::remove_const_t< T >, Elems, IterDescriptor, 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 >
template<typename T , unsigned N, size_t Elems, size_t Stride = 1, aie_dm_resource Resource = aie_dm_resource::none>
using	const_vector_circular_iterator = vector_circular_iterator< const T, N, Elems, Stride, Resource >
template<typename T , unsigned Elems, size_t Stride = 1, aie_dm_resource Resource = aie_dm_resource::none>
using	const_vector_iterator = vector_iterator< const std::remove_const_t< T >, Elems, Stride, Resource >
template<typename T , unsigned N, size_t Elems, size_t Stride = 1, aie_dm_resource Resource = aie_dm_resource::none>
using	const_vector_random_circular_iterator = vector_random_circular_iterator< const T, N, Elems, Stride, Resource >
template<unsigned NumReaders, unsigned NumWriters>
using	consumer_lock = scoped_lock_impl< consumer_sem< NumReaders, NumWriters > >
template<typename ... Tags>
using	deduce_accauto_helper_t = typename deduce_accauto_helper< Tags... >::type
template<typename A , typename B >
using	default_accum_tag_t = typename default_accum_tag< A, B >::type
template<unsigned N>
using	default_repr_t = typename default_repr< N >::type
template<typename Input , typename Output = Input>
using	default_twiddle_type_t = typename default_twiddle_type< Input, Output >::type
template<size_t Rank>
using	dyn_extents = std::array< size_t, Rank >
template<ElementaryOp Op, typename TR , typename T >
using	elementary = elementary_bits< Op, type_bits_v< T >, TR, T >
template<ElementaryOp Op, typename TR , typename T , unsigned N>
using	elementary_vector = elementary_vector_bits< Op, type_bits_v< T >, TR, T, N >
template<typename T , unsigned Elems>
using	eq = cmp_impl< CmpOp::EQ, T, Elems >
template<size_t... Extents>
using	extents = std::integer_sequence< size_t, Extents... >
template<typename T , unsigned Elems, FilterOp Op>
using	filter = filter_bits< type_bits_v< T >, T, Elems, Op >
template<typename T , unsigned Elems>
using	ge = cmp_impl< CmpOp::GE, T, Elems >
template<typename T >
using	get_value_type_t = typename get_value_type< T >::type
template<typename T , unsigned Elems>
using	interleave_butterfly = interleave_bits_butterfly< type_bits_v< T >, T, Elems >
template<typename T , unsigned Elems>
using	interleave_butterfly_half = interleave_bits_butterfly_half< type_bits_v< T >, T, Elems >
template<typename T , unsigned Elems>
using	interleave_crossover = interleave_bits_crossover< type_bits_v< T >, T, Elems >
template<typename T , unsigned Elems, unsigned... Select>
using	interleave_custom = interleave_bits_custom< type_bits_v< T >, T, Elems >
template<typename T , unsigned Elems, unsigned... Select>
using	interleave_custom_static = interleave_bits_custom_static< type_bits_v< T >, T, Elems, Select... >
template<typename T , unsigned Elems>
using	interleave_unzip = interleave_bits_unzip< type_bits_v< T >, T, Elems >
template<typename T , unsigned Elems>
using	interleave_zip = interleave_bits_zip< type_bits_v< T >, T, Elems >
template<typename T , unsigned Elems>
using	lt = cmp_impl< CmpOp::LT, T, Elems >
template<size_t Rank>
using	make_dynamic_extents = utils::make_integer_broadcast< size_t, Rank, dynamic_extent >
template<typename T , unsigned Elems>
using	max = max_min_bits< type_bits_v< T >, T, Elems, MaxMinOperation::Max >
template<typename T , unsigned Elems>
using	max_cmp = max_min_cmp_bits< type_bits_v< T >, T, Elems, MaxMinOperation::MaxCmp >
template<typename T , unsigned Elems>
using	max_reduce = max_min_reduce_bits< type_bits_v< T >, T, Elems, MaxMinOperation::Max >
template<typename T , unsigned Elems>
using	maxdiff = max_min_bits< type_bits_v< T >, T, Elems, MaxMinOperation::MaxDiff >
template<typename T , unsigned Elems>
using	min = max_min_bits< type_bits_v< T >, T, Elems, MaxMinOperation::Min >
template<typename T , unsigned Elems>
using	min_cmp = max_min_cmp_bits< type_bits_v< T >, T, Elems, MaxMinOperation::MinCmp >
template<typename T , unsigned Elems>
using	min_reduce = max_min_reduce_bits< type_bits_v< T >, T, Elems, MaxMinOperation::Min >
template<MulMacroOp MulOp, unsigned AccumBits, typename T1 , typename T2 >
using	mul = mul_bits< MulOp, AccumBits, type_bits_v< T1 >, T1, type_bits_v< T2 >, T2 >
template<MulMacroOp MulOp, unsigned AccumBits, typename T1 , typename T2 >
using	mul_maxmin = mul_maxmin_bits< MulOp, AccumBits, type_bits_v< T1 >, T1, type_bits_v< T2 >, T2 >
template<unsigned AccumBits, typename T , unsigned Elems>
using	mul_reduce = mul_reduce_bits< AccumBits, type_bits_v< T >, T, Elems >
template<typename T , unsigned Elems>
using	native_vector_type_t = typename native_vector_type< T, Elems >::type
template<typename T , unsigned Elems>
using	neg = neg_bits< type_bits_v< T >, T, Elems >
template<typename T , unsigned Elems>
using	neq = cmp_impl< CmpOp::NEQ, T, Elems >
template<unsigned NumReaders, unsigned NumWriters>
using	producer_lock = scoped_lock_impl< producer_sem< NumReaders, NumWriters > >
using	scoped_lock = scoped_lock_impl< mutex >
template<typename T , unsigned Elems>
using	select = select_bits< type_bits_v< T >, T, Elems >
template<typename T , unsigned Elems>
using	shift = shift_bits< T, type_bits_v< T >, Elems >
template<typename T , unsigned Elems>
using	shuffle_down = shuffle_down_bits< type_bits_v< T >, T, Elems >
template<typename T , unsigned Elems>
using	shuffle_down_fill = shuffle_down_fill_bits< type_bits_v< T >, T, Elems >
template<typename T , unsigned Elems>
using	shuffle_down_replicate = shuffle_down_replicate_bits< type_bits_v< T >, T, Elems >
template<typename T , unsigned Elems>
using	shuffle_down_rotate = shuffle_down_rotate_bits< type_bits_v< T >, T, Elems >
template<typename T , unsigned Elems>
using	shuffle_up = shuffle_up_bits< type_bits_v< T >, T, Elems >
template<typename T , unsigned Elems>
using	shuffle_up_fill = shuffle_up_fill_bits< type_bits_v< T >, T, Elems >
template<typename T , unsigned Elems>
using	shuffle_up_replicate = shuffle_up_replicate_bits< type_bits_v< T >, T, Elems >
template<typename T , unsigned Elems>
using	shuffle_up_rotate = shuffle_up_rotate_bits< type_bits_v< T >, T, Elems >
template<unsigned OutElems, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, unsigned AccumBits, typename CoeffType , typename DataType >
using	sliding_mul = sliding_mul_bits< OutElems, Points, CoeffStep, DataStepX, DataStepY, AccumBits, type_bits_v< CoeffType >, type_bits_v< DataType >, CoeffType, DataType >
template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, unsigned AccumBits, typename CoeffType , typename DataType >
using	sliding_mul_ch = sliding_mul_ch_bits< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, AccumBits, type_bits_v< CoeffType >, type_bits_v< DataType >, CoeffType, DataType >
template<unsigned OutElems, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, unsigned AccumBits, typename CoeffType , typename DataType >
using	sliding_mul_sym = sliding_mul_sym_bits< OutElems, Points, CoeffStep, DataStepX, DataStepY, AccumBits, type_bits_v< CoeffType >, type_bits_v< DataType >, CoeffType, DataType >
template<unsigned OutElems, unsigned Points, int CoeffStep, int DataStep, unsigned AccumBits, typename CoeffType , typename DataType >
using	sliding_mul_sym_uct = sliding_mul_sym_uct_bits< OutElems, Points, CoeffStep, DataStep, AccumBits, type_bits_v< CoeffType >, type_bits_v< DataType >, CoeffType, DataType >
template<MulMacroOp MulOp, unsigned AccumBits, typename T >
using	square = square_bits< MulOp, AccumBits, type_bits_v< T >, T >
template<typename T , unsigned Elems>
using	sub = add_sub_bits< type_bits_v< T >, T, Elems, AddSubOperation::Sub >
template<AccumElemBaseType AccumTag, unsigned Elems>
using	sub_accum = add_sub_accum_bits< accum_native_type_t< AccumTag >, Elems, AddSubOperation::Sub >
template<unsigned AccumBits, typename T , unsigned Elems>
using	sub_accum_vector = add_sub_accum_vector_bits< AccumBits, type_bits_v< T >, T, Elems, AddSubOperation::Sub >
template<typename T , unsigned Elems>
using	transpose = transpose_bits< type_bits_v< T >, T, Elems >
template<typename T , unsigned Elems>
using	vector_storage_t = typename vector_storage< T, Elems >::type
template<typename DstTag , typename T , unsigned Elems>
using	vector_to_accum_cast = vector_to_accum_cast_bits< DstTag, T, Elems >
template<typename T , unsigned Elems>
using	zeros = zeros_bits< type_bits_v< T >, T, Elems >
template<AccumClass Class, unsigned AccumBits, unsigned Elems>
using	zeros_acc = zeros_acc_bits< Class, AccumBits, Elems >
template<AccumClass Class>
using	zeros_type_for_accum_t = typename zeros_type_for_accum< Class >::type

Enumerations
enum class	AccumClass { Int , CInt , FP , CFP }
enum class	AddSubOperation { Add , Sub }
enum class	BitOp { And , Not , Or , Xor }
enum class	CmpOp { LT , GE , EQ , NEQ }
enum class	ElementaryOp {   Sqrt , Inv , InvSqrt , SinCos ,   SinCosComplex , Sin , Cos , Fix2Float ,   Float2Fix , Tanh , Exp2 }
enum class	FifoDirection { In , Out }
enum class	FilterOp { Odd , Even }
enum class	lut_oor_policy { saturate , truncate }
enum class	MaxMinOperation {   Max , Min , MaxCmp , MinCmp ,   MaxDiff }
enum class	MulMacroOp {   Unavailable = -1 , Mul = 0 , NegMul , Add_Mul ,   Add_NegMul , Sub_Mul = Add_NegMul }
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 }
enum class	saturation_mode : unsigned { none = 0 , truncate = 1 , saturate = 1 , symmetric = 3 }

Functions
template<typename DstTag , typename Acc >
auto	accum_cast (const Acc &acc)
template<MulMacroOp Op>
constexpr MulMacroOp	add_to_op ()
template<typename T >
constexpr bool	check_alignment (const T *ptr, unsigned aligned_elems)
template<unsigned Elems, typename T >
constexpr bool	check_vector_alignment (const T *ptr)
template<typename Accum , typename... Accums>
auto	concat_accum (const Accum &acc, const Accum &acc2, const Accums &...accums)
template<typename... Vectors>
auto	concat_vector (Vectors &&...vectors)
template<typename T >
constexpr Operation	evaluate_mul_operation ()
template<typename T >
constexpr bool	get_mul_sign (T v)
template<Accum Acc> requires (!Acc::is_floating_point())
auto	get_sub_accum (const Acc &acc, unsigned i)
template<MulMacroOp Op>
constexpr bool	has_abs ()
template<MulMacroOp Op>
constexpr bool	has_conj1 ()
template<MulMacroOp Op>
constexpr bool	has_conj2 ()
template<typename T , unsigned Elems>
constexpr unsigned	largest_valid_vector_size ()
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T >
auto	load_unaligned_vector (const T *ptr, unsigned aligned_elems=1)
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T >
auto	load_vector (const T *ptr)
template<typename Fn , typename... MutexTypes>
void	locked (Fn fn, MutexTypes &...mutexes)
template<typename T , unsigned Elems, aie_dm_resource Resource, aie_dm_resource ResourceIn>
constexpr unaligned_vector_output_buffer_stream< T, Elems, Resource > &	operator<< (unaligned_vector_output_buffer_stream< T, Elems, Resource > &out, unaligned_vector_input_buffer_stream< T, Elems, ResourceIn > &in)
template<typename T , unsigned Elems, aie_dm_resource Resource, aie_dm_resource ResourceIn>
constexpr unaligned_vector_output_buffer_stream< T, Elems, Resource > &	operator<< (unaligned_vector_output_buffer_stream< T, Elems, Resource > &out, vector_input_buffer_stream< T, Elems, ResourceIn > &in)
template<typename T , unsigned Elems, aie_dm_resource Resource, aie_dm_resource ResourceIn>
constexpr vector_output_buffer_stream< T, Elems, Resource > &	operator<< (vector_output_buffer_stream< T, Elems, Resource > &out, unaligned_vector_input_buffer_stream< T, Elems, ResourceIn > &in)
template<typename T , unsigned Elems, aie_dm_resource Resource, aie_dm_resource ResourceIn>
constexpr vector_output_buffer_stream< T, Elems, Resource > &	operator<< (vector_output_buffer_stream< T, Elems, Resource > &out, vector_input_buffer_stream< T, Elems, ResourceIn > &in)
template<RegularAcc Acc> requires (Acc::is_floating_point())
void	print_elem (const Acc &acc, unsigned i)
template<RegularAcc Acc> requires (!Acc::is_floating_point() && !Acc::is_complex())
void	print_elem (const Acc &acc, unsigned i)
template<RegularAcc Acc> requires (!Acc::is_floating_point() && Acc::is_complex())
void	print_elem (const Acc &acc, unsigned i)
template<OverlappingAcc Acc> requires (Acc::is_complex())
void	print_elem (const Acc &acc, unsigned i)
template<OverlappingAcc Acc> requires (!Acc::is_complex())
void	print_elem (const Acc &acc, unsigned i, const char *prefix="", const char *suffix=" ")
template<typename T , unsigned Elems>
void	print_elem (const vector< T, Elems > &v, unsigned i)
template<RegularAcc Acc, unsigned memory_bits> requires (!Acc::is_floating_point())
void	print_int_component (const char *acc_ptr, const char *prefix="", const char *suffix="")
template<typename T >
void	print_value (const T &e, int scale=0)
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T1 , typename T2 >
T1 *	store_unaligned_vector (T1 *ptr, const vector< T2, Elems > &v, unsigned aligned_elems=1)
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T1 , typename T2 >
T1 *	store_vector (T1 *ptr, const vector< T2, Elems > &v)
template<Operation Op1, Operation Op2>
constexpr MulMacroOp	to_mul_antisym_macro_op ()
template<Operation AccOp, Operation Op1, Operation Op2>
constexpr MulMacroOp	to_mul_antisym_macro_op ()
template<Operation Op1, Operation Op2>
constexpr MulMacroOp	to_mul_macro_op ()
template<Operation AccOp, Operation Op1, Operation Op2>
constexpr MulMacroOp	to_mul_macro_op ()
template<Operation Op1, Operation Op2>
constexpr MulMacroOp	to_mul_sym_macro_op ()
template<Operation AccOp, Operation Op1, Operation Op2>
constexpr MulMacroOp	to_mul_sym_macro_op ()
template<Operation Op1, Operation Op2>
constexpr MulMacroOp	to_negmul_antisym_macro_op ()
template<Operation Op1, Operation Op2>
constexpr MulMacroOp	to_negmul_macro_op ()
template<Operation Op1, Operation Op2>
constexpr MulMacroOp	to_negmul_sym_macro_op ()
template<size_t... Indices, typename... MutexTypes>
void	unlock_reverse_helper (const std::index_sequence< Indices... > &, MutexTypes &&...mutexes)
template<typename DstT , typename SrcT , unsigned SrcElems>
auto	vector_cast (const vector< SrcT, SrcElems > &v)

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

---

Class Documentation

aie::detail::accum_bits_for_tag

struct aie::detail::accum_bits_for_tag

template<typename T>
struct aie::detail::accum_bits_for_tag< T >

aie::detail::accum_class_for_mul_types

struct aie::detail::accum_class_for_mul_types

template<typename T1, typename T2>
struct aie::detail::accum_class_for_mul_types< T1, T2 >

aie::detail::accum_class_for_tag

struct aie::detail::accum_class_for_tag

template<typename T>
struct aie::detail::accum_class_for_tag< T >

aie::detail::accum_class_for_type

struct aie::detail::accum_class_for_type

template<typename T>
struct aie::detail::accum_class_for_type< T >

aie::detail::accum_native_type

struct aie::detail::accum_native_type

template<typename T>
struct aie::detail::accum_native_type< T >

aie::detail::accum_tag

struct aie::detail::accum_tag

template<AccumClass Class, unsigned Bits>
struct aie::detail::accum_tag< Class, Bits >

aie::detail::accum_tag< AccumClass::CInt, 16 >

struct aie::detail::accum_tag< AccumClass::CInt, 16 >

Class Members
typedef cacc16	type

aie::detail::accum_tag< AccumClass::CInt, 24 >

struct aie::detail::accum_tag< AccumClass::CInt, 24 >

Class Members
typedef cacc24	type

aie::detail::accum_tag< AccumClass::CInt, 32 >

struct aie::detail::accum_tag< AccumClass::CInt, 32 >

Class Members
typedef cacc32	type

aie::detail::accum_tag< AccumClass::CInt, 40 >

struct aie::detail::accum_tag< AccumClass::CInt, 40 >

Class Members
typedef cacc40	type

aie::detail::accum_tag< AccumClass::CInt, 48 >

struct aie::detail::accum_tag< AccumClass::CInt, 48 >

Class Members
typedef cacc48	type

aie::detail::accum_tag< AccumClass::CInt, 56 >

struct aie::detail::accum_tag< AccumClass::CInt, 56 >

Class Members
typedef cacc56	type

aie::detail::accum_tag< AccumClass::CInt, 64 >

struct aie::detail::accum_tag< AccumClass::CInt, 64 >

Class Members
typedef cacc64	type

aie::detail::accum_tag< AccumClass::FP, 32 >

struct aie::detail::accum_tag< AccumClass::FP, 32 >

Class Members
typedef accfloat	type

aie::detail::accum_tag< AccumClass::Int, 16 >

struct aie::detail::accum_tag< AccumClass::Int, 16 >

Class Members
typedef acc16	type

aie::detail::accum_tag< AccumClass::Int, 24 >

struct aie::detail::accum_tag< AccumClass::Int, 24 >

Class Members
typedef acc24	type

aie::detail::accum_tag< AccumClass::Int, 32 >

struct aie::detail::accum_tag< AccumClass::Int, 32 >

Class Members
typedef acc32	type

aie::detail::accum_tag< AccumClass::Int, 40 >

struct aie::detail::accum_tag< AccumClass::Int, 40 >

Class Members
typedef acc40	type

aie::detail::accum_tag< AccumClass::Int, 48 >

struct aie::detail::accum_tag< AccumClass::Int, 48 >

Class Members
typedef acc48	type

aie::detail::accum_tag< AccumClass::Int, 56 >

struct aie::detail::accum_tag< AccumClass::Int, 56 >

Class Members
typedef acc56	type

aie::detail::accum_tag< AccumClass::Int, 64 >

struct aie::detail::accum_tag< AccumClass::Int, 64 >

Class Members
typedef acc64	type

aie::detail::accum_tag_or_default

struct aie::detail::accum_tag_or_default

template<typename AccumTag, typename ... Tags>
struct aie::detail::accum_tag_or_default< AccumTag, Tags >

Class Members
typedef conditional_t< is_same_v< AccumTag, accauto >, deduce_accauto_helper_t< Tags... >, AccumTag >	type

aie::detail::add_memory_bank

struct aie::detail::add_memory_bank

template<aie_dm_resource Resource, typename T>
struct aie::detail::add_memory_bank< Resource, T >

Class Members
typedef T	type

aie::detail::add_memory_bank< aie_dm_resource::a, T >

struct aie::detail::add_memory_bank< aie_dm_resource::a, T >

template<typename T>
struct aie::detail::add_memory_bank< aie_dm_resource::a, T >

Class Members
typedef T chess_storage(DM_bankA)	type

aie::detail::add_memory_bank< aie_dm_resource::b, T >

struct aie::detail::add_memory_bank< aie_dm_resource::b, T >

template<typename T>
struct aie::detail::add_memory_bank< aie_dm_resource::b, T >

Class Members
typedef T chess_storage(DM_bankB)	type

aie::detail::add_memory_bank< aie_dm_resource::c, T >

struct aie::detail::add_memory_bank< aie_dm_resource::c, T >

template<typename T>
struct aie::detail::add_memory_bank< aie_dm_resource::c, T >

Class Members
typedef T chess_storage(DM_bankC)	type

aie::detail::add_memory_bank< aie_dm_resource::d, T >

struct aie::detail::add_memory_bank< aie_dm_resource::d, T >

template<typename T>
struct aie::detail::add_memory_bank< aie_dm_resource::d, T >

Class Members
typedef T chess_storage(DM_bankD)	type

aie::detail::add_memory_bank< aie_dm_resource::stack, T >

struct aie::detail::add_memory_bank< aie_dm_resource::stack, T >

template<typename T>
struct aie::detail::add_memory_bank< aie_dm_resource::stack, T >

Class Members
typedef T chess_storage(DM_stack)	type

aie::detail::adopt_lock_t

struct aie::detail::adopt_lock_t

aie::detail::basic_mdspan

class aie::detail::basic_mdspan

template<typename T, typename Extents, typename LayoutPolicy, typename AccessorPolicy>
class aie::detail::basic_mdspan< T, Extents, LayoutPolicy, AccessorPolicy >

aie::detail::basic_tiled_mdspan

class aie::detail::basic_tiled_mdspan

template<typename T, typename TileExtents, typename Extents, typename LayoutPolicy, typename AccessorPolicy>
class aie::detail::basic_tiled_mdspan< T, TileExtents, Extents, LayoutPolicy, AccessorPolicy >

aie::detail::C_block

struct aie::detail::C_block

template<typename TypeA, typename TypeB, unsigned AccumBits, unsigned Elems, unsigned NumAccum>
struct aie::detail::C_block< TypeA, TypeB, AccumBits, Elems, NumAccum >

aie::detail::cfr

struct aie::detail::cfr

template<typename T>
struct aie::detail::cfr< T >

aie::detail::circular_iterator

class aie::detail::circular_iterator

template<typename T, size_t Elems, size_t Stride = 1, aie_dm_resource Resource = aie_dm_resource::none>
class aie::detail::circular_iterator< T, Elems, Stride, Resource >

aie::detail::compute_C_type

struct aie::detail::compute_C_type

template<typename TypeA, typename TypeB>
struct aie::detail::compute_C_type< TypeA, TypeB >

aie::detail::compute_C_type< int8, int8 >

struct aie::detail::compute_C_type< int8, int8 >

Class Members
typedef int8	type

aie::detail::compute_C_type< int8, uint8 >

struct aie::detail::compute_C_type< int8, uint8 >

Class Members
typedef int8	type

aie::detail::compute_C_type< uint8, int8 >

struct aie::detail::compute_C_type< uint8, int8 >

Class Members
typedef int8	type

aie::detail::compute_C_type< uint8, uint8 >

struct aie::detail::compute_C_type< uint8, uint8 >

Class Members
typedef uint8	type

aie::detail::consume_terms

struct aie::detail::consume_terms

template<unsigned AccumBits, unsigned Lanes, unsigned CoeffBits, typename T_Coeff, unsigned N_Coeff, unsigned DataBits, typename T_Data, Operation Op, int Step>
struct aie::detail::consume_terms< AccumBits, Lanes, CoeffBits, T_Coeff, N_Coeff, DataBits, T_Data, Op, Step >

aie::detail::consumer_sem

class aie::detail::consumer_sem

template<unsigned NumReaders, unsigned NumWriters>
class aie::detail::consumer_sem< NumReaders, NumWriters >

aie::detail::deduce_accauto_helper

struct aie::detail::deduce_accauto_helper

template<typename ... Tags>
struct aie::detail::deduce_accauto_helper< Tags >

aie::detail::deduce_accauto_helper< Tag >

struct aie::detail::deduce_accauto_helper< Tag >

template<typename Tag>
requires (is_valid_element_type_v<Tag>)
struct aie::detail::deduce_accauto_helper< Tag >

Class Members
typedef default_accum_tag_t< Tag, Tag >	type

aie::detail::deduce_accauto_helper< Tag1, Tag2 >

struct aie::detail::deduce_accauto_helper< Tag1, Tag2 >

template<typename Tag1, typename Tag2>
requires (is_valid_element_type_v<Tag1, Tag2>)
struct aie::detail::deduce_accauto_helper< Tag1, Tag2 >

Class Members
typedef default_accum_tag_t< Tag1, Tag2 >	type

aie::detail::default_accum_tag

struct aie::detail::default_accum_tag

template<typename A, typename B>
struct aie::detail::default_accum_tag< A, B >

Class Members
typedef conditional_t< is_complex_v< A >||is_complex_v< B >, typename default_accum_tag_helper< default_accum_bits< A, B >(), is_floating_point_v< A > >::ctype, typename default_accum_tag_helper< default_accum_bits< A, B >(), is_floating_point_v< A > >::type >	type

aie::detail::default_accum_tag_helper

struct aie::detail::default_accum_tag_helper

template<unsigned SumBits, bool is_float = false>
struct aie::detail::default_accum_tag_helper< SumBits, is_float >

aie::detail::default_accum_tag_helper< 32, false >

struct aie::detail::default_accum_tag_helper< 32, false >

Class Members
typedef cacc32	ctype
typedef acc32	type

aie::detail::default_accum_tag_helper< 48 >

struct aie::detail::default_accum_tag_helper< 48 >

Class Members
typedef cacc48	ctype
typedef acc48	type

aie::detail::default_accum_tag_helper< 64 >

struct aie::detail::default_accum_tag_helper< 64 >

Class Members
typedef cacc64	ctype
typedef acc64	type

aie::detail::default_repr

struct aie::detail::default_repr

template<unsigned N>
struct aie::detail::default_repr< N >

Class Members
typedef decltype(tuple_cat(declval< tuple< dim_3d > >(), type >()))	type

aie::detail::default_repr< 0 >

struct aie::detail::default_repr< 0 >

Class Members
typedef tuple<>	type

aie::detail::default_repr< 1 >

struct aie::detail::default_repr< 1 >

Class Members
typedef tuple< int >	type

aie::detail::default_repr< 2 >

struct aie::detail::default_repr< 2 >

Class Members
typedef tuple< dim_2d >	type

aie::detail::default_twiddle_type

struct aie::detail::default_twiddle_type

template<typename Input, typename Output>
struct aie::detail::default_twiddle_type< Input, Output >

Class Members
typedef cint16	type

aie::detail::fft_dit

struct aie::detail::fft_dit

template<unsigned Vectorization, unsigned Stage, unsigned Radix, typename Input, typename Output = Input, typename Twiddle = default_twiddle_type_t<Input, Output>>
struct aie::detail::fft_dit< Vectorization, Stage, Radix, Input, Output, Twiddle >

aie::detail::fft_dit_stage

struct aie::detail::fft_dit_stage

template<unsigned Radix, unsigned Vectorization, typename Input, typename Output, typename Twiddle>
struct aie::detail::fft_dit_stage< Radix, Vectorization, Input, Output, Twiddle >

aie::detail::get_value_type

struct aie::detail::get_value_type

template<typename T>
struct aie::detail::get_value_type< T >

Class Members
typedef T	type

aie::detail::get_value_type< vector< T, Elems > >

struct aie::detail::get_value_type< vector< T, Elems > >

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

Class Members
typedef typename value_type	type

aie::detail::is_complex

struct aie::detail::is_complex

template<typename T>
struct aie::detail::is_complex< T >

aie::detail::is_floating_point

struct aie::detail::is_floating_point

template<typename T>
struct aie::detail::is_floating_point< T >

aie::detail::is_integral

struct aie::detail::is_integral

template<typename T>
struct aie::detail::is_integral< T >

aie::detail::is_signed

struct aie::detail::is_signed

template<typename T>
struct aie::detail::is_signed< T >

aie::detail::is_valid_accum_type

struct aie::detail::is_valid_accum_type

template<typename T>
struct aie::detail::is_valid_accum_type< T >

aie::detail::is_valid_element_type

struct aie::detail::is_valid_element_type

template<typename T>
struct aie::detail::is_valid_element_type< T >

aie::detail::iter_state

struct aie::detail::iter_state

template<typename U>
struct aie::detail::iter_state< U >

Class Members
typedef conditional_t< is_one_of_v< U, dim_3d, sliding_window_dim_3d >, state_3d, conditional_t< is_one_of_v< U, dim_2d, sliding_window_dim_2d >, state_2d, state_1d > >	storage_t

Class Members
storage_t	state_

aie::detail::linear_approx

struct aie::detail::linear_approx

template<typename T, typename MyLUT>
struct aie::detail::linear_approx< T, MyLUT >

aie::detail::native_vector_length

struct aie::detail::native_vector_length

template<typename T>
struct aie::detail::native_vector_length< T >

aie::detail::native_vector_traits

struct aie::detail::native_vector_traits

template<typename T>
struct aie::detail::native_vector_traits< T >

aie::detail::native_vector_type

struct aie::detail::native_vector_type

template<typename T, unsigned Elems>
struct aie::detail::native_vector_type< T, Elems >

aie::detail::parallel_lookup

struct aie::detail::parallel_lookup

template<typename T, typename MyLUT, lut_oor_policy oor_policy>
struct aie::detail::parallel_lookup< T, MyLUT, oor_policy >

aie::detail::producer_sem

class aie::detail::producer_sem

template<unsigned NumReaders, unsigned NumWriters>
class aie::detail::producer_sem< NumReaders, NumWriters >

aie::detail::random_circular_iterator_storage_dynamic

struct aie::detail::random_circular_iterator_storage_dynamic

template<typename Pointer>
struct aie::detail::random_circular_iterator_storage_dynamic< Pointer >

Class Members
Pointer	base
size_t	elems
Pointer	ptr

aie::detail::restrict_tensor_buffer_stream

class aie::detail::restrict_tensor_buffer_stream

template<typename T, unsigned Elems, unsigned Level, typename TensorIterDescriptor, aie_dm_resource Resource>
class aie::detail::restrict_tensor_buffer_stream< T, Elems, Level, TensorIterDescriptor, Resource >

aie::detail::sliding_window_buffer_stream

class aie::detail::sliding_window_buffer_stream

template<typename T, unsigned Elems, typename IterDescriptor, aie_dm_resource Resource = aie_dm_resource::none>
requires (arch::is(arch::AIE_ML))
class aie::detail::sliding_window_buffer_stream< T, Elems, IterDescriptor, Resource >

aie::detail::sparse_vector

class aie::detail::sparse_vector

template<typename T, unsigned N>
class aie::detail::sparse_vector< T, N >

aie::detail::sparse_vector_input_buffer_stream

class aie::detail::sparse_vector_input_buffer_stream

template<typename T, unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none>
class aie::detail::sparse_vector_input_buffer_stream< T, Elems, Resource >

aie::detail::tensor_buffer_stream

class aie::detail::tensor_buffer_stream

template<typename T, unsigned Elems, unsigned Level, typename TensorIterDescriptor, aie_dm_resource Resource>
class aie::detail::tensor_buffer_stream< T, Elems, Level, TensorIterDescriptor, Resource >

aie::detail::tile_id

struct aie::detail::tile_id

Class Members
uint16_t	col
uint16_t	row

aie::detail::tiled_span_extents

struct aie::detail::tiled_span_extents

template<bool IsStatic, typename TileExtents, typename Extents>
struct aie::detail::tiled_span_extents< IsStatic, TileExtents, Extents >

aie::detail::tiled_span_extents_common

struct aie::detail::tiled_span_extents_common

template<typename TileExtents, typename Extents>
struct aie::detail::tiled_span_extents_common< TileExtents, Extents >

aie::detail::vector_circular_iterator

class aie::detail::vector_circular_iterator

template<typename T, unsigned N, size_t Elems, size_t Stride = 1, aie_dm_resource Resource = aie_dm_resource::none>
class aie::detail::vector_circular_iterator< T, N, Elems, Stride, Resource >

aie::detail::vector_ldst_align

struct aie::detail::vector_ldst_align

template<typename T, unsigned Elems>
struct aie::detail::vector_ldst_align< T, Elems >

aie::detail::vector_storage

struct aie::detail::vector_storage

template<typename T, unsigned Elems>
struct aie::detail::vector_storage< T, Elems >

aie::detail::zeros_type_for_accum

struct aie::detail::zeros_type_for_accum

template<AccumClass Class>
struct aie::detail::zeros_type_for_accum< Class >

aie::detail::zeros_type_for_accum< AccumClass::CInt >

struct aie::detail::zeros_type_for_accum< AccumClass::CInt >

Class Members
typedef cint32	type

aie::detail::zeros_type_for_accum< AccumClass::Int >

struct aie::detail::zeros_type_for_accum< AccumClass::Int >

Class Members
typedef int32	type

Typedef Documentation

abs

template<typename T , unsigned Elems>

using aie::detail::abs = typedef abs_bits<type_bits_v<T>, T, Elems>

abs_square

template<typename T , typename TR , unsigned Elems>

using aie::detail::abs_square = typedef abs_square_bits<T, TR, Elems>

accum_native_type_t

template<typename T >

using aie::detail::accum_native_type_t = typedef typename accum_native_type<T>::type

accum_tag_for_mul_types

template<typename T1 , typename T2 , unsigned Bits = default_accum_bits<T1, T2>()>

using aie::detail::accum_tag_for_mul_types = typedef accum_tag_t<accum_class_for_mul_types_v<T1, T2>, Bits>

accum_tag_for_type

template<typename T , unsigned Bits = default_accum_bits<T, T>()>

using aie::detail::accum_tag_for_type = typedef accum_tag_t<accum_class_for_type<T>::value(), Bits>

accum_tag_or_default_t

template<typename AccumTag , typename ... Tags>

using aie::detail::accum_tag_or_default_t = typedef typename accum_tag_or_default<AccumTag, Tags...>::type

accum_tag_t

template<AccumClass Class, unsigned Bits>

using aie::detail::accum_tag_t = typedef typename accum_tag<Class, Bits>::type

accum_to_vector_cast

template<typename DstT , typename Tag , unsigned Elems>

using aie::detail::accum_to_vector_cast = typedef accum_to_vector_cast_bits<DstT, accum_class_for_tag_v<Tag>, accum_bits_for_tag_v<Tag>, Elems>

add

template<typename T , unsigned Elems>

using aie::detail::add = typedef add_sub_bits<type_bits_v<T>, T, Elems, AddSubOperation::Add>

add_accum

template<AccumElemBaseType AccumTag, unsigned Elems>

using aie::detail::add_accum = typedef add_sub_accum_bits<accum_native_type_t<AccumTag>, Elems, AddSubOperation::Add>

add_accum_vector

template<unsigned AccumBits, typename T , unsigned Elems>

using aie::detail::add_accum_vector = typedef add_sub_accum_vector_bits<AccumBits, type_bits_v<T>, T, Elems, AddSubOperation::Add>

add_memory_bank_t

template<aie_dm_resource Resource, typename T >

using aie::detail::add_memory_bank_t = typedef typename add_memory_bank<Resource, T>::type

add_reduce

template<typename T , unsigned Elems>

using aie::detail::add_reduce = typedef add_reduce_bits<type_bits_v<T>, T, Elems>

add_reduce_v

template<typename T , unsigned Elems>

using aie::detail::add_reduce_v = typedef add_reduce_v_bits<type_bits_v<T>, T, Elems>

bit

template<typename T , unsigned Elems, BitOp Op>

using aie::detail::bit = typedef bit_bits<type_bits_v<T>, T, Elems, Op>

broadcast

template<typename T , unsigned Elems>

using aie::detail::broadcast = typedef broadcast_bits<type_bits_v<T>, T, Elems>

compute_C_type_t

template<typename TypeA , typename TypeB >

using aie::detail::compute_C_type_t = typedef typename compute_C_type<TypeA, TypeB>::type

conj

template<typename T , unsigned Elems>

using aie::detail::conj = typedef conj_bits<type_bits_v<T>, T, Elems>

const_circular_iterator

template<typename T , size_t Elems, size_t Stride = 1, aie_dm_resource Resource = aie_dm_resource::none>

using aie::detail::const_circular_iterator = typedef circular_iterator<const T, Elems, Stride, Resource>

const_pattern_iterator

template<typename T , unsigned Steps>

using aie::detail::const_pattern_iterator = typedef pattern_iterator<const std::remove_const_t<T>, Steps>

const_random_circular_iterator

template<typename T , size_t Elems, size_t Stride = 1, aie_dm_resource Resource = aie_dm_resource::none>

using aie::detail::const_random_circular_iterator = typedef random_circular_iterator<const T, Elems, Stride, Resource>

const_restrict_vector_iterator

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

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

const_sliding_window_buffer_stream

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

using aie::detail::const_sliding_window_buffer_stream = typedef sliding_window_buffer_stream<const std::remove_const_t<T>, Elems, IterDescriptor, Resource>

const_unaligned_vector_iterator

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

using aie::detail::const_unaligned_vector_iterator = typedef unaligned_vector_iterator<const std::remove_const_t<T>, Elems, Resource>

const_vector_circular_iterator

template<typename T , unsigned N, size_t Elems, size_t Stride = 1, aie_dm_resource Resource = aie_dm_resource::none>

using aie::detail::const_vector_circular_iterator = typedef vector_circular_iterator<const T, N, Elems, Stride, Resource>

const_vector_iterator

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

using aie::detail::const_vector_iterator = typedef vector_iterator<const std::remove_const_t<T>, Elems, Stride, Resource>

const_vector_random_circular_iterator

template<typename T , unsigned N, size_t Elems, size_t Stride = 1, aie_dm_resource Resource = aie_dm_resource::none>

using aie::detail::const_vector_random_circular_iterator = typedef vector_random_circular_iterator<const T, N, Elems, Stride, Resource>

consumer_lock

template<unsigned NumReaders, unsigned NumWriters>

using aie::detail::consumer_lock = typedef scoped_lock_impl<consumer_sem<NumReaders, NumWriters> >

deduce_accauto_helper_t

template<typename ... Tags>

using aie::detail::deduce_accauto_helper_t = typedef typename deduce_accauto_helper<Tags...>::type

default_accum_tag_t

template<typename A , typename B >

using aie::detail::default_accum_tag_t = typedef typename default_accum_tag<A, B>::type

default_repr_t

template<unsigned N>

using aie::detail::default_repr_t = typedef typename default_repr<N>::type

default_twiddle_type_t

template<typename Input , typename Output = Input>

using aie::detail::default_twiddle_type_t = typedef typename default_twiddle_type<Input, Output>::type

dyn_extents

template<size_t Rank>

using aie::detail::dyn_extents = typedef std::array<size_t, Rank>

elementary

template<ElementaryOp Op, typename TR , typename T >

using aie::detail::elementary = typedef elementary_bits<Op, type_bits_v<T>, TR, T>

elementary_vector

template<ElementaryOp Op, typename TR , typename T , unsigned N>

using aie::detail::elementary_vector = typedef elementary_vector_bits<Op, type_bits_v<T>, TR, T, N>

eq

template<typename T , unsigned Elems>

using aie::detail::eq = typedef cmp_impl<CmpOp::EQ, T, Elems>

extents

template<size_t... Extents>

using aie::detail::extents = typedef std::integer_sequence<size_t, Extents...>

filter

template<typename T , unsigned Elems, FilterOp Op>

using aie::detail::filter = typedef filter_bits<type_bits_v<T>, T, Elems, Op>

ge

template<typename T , unsigned Elems>

using aie::detail::ge = typedef cmp_impl<CmpOp::GE, T, Elems>

get_value_type_t

template<typename T >

using aie::detail::get_value_type_t = typedef typename get_value_type<T>::type

interleave_butterfly

template<typename T , unsigned Elems>

using aie::detail::interleave_butterfly = typedef interleave_bits_butterfly<type_bits_v<T>, T, Elems>

interleave_butterfly_half

template<typename T , unsigned Elems>

using aie::detail::interleave_butterfly_half = typedef interleave_bits_butterfly_half<type_bits_v<T>, T, Elems>

interleave_crossover

template<typename T , unsigned Elems>

using aie::detail::interleave_crossover = typedef interleave_bits_crossover<type_bits_v<T>, T, Elems>

interleave_custom

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

using aie::detail::interleave_custom = typedef interleave_bits_custom<type_bits_v<T>, T, Elems>

interleave_custom_static

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

using aie::detail::interleave_custom_static = typedef interleave_bits_custom_static<type_bits_v<T>, T, Elems, Select...>

interleave_unzip

template<typename T , unsigned Elems>

using aie::detail::interleave_unzip = typedef interleave_bits_unzip<type_bits_v<T>, T, Elems>

interleave_zip

template<typename T , unsigned Elems>

using aie::detail::interleave_zip = typedef interleave_bits_zip<type_bits_v<T>, T, Elems>

lt

template<typename T , unsigned Elems>

using aie::detail::lt = typedef cmp_impl<CmpOp::LT, T, Elems>

make_dynamic_extents

template<size_t Rank>

using aie::detail::make_dynamic_extents = typedef utils::make_integer_broadcast<size_t, Rank, dynamic_extent>

max

template<typename T , unsigned Elems>

using aie::detail::max = typedef max_min_bits<type_bits_v<T>, T, Elems, MaxMinOperation::Max>

max_cmp

template<typename T , unsigned Elems>

using aie::detail::max_cmp = typedef max_min_cmp_bits<type_bits_v<T>, T, Elems, MaxMinOperation::MaxCmp>

max_reduce

template<typename T , unsigned Elems>

using aie::detail::max_reduce = typedef max_min_reduce_bits<type_bits_v<T>, T, Elems, MaxMinOperation::Max>

maxdiff

template<typename T , unsigned Elems>

using aie::detail::maxdiff = typedef max_min_bits<type_bits_v<T>, T, Elems, MaxMinOperation::MaxDiff>

min

template<typename T , unsigned Elems>

using aie::detail::min = typedef max_min_bits<type_bits_v<T>, T, Elems, MaxMinOperation::Min>

min_cmp

template<typename T , unsigned Elems>

using aie::detail::min_cmp = typedef max_min_cmp_bits<type_bits_v<T>, T, Elems, MaxMinOperation::MinCmp>

min_reduce

template<typename T , unsigned Elems>

using aie::detail::min_reduce = typedef max_min_reduce_bits<type_bits_v<T>, T, Elems, MaxMinOperation::Min>

mul

template<MulMacroOp MulOp, unsigned AccumBits, typename T1 , typename T2 >

using aie::detail::mul = typedef mul_bits<MulOp, AccumBits, type_bits_v<T1>, T1, type_bits_v<T2>, T2>

mul_maxmin

template<MulMacroOp MulOp, unsigned AccumBits, typename T1 , typename T2 >

using aie::detail::mul_maxmin = typedef mul_maxmin_bits<MulOp, AccumBits, type_bits_v<T1>, T1, type_bits_v<T2>, T2>

mul_reduce

template<unsigned AccumBits, typename T , unsigned Elems>

using aie::detail::mul_reduce = typedef mul_reduce_bits<AccumBits, type_bits_v<T>, T, Elems>

native_vector_type_t

template<typename T , unsigned Elems>

using aie::detail::native_vector_type_t = typedef typename native_vector_type<T, Elems>::type

neg

template<typename T , unsigned Elems>

using aie::detail::neg = typedef neg_bits<type_bits_v<T>, T, Elems>

neq

template<typename T , unsigned Elems>

using aie::detail::neq = typedef cmp_impl<CmpOp::NEQ, T, Elems>

producer_lock

template<unsigned NumReaders, unsigned NumWriters>

using aie::detail::producer_lock = typedef scoped_lock_impl<producer_sem<NumReaders, NumWriters> >

scoped_lock

using aie::detail::scoped_lock = typedef scoped_lock_impl<mutex>

select

template<typename T , unsigned Elems>

using aie::detail::select = typedef select_bits<type_bits_v<T>, T, Elems>

shift

template<typename T , unsigned Elems>

using aie::detail::shift = typedef shift_bits<T, type_bits_v<T>, Elems>

shuffle_down

template<typename T , unsigned Elems>

using aie::detail::shuffle_down = typedef shuffle_down_bits<type_bits_v<T>, T, Elems>

shuffle_down_fill

template<typename T , unsigned Elems>

using aie::detail::shuffle_down_fill = typedef shuffle_down_fill_bits<type_bits_v<T>, T, Elems>

shuffle_down_replicate

template<typename T , unsigned Elems>

using aie::detail::shuffle_down_replicate = typedef shuffle_down_replicate_bits<type_bits_v<T>, T, Elems>

shuffle_down_rotate

template<typename T , unsigned Elems>

using aie::detail::shuffle_down_rotate = typedef shuffle_down_rotate_bits<type_bits_v<T>, T, Elems>

shuffle_up

template<typename T , unsigned Elems>

using aie::detail::shuffle_up = typedef shuffle_up_bits<type_bits_v<T>, T, Elems>

shuffle_up_fill

template<typename T , unsigned Elems>

using aie::detail::shuffle_up_fill = typedef shuffle_up_fill_bits<type_bits_v<T>, T, Elems>

shuffle_up_replicate

template<typename T , unsigned Elems>

using aie::detail::shuffle_up_replicate = typedef shuffle_up_replicate_bits<type_bits_v<T>, T, Elems>

shuffle_up_rotate

template<typename T , unsigned Elems>

using aie::detail::shuffle_up_rotate = typedef shuffle_up_rotate_bits<type_bits_v<T>, T, Elems>

sliding_mul

template<unsigned OutElems, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, unsigned AccumBits, typename CoeffType , typename DataType >

using aie::detail::sliding_mul = typedef sliding_mul_bits <OutElems, Points, CoeffStep, DataStepX, DataStepY, AccumBits, type_bits_v<CoeffType>, type_bits_v<DataType>, CoeffType, DataType>

sliding_mul_ch

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, unsigned AccumBits, typename CoeffType , typename DataType >

using aie::detail::sliding_mul_ch = typedef sliding_mul_ch_bits <Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, AccumBits, type_bits_v<CoeffType>, type_bits_v<DataType>, CoeffType, DataType>

sliding_mul_sym

template<unsigned OutElems, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, unsigned AccumBits, typename CoeffType , typename DataType >

using aie::detail::sliding_mul_sym = typedef sliding_mul_sym_bits<OutElems, Points, CoeffStep, DataStepX, DataStepY, AccumBits, type_bits_v<CoeffType>, type_bits_v<DataType>, CoeffType, DataType>

sliding_mul_sym_uct

template<unsigned OutElems, unsigned Points, int CoeffStep, int DataStep, unsigned AccumBits, typename CoeffType , typename DataType >

using aie::detail::sliding_mul_sym_uct = typedef sliding_mul_sym_uct_bits<OutElems, Points, CoeffStep, DataStep, AccumBits, type_bits_v<CoeffType>, type_bits_v<DataType>, CoeffType, DataType>

square

template<MulMacroOp MulOp, unsigned AccumBits, typename T >

using aie::detail::square = typedef square_bits<MulOp, AccumBits, type_bits_v<T>, T>

sub

template<typename T , unsigned Elems>

using aie::detail::sub = typedef add_sub_bits<type_bits_v<T>, T, Elems, AddSubOperation::Sub>

sub_accum

template<AccumElemBaseType AccumTag, unsigned Elems>

using aie::detail::sub_accum = typedef add_sub_accum_bits<accum_native_type_t<AccumTag>, Elems, AddSubOperation::Sub>

sub_accum_vector

template<unsigned AccumBits, typename T , unsigned Elems>

using aie::detail::sub_accum_vector = typedef add_sub_accum_vector_bits<AccumBits, type_bits_v<T>, T, Elems, AddSubOperation::Sub>

transpose

template<typename T , unsigned Elems>

using aie::detail::transpose = typedef transpose_bits<type_bits_v<T>, T, Elems>

vector_storage_t

template<typename T , unsigned Elems>

using aie::detail::vector_storage_t = typedef typename vector_storage<T, Elems>::type

vector_to_accum_cast

template<typename DstTag , typename T , unsigned Elems>

using aie::detail::vector_to_accum_cast = typedef vector_to_accum_cast_bits<DstTag, T, Elems>

zeros

template<typename T , unsigned Elems>

using aie::detail::zeros = typedef zeros_bits<type_bits_v<T>, T, Elems>

zeros_acc

template<AccumClass Class, unsigned AccumBits, unsigned Elems>

using aie::detail::zeros_acc = typedef zeros_acc_bits<Class, AccumBits, Elems>

zeros_type_for_accum_t

template<AccumClass Class>

using aie::detail::zeros_type_for_accum_t = typedef typename zeros_type_for_accum<Class>::type

Enumeration Type Documentation

AccumClass

enum class aie::detail::AccumClass

strong

Enumerator
Int
CInt
FP
CFP

AddSubOperation

enum class aie::detail::AddSubOperation

strong

Enumerator
Add
Sub

BitOp

enum class aie::detail::BitOp

strong

Enumerator
And
Not
Or
Xor

CmpOp

enum class aie::detail::CmpOp

strong

Enumerator
LT
GE
EQ
NEQ

ElementaryOp

enum class aie::detail::ElementaryOp

strong

Enumerator
Sqrt
Inv
InvSqrt
SinCos
SinCosComplex
Sin
Cos
Fix2Float
Float2Fix
Tanh
Exp2

FifoDirection

enum class aie::detail::FifoDirection

strong

Enumerator
In
Out

FilterOp

enum class aie::detail::FilterOp

strong

Enumerator
Odd
Even

lut_oor_policy

enum class aie::detail::lut_oor_policy

strong

Enumerator
saturate
truncate

MaxMinOperation

enum class aie::detail::MaxMinOperation

strong

Enumerator
Max
Min
MaxCmp
MinCmp
MaxDiff

MulMacroOp

enum class aie::detail::MulMacroOp

strong

Enumerator
Unavailable
Mul
NegMul
Add_Mul
Add_NegMul
Sub_Mul

rounding_mode

enum class aie::detail::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 the even number.
conv_odd	Round to the nearest integer, with preference to the odd number.

saturation_mode

enum class aie::detail::saturation_mode : unsigned

strong

Enumerator
none
truncate
saturate
symmetric

Function Documentation

accum_cast()

template<typename DstTag , typename Acc >

auto aie::detail::accum_cast

(

const Acc &

acc

)

add_to_op()

template<MulMacroOp Op>

constexpr MulMacroOp aie::detail::add_to_op ( )

constexpr

check_alignment()

template<typename T >

constexpr bool aie::detail::check_alignment ( const T *  ptr, unsigned  aligned_elems  )

constexpr

check_vector_alignment()

template<unsigned Elems, typename T >

constexpr bool aie::detail::check_vector_alignment ( const T *  ptr )

constexpr

concat_accum()

template<typename Accum , typename... Accums>

auto aie::detail::concat_accum	(	const Accum &	acc,
		const Accum &	acc2,
		const Accums &...	accums
	)

concat_vector()

template<typename... Vectors>

auto aie::detail::concat_vector

(

Vectors &&...

vectors

)

evaluate_mul_operation()

template<typename T >

constexpr Operation aie::detail::evaluate_mul_operation ( )

constexpr

get_mul_sign()

template<typename T >

constexpr bool aie::detail::get_mul_sign ( T  v )

constexpr

get_sub_accum()

template<Accum Acc>
requires (!Acc::is_floating_point())

auto aie::detail::get_sub_accum	(	const Acc &	acc,
		unsigned	i
	)

has_abs()

template<MulMacroOp Op>

constexpr bool aie::detail::has_abs ( )

constexpr

has_conj1()

template<MulMacroOp Op>

constexpr bool aie::detail::has_conj1 ( )

constexpr

has_conj2()

template<MulMacroOp Op>

constexpr bool aie::detail::has_conj2 ( )

constexpr

largest_valid_vector_size()

template<typename T , unsigned Elems>

constexpr unsigned aie::detail::largest_valid_vector_size ( )

constexpr

load_unaligned_vector()

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

auto aie::detail::load_unaligned_vector	(	const T *	ptr,
		unsigned	aligned_elems = 1
	)

load_vector()

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

auto aie::detail::load_vector

(

const T *

ptr

)

locked()

template<typename Fn , typename... MutexTypes>

void aie::detail::locked	(	Fn	fn,
		MutexTypes &...	mutexes
	)

operator<<() [1/4]

template<typename T , unsigned Elems, aie_dm_resource Resource, aie_dm_resource ResourceIn>

constexpr unaligned_vector_output_buffer_stream< T, Elems, Resource > & aie::detail::operator<< ( unaligned_vector_output_buffer_stream< T, Elems, Resource > &  out, unaligned_vector_input_buffer_stream< T, Elems, ResourceIn > &  in  )

constexpr

operator<<() [2/4]

template<typename T , unsigned Elems, aie_dm_resource Resource, aie_dm_resource ResourceIn>

constexpr unaligned_vector_output_buffer_stream< T, Elems, Resource > & aie::detail::operator<< ( unaligned_vector_output_buffer_stream< T, Elems, Resource > &  out, vector_input_buffer_stream< T, Elems, ResourceIn > &  in  )

constexpr

operator<<() [3/4]

template<typename T , unsigned Elems, aie_dm_resource Resource, aie_dm_resource ResourceIn>

constexpr vector_output_buffer_stream< T, Elems, Resource > & aie::detail::operator<< ( vector_output_buffer_stream< T, Elems, Resource > &  out, unaligned_vector_input_buffer_stream< T, Elems, ResourceIn > &  in  )

constexpr

operator<<() [4/4]

template<typename T , unsigned Elems, aie_dm_resource Resource, aie_dm_resource ResourceIn>

constexpr vector_output_buffer_stream< T, Elems, Resource > & aie::detail::operator<< ( vector_output_buffer_stream< T, Elems, Resource > &  out, vector_input_buffer_stream< T, Elems, ResourceIn > &  in  )

constexpr

print_elem() [1/6]

template<RegularAcc Acc>
requires (Acc::is_floating_point())

void aie::detail::print_elem	(	const Acc &	acc,
		unsigned	i
	)

print_elem() [2/6]

template<RegularAcc Acc>
requires (!Acc::is_floating_point() && !Acc::is_complex())

void aie::detail::print_elem	(	const Acc &	acc,
		unsigned	i
	)

print_elem() [3/6]

template<RegularAcc Acc>
requires (!Acc::is_floating_point() && Acc::is_complex())

void aie::detail::print_elem	(	const Acc &	acc,
		unsigned	i
	)

print_elem() [4/6]

template<OverlappingAcc Acc>
requires (Acc::is_complex())

void aie::detail::print_elem	(	const Acc &	acc,
		unsigned	i
	)

print_elem() [5/6]

template<OverlappingAcc Acc>
requires (!Acc::is_complex())

void aie::detail::print_elem	(	const Acc &	acc,
		unsigned	i,
		const char *	prefix = "",
		const char *	suffix = " "
	)

print_elem() [6/6]

template<typename T , unsigned Elems>

void aie::detail::print_elem	(	const vector< T, Elems > &	v,
		unsigned	i
	)

print_int_component()

template<RegularAcc Acc, unsigned memory_bits>
requires (!Acc::is_floating_point())

void aie::detail::print_int_component	(	const char *	acc_ptr,
		const char *	prefix = "",
		const char *	suffix = ""
	)

print_value()

template<typename T >

void aie::detail::print_value	(	const T &	e,
		int	scale = 0
	)

store_unaligned_vector()

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

T1 * aie::detail::store_unaligned_vector	(	T1 *	ptr,
		const vector< T2, Elems > &	v,
		unsigned	aligned_elems = 1
	)

store_vector()

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

T1 * aie::detail::store_vector	(	T1 *	ptr,
		const vector< T2, Elems > &	v
	)

to_mul_antisym_macro_op() [1/2]

template<Operation Op1, Operation Op2>

constexpr MulMacroOp aie::detail::to_mul_antisym_macro_op ( )

constexpr

to_mul_antisym_macro_op() [2/2]

template<Operation AccOp, Operation Op1, Operation Op2>

constexpr MulMacroOp aie::detail::to_mul_antisym_macro_op ( )

constexpr

to_mul_macro_op() [1/2]

template<Operation Op1, Operation Op2>

constexpr MulMacroOp aie::detail::to_mul_macro_op ( )

constexpr

to_mul_macro_op() [2/2]

template<Operation AccOp, Operation Op1, Operation Op2>

constexpr MulMacroOp aie::detail::to_mul_macro_op ( )

constexpr

to_mul_sym_macro_op() [1/2]

template<Operation Op1, Operation Op2>

constexpr MulMacroOp aie::detail::to_mul_sym_macro_op ( )

constexpr

to_mul_sym_macro_op() [2/2]

template<Operation AccOp, Operation Op1, Operation Op2>

constexpr MulMacroOp aie::detail::to_mul_sym_macro_op ( )

constexpr

to_negmul_antisym_macro_op()

template<Operation Op1, Operation Op2>

constexpr MulMacroOp aie::detail::to_negmul_antisym_macro_op ( )

constexpr

to_negmul_macro_op()

template<Operation Op1, Operation Op2>

constexpr MulMacroOp aie::detail::to_negmul_macro_op ( )

constexpr

to_negmul_sym_macro_op()

template<Operation Op1, Operation Op2>

constexpr MulMacroOp aie::detail::to_negmul_sym_macro_op ( )

constexpr

unlock_reverse_helper()

template<size_t... Indices, typename... MutexTypes>

void aie::detail::unlock_reverse_helper	(	const std::index_sequence< Indices... > &	,
		MutexTypes &&...	mutexes
	)

vector_cast()

template<typename DstT , typename SrcT , unsigned SrcElems>

auto aie::detail::vector_cast

(

const vector< SrcT, SrcElems > &

v

)

Variable Documentation

dynamic_extent

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

inlineconstexpr