aie Namespace Reference

Detailed Description

Base namespace for AIE operations and types.

Namespaces
namespace	detail
namespace	operators
namespace	sync

Classes
struct	accauto
class	accum
struct	binary_op
struct	binary_op< Parent1, Parent2, Operation::Max >
struct	binary_op< Parent1, Parent2, Operation::Min >
struct	binary_op_common
struct	cfr
struct	circular_iterator
struct	const_circular_iterator
struct	const_pattern_iterator
struct	const_random_circular_iterator
struct	const_restrict_vector_iterator
struct	const_vector_iterator
struct	fft_dit
struct	is_accum_op
struct	is_accum_op< unary_op< Parent, Op > >
struct	is_binary_op
struct	is_binary_op< binary_op< Parent1, Parent2, Op > >
struct	is_elem_op
struct	is_elem_op< binary_op< Parent1, Parent2, Op > >
struct	is_elem_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 > >
class	mask
struct	mmul
struct	op_result_helper
struct	op_result_helper< binary_op< Parent1, Parent2, ParentOp >, Op >
struct	op_result_helper< detail::vector_elem_const_ref< T, Elems >, Op >
struct	op_result_helper< detail::vector_elem_ref< T, Elems >, Op >
struct	op_result_helper< Parent, Operation::None >
struct	op_result_helper< unary_op< Parent, ParentOp >, Op >
struct	op_value_type_helper
struct	op_value_type_helper< binary_op< Parent1, Parent2, Op > >
struct	op_value_type_helper< detail::vector_elem_const_ref< T, Elems > >
struct	op_value_type_helper< detail::vector_elem_ref< T, Elems > >
struct	op_value_type_helper< unary_op< Parent, Op > >
struct	op_value_type_helper< vector< T, Elems > >
struct	operand_base_type
struct	operand_base_type< binary_op< Parent1, Parent2, Op > >
struct	operand_base_type< detail::vector_elem_const_ref< T, Elems > >
struct	operand_base_type< detail::vector_elem_ref< T, Elems > >
struct	operand_base_type< unary_op< Parent, Op > >
struct	pattern_iterator
struct	random_circular_iterator
struct	restrict_vector_iterator
struct	sliding_mul_ops
struct	sliding_mul_sym_ops
struct	sliding_mul_sym_uct_ops
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_common
class	vector
struct	vector_iterator

Typedefs
template<AccumElemBaseTypeMinAccumTag, unsigned Elems>
using	accum=detail::accum< detail::accum_class_for_tag_v< MinAccumTag >, detail::accum_bits_for_tag_v< MinAccumTag >, Elems >
	More...
using	AccumClass=detail::AccumClass
template
using	cfp_accum=detail::accum< AccumClass::CFP, detail::to_native_accum_bits< AccumClass::CFP, MinAccumBits >(), Elems >
template
using	cfr=detail::cfr< T >
template
using	cint_accum=detail::accum< AccumClass::CInt, detail::to_native_accum_bits< AccumClass::CInt, MinAccumBits >(), Elems >
templateaie_dm_resourceResource = aie_dm_resource::none>
using	circular_iterator=detail::circular_iterator< T, Elems, 1, Resource >
	More...
templateaie_dm_resourceResource = aie_dm_resource::none>
using	const_circular_iterator=detail::const_circular_iterator< T, Elems, 1, Resource >
	More...
template
using	const_pattern_iterator=detail::const_pattern_iterator< T, Steps >
template
using	const_random_circular_iterator=detail::const_random_circular_iterator< T, Elems, 1 >
	More...
template<DecoratedElemBaseTypeT, unsigned Elems,aie_dm_resourceResource = aie_dm_resource::none>
using	const_restrict_vector_iterator=detail::const_restrict_vector_iterator< T, Elems, 1, Resource >
template<DecoratedElemBaseTypeT, unsigned Elems,aie_dm_resourceResource = aie_dm_resource::none>
using	const_vector_iterator=detail::const_vector_iterator< T, Elems, 1, Resource >
template
using	extents=detail::extents< Extents... >
template
using	fft_dit=detail::fft_dit< Vectorization, detail::fft_get_stage< Vectorization, Radix, T1, T2 >(), Radix, T1, T2 >
	More...
template
using	fp_accum=detail::accum< AccumClass::FP, detail::to_native_accum_bits< AccumClass::FP, MinAccumBits >(), Elems >
template
using	int_accum=detail::accum< AccumClass::Int, detail::to_native_accum_bits< AccumClass::Int, MinAccumBits >(), Elems >
templateParallelLUTMyLUT>
using	linear_approx=detail::linear_approx< T, MyLUT >
template
using	lut=detail::lut< ParallelAccesses, OffsetType, SlopeType >
template
using	mask=detail::mask< Elems >
	More...
template
using	mdspan=detail::basic_mdspan< T,extents< Extents... >, void,detail::accessor_basic< T > >
templateOperationOp>
using	op_result_type_t= typenameop_result_helper< T, Op >::type
template
using	op_value_type_t= typenameop_value_type_helper< T >::type
template
using	operand_base_type_t= typenameoperand_base_type<Utils::remove_all_t< T > >::type
templateParallelLUTMyLUT>
using	parallel_lookup=detail::parallel_lookup< T, MyLUT >
template
using	pattern_iterator=detail::pattern_iterator< T, Steps >
template
using	random_circular_iterator=detail::random_circular_iterator< T, Elems, 1 >
	More...
template
using	restrict_mdspan=detail::basic_mdspan< T,extents< Extents... >, void,detail::accessor_restrict< T > >
template
using	restrict_span=restrict_span_1d< T, Extents1 >
template
using	restrict_span_1d=restrict_mdspan< T, Extents1 >
template
using	restrict_span_2d=restrict_mdspan< T, Extents1, Extents2 >
template
using	restrict_span_3d=restrict_mdspan< T, Extents1, Extents2, Extents3 >
template
using	restrict_span_4d=restrict_mdspan< T, Extents1, Extents2, Extents3, Extents4 >
template
using	restrict_tiled_mdspan=detail::basic_tiled_mdspan< T, TileExtents,extents< Extents... >, void,detail::accessor_restrict< T > >
template
using	restrict_tiled_span=tiled_span_1d< T, TileExtents, Extents1 >
template
using	restrict_tiled_span_1d=tiled_mdspan< T, TileExtents, Extents1 >
template
using	restrict_tiled_span_2d=tiled_mdspan< T, TileExtents, Extents1, Extents2 >
template
using	restrict_tiled_span_3d=tiled_mdspan< T, TileExtents, Extents1, Extents2, Extents3 >
template
using	restrict_tiled_span_4d=tiled_mdspan< T, TileExtents, Extents1, Extents2, Extents3, Extents4 >
template<DecoratedElemBaseTypeT, unsigned Elems,aie_dm_resourceResource = aie_dm_resource::none>
using	restrict_vector_iterator=detail::restrict_vector_iterator< T, Elems, 1, Resource >
templateElemBaseTypeCoeffType,ElemBaseTypeDataType,AccumElemBaseTypeAccumTag = detail::default_accum_tag_t>
using	sliding_mul_sym_x_ops=sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, 1, CoeffType, DataType, AccumTag >
	More...
templateElemBaseTypeCoeffType,ElemBaseTypeDataType,AccumElemBaseTypeAccumTag = detail::default_accum_tag_t>
using	sliding_mul_sym_xy_ops=sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepXY, DataStepXY, CoeffType, DataType, AccumTag >
	More...
templateElemBaseTypeCoeffType,ElemBaseTypeDataType,AccumElemBaseTypeAccumTag = detail::default_accum_tag_t>
using	sliding_mul_sym_y_ops=sliding_mul_sym_ops< Lanes, Points, CoeffStep, 1, DataStepY, CoeffType, DataType, AccumTag >
	More...
templateElemBaseTypeCoeffType,ElemBaseTypeDataType,AccumElemBaseTypeAccumTag = detail::default_accum_tag_t>
using	sliding_mul_x_ops=sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, 1, CoeffType, DataType, AccumTag >
	More...
templateElemBaseTypeCoeffType,ElemBaseTypeDataType,AccumElemBaseTypeAccumTag = detail::default_accum_tag_t>
using	sliding_mul_xy_ops=sliding_mul_ops< Lanes, Points, CoeffStep, DataStepXY, DataStepXY, CoeffType, DataType, AccumTag >
	More...
templateElemBaseTypeCoeffType,ElemBaseTypeDataType,AccumElemBaseTypeAccumTag = detail::default_accum_tag_t>
using	sliding_mul_y_ops=sliding_mul_ops< Lanes, Points, CoeffStep, 1, DataStepY, CoeffType, DataType, AccumTag >
	More...
template
using	span=span_1d< T, Extents1 >
template
using	span_1d=mdspan< T, Extents1 >
template
using	span_2d=mdspan< T, Extents1, Extents2 >
template
using	span_3d=mdspan< T, Extents1, Extents2, Extents3 >
template
using	span_4d=mdspan< T, Extents1, Extents2, Extents3, Extents4 >
using	tile=detail::tile
using	tile_id=detail::tile_id
template
using	tiled_mdspan=detail::basic_tiled_mdspan< T, TileExtents,extents< Extents... >, void,detail::accessor_basic< T > >
template
using	tiled_span=tiled_span_1d< T, TileExtents, Extents1 >
template
using	tiled_span_1d=tiled_mdspan< T, TileExtents, Extents1 >
template
using	tiled_span_2d=tiled_mdspan< T, TileExtents, Extents1, Extents2 >
template
using	tiled_span_3d=tiled_mdspan< T, TileExtents, Extents1, Extents2, Extents3 >
template
using	tiled_span_4d=tiled_mdspan< T, TileExtents, Extents1, Extents2, Extents3, Extents4 >
template<ElemBaseTypeT, unsigned Elems = native_vector_length_v>
using	vector=detail::vector< T, Elems >
	More...
template<ElemBaseTypeT, unsigned N>
using	vector_elem_const_ref=detail::vector_elem_const_ref< T, N >
	More...
template<ElemBaseTypeT, unsigned N>
using	vector_elem_ref=detail::vector_elem_ref< T, N >
	More...
template<DecoratedElemBaseTypeT, unsigned Elems,aie_dm_resourceResource = aie_dm_resource::none>
using	vector_iterator=detail::vector_iterator< T, Elems, 1, Resource >

Enumerations
enum class	Operation{ None,Acc_Add,Acc_Sub,Abs, Conj,Max,Min }

Functions
template<ElemE>
constexpr auto	abs(const E &a) ->operand_base_type_t< E >
	More...
template<VectorVec>
constexpr auto	abs(const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
templateComplexVectorVec>
constexpr auto	abs_square(const Vec &v, int shift=0)
	More...
template
constexprvector< float, Elems >	abs_square(constvector< cfloat, Elems > &v)
	More...
templateAccumOrOpAcc,VectorVecCoeff = void,VectorVecData = void, Vector... NextVecData>
auto	accumulate(const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, const NextVecData &...next_data) ->operand_base_type_t< Acc >
	More...
templateAccumElemBaseTypeAccumTag = accauto,VectorVecCoeff = void,VectorVecData = void, Vector... NextVecData>
auto	accumulate(const VecCoeff &coeff, const VecData &data, const NextVecData &...next_data)
templateAccumElemBaseTypeAccumTag = accauto,VectorVecCoeff = void,VectorVecData = void, Vector... NextVecData>
auto	accumulate(const VecCoeff &coeff, unsigned coeff_start, const VecData &data, const NextVecData &...next_data) ->accum< std::conditional_t< std::is_same_v< AccumTag,accauto>,detail::default_accum_tag_t< typename VecCoeff::value_type, typename VecData::value_type >, AccumTag >, Lanes >
	More...
template<AccumAcc,VectorVec>
Acc	add(const Acc &acc, const Vec &v)
	More...
template<AccumAcc,ElemE>
Acc	add(const Acc &acc, E a)
	More...
template<VectorVec,ElemE>
auto	add(const Vec &v, E a) ->aie_dm_resource_remove_t< Vec >
	More...
template<VectorVec1,VectorVec2>
auto	add(const Vec1 &v1, const Vec2 &v2) ->aie_dm_resource_remove_t< Vec1 >
	More...
template<ElemE,VectorVec>
auto	add(E a, const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
template
T	add(T a, T b)
template<VectorVec>
Vec::value_type	add_reduce(const Vec &v)
template<VectorVec, Vector... Others>
auto	add_reduce_v(const Vec &v, const Others &... others) ->aie_dm_resource_remove_t< Vec >
templateaie_dm_resourceResource = aie_dm_resource::none, typename T = void>
constexpr auto	begin_circular(T *base)
	More...
template<aie_dm_resourceResource = aie_dm_resource::none, typename T = void>
constexpr auto	begin_circular(T *base, size_t n)
	More...
template<aie_dm_resourceResource = aie_dm_resource::none, typename T = void, size_t Elems = 0>
constexpr auto	begin_circular(T(&base)[Elems])
	More...
template
constexpr auto	begin_pattern(T *base, Offsets &&... offsets)
template
constexpr auto	begin_random_circular(T *base)
	More...
template
constexpr auto	begin_random_circular(T *base, size_t n)
	More...
template
constexpr auto	begin_random_circular(T(&base)[Elems])
	More...
templateaie_dm_resourceResource = aie_dm_resource::none,DecoratedElemBaseTypeT = void>
constexpr auto	begin_restrict_vector(const T *base)
	More...
templateaie_dm_resourceResource = aie_dm_resource::none,DecoratedElemBaseTypeT = void>
constexpr auto	begin_restrict_vector(T *base)
	More...
templateaie_dm_resourceResource = aie_dm_resource::none,DecoratedElemBaseTypeT = void>
constexpr auto	begin_vector(const T *base)
	More...
templateaie_dm_resourceResource = aie_dm_resource::none,DecoratedElemBaseTypeT = void>
constexpr auto	begin_vector(T *base)
	More...
templateaie_dm_resourceResource = aie_dm_resource::none, typename T = void>
constexpr auto	begin_vector_circular(T *base)
	More...
templateaie_dm_resourceResource = aie_dm_resource::none, typename T = void>
constexpr auto	begin_vector_circular(T *base, size_t n)
	More...
templateaie_dm_resourceResource = aie_dm_resource::none, typename T = void, size_t ArrayElems = 0>
constexpr auto	begin_vector_circular(T(&base)[ArrayElems])
	More...
templateaie_dm_resourceResource = aie_dm_resource::none, DecoratedElemBaseType... Types>
constexpr auto	begin_vectors(Types *...ptrs)
template<VectorVec1,VectorVec2>
auto	bit_and(const Vec1 &v1, const Vec2 &v2) ->aie_dm_resource_remove_t< Vec1 >
	More...
template<ElemE,VectorVec>
auto	bit_and(E a, const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
template<VectorVec>
auto	bit_not(const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
template<VectorVec1,VectorVec2>
auto	bit_or(const Vec1 &v1, const Vec2 &v2) ->aie_dm_resource_remove_t< Vec1 >
	More...
template<ElemE,VectorVec>
auto	bit_or(E a, const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
template<VectorVec1,VectorVec2>
auto	bit_xor(const Vec1 &v1, const Vec2 &v2) ->aie_dm_resource_remove_t< Vec1 >
	More...
template<ElemE,VectorVec>
auto	bit_xor(E a, const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
template<ElemE, unsigned Elems = native_vector_length_v>
vector<operand_base_type_t< E >, Elems >	broadcast(E a)
	More...
templateaie_dm_resourceResource = aie_dm_resource::none, typename T = void>
constexprconst_circular_iterator< T, Elems, Resource >	cbegin_circular(const T *base)
	More...
template<aie_dm_resourceResource = aie_dm_resource::none, typename T = void>
constexprconst_circular_iterator< T, dynamic_extent, Resource >	cbegin_circular(const T *base, size_t n)
	More...
template<aie_dm_resourceResource = aie_dm_resource::none, typename T = void, size_t Elems = 0>
constexprconst_circular_iterator< T, Elems, Resource >	cbegin_circular(const T(&base)[Elems])
	More...
template
constexprconst_pattern_iterator< T, Steps >	cbegin_pattern(const T *base, Offsets &&... offsets)
template
constexpr auto	cbegin_random_circular(const T *base)
	More...
template
constexpr auto	cbegin_random_circular(const T *base, size_t n)
	More...
template
constexpr auto	cbegin_random_circular(const T(&base)[Elems])
	More...
templateaie_dm_resourceResource = aie_dm_resource::none,DecoratedElemBaseTypeT = void>
constexpr auto	cbegin_restrict_vector(const T *base)
	More...
templateaie_dm_resourceResource = aie_dm_resource::none,DecoratedElemBaseTypeT = void>
constexpr auto	cbegin_vector(const T *base)
	More...
templateaie_dm_resourceResource = aie_dm_resource::none, typename T = void>
constexpr auto	cbegin_vector_circular(const T *base)
	More...
templateaie_dm_resourceResource = aie_dm_resource::none, typename T = void>
constexpr auto	cbegin_vector_circular(const T *base, size_t n)
	More...
templateaie_dm_resourceResource = aie_dm_resource::none, typename T = void, size_t ArrayElems = 0>
constexpr auto	cbegin_vector_circular(const T(&base)[ArrayElems])
	More...
templateaie_dm_resourceResource = aie_dm_resource::none, DecoratedElemBaseType... Types>
constexpr auto	cbegin_vectors(const Types *...ptrs)
template<AccumAcc, Accum... Accums>
auto	concat(const Acc &acc, const Accums &...accums) ->accum< typename Acc::value_type, Acc::size() *(1+sizeof...(Accums))>
	More...
template<VectorVec, Vector... Vectors>
auto	concat(const Vec &v, const Vectors &...vectors) ->vector< typename Vec::value_type, Vec::size() *(1+sizeof...(Vectors))>
	More...
template<ComplexElemE>
constexpr auto	conj(const E &a) ->operand_base_type_t< E >
	More...
template<ComplexVectorVec>
auto	conj(const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
template<ElemE,VectorVec>
bool	contains(E a, const Vec &v)
template<RealVectorVec>
auto	cos(const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
template
auto	cos(E a)
	More...
float	div(float a, float b)
template<VectorVec>
constexpr auto	downshift(const Vec &v, unsigned shift) ->aie_dm_resource_remove_t< Vec >
	More...
template<VectorVec,ElemE>
mask< Vec::size()>	eq(const Vec &v, E a)
	More...
template<VectorVec1,VectorVec2>
mask< Vec1::size()>	eq(const Vec1 &v1, const Vec2 &v2)
	More...
template<ElemE,VectorVec>
mask< Vec::size()>	eq(E a, const Vec &v)
	More...
template
bool	eq(T a, T b)
	More...
template<VectorVec1,VectorVec2>
constexpr bool	equal(const Vec1 &v1, const Vec2 &v2)
	More...
template<VectorVec>
auto	filter_even(const Vec &v, unsigned step=1) ->vector< typename Vec::value_type, Vec::size()/2 >
	More...
template<VectorVec>
auto	filter_odd(const Vec &v, unsigned step=1) ->vector< typename Vec::value_type, Vec::size()/2 >
	More...
template<RealVectorVec,RealElemE>
mask< Vec::size()>	ge(const Vec &v, E a)
	More...
template<RealVectorVec1,RealVectorVec2>
mask< Vec1::size()>	ge(const Vec1 &v1, const Vec2 &v2)
	More...
template<RealElemE,RealVectorVec>
mask< Vec::size()>	ge(E a, const Vec &v)
	More...
template
bool	ge(T a, T b)
	More...
template<RealVectorVec,RealElemE>
mask< Vec::size()>	gt(const Vec &v, E a)
	More...
template<RealVectorVec1,RealVectorVec2>
mask< Vec1::size()>	gt(const Vec1 &v1, const Vec2 &v2)
	More...
template<RealElemE,RealVectorVec>
mask< Vec::size()>	gt(E a, const Vec &v)
	More...
template
bool	gt(T a, T b)
	More...
template<VectorVec1,VectorVec2>
auto	interleave_butterfly(const Vec1 &v1, const Vec2 &v2, unsigned step) -> std::pair<aie_dm_resource_remove_t< Vec1 >,aie_dm_resource_remove_t< Vec1 >>
template<VectorVec1,VectorVec2>
auto	interleave_butterfly_half(const Vec1 &v1, const Vec2 &v2, unsigned step) -> std::pair<aie_dm_resource_remove_t< Vec1 >,aie_dm_resource_remove_t< Vec1 >>
template<VectorVec1,VectorVec2>
auto	interleave_crossover(const Vec1 &v1, const Vec2 &v2, unsigned step) -> std::pair<aie_dm_resource_remove_t< Vec1 >,aie_dm_resource_remove_t< Vec1 >>
template<VectorVec1,VectorVec2, typename... Select>
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 >>
templateVectorVec1,VectorVec2>
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<VectorVec1,VectorVec2>
auto	interleave_unzip(const Vec1 &v1, const Vec2 &v2, unsigned step) -> std::pair<aie_dm_resource_remove_t< Vec1 >,aie_dm_resource_remove_t< Vec1 >>
	More...
template<VectorVec1,VectorVec2>
auto	interleave_zip(const Vec1 &v1, const Vec2 &v2, unsigned step) -> std::pair<aie_dm_resource_remove_t< Vec1 >,aie_dm_resource_remove_t< Vec1 >>
	More...
template
accum< accfloat, Elems >	inv(constaccum< accfloat, Elems > &v)
template<VectorVec>
auto	inv(const Vec &v) ->aie_dm_resource_remove_t< Vec >
template<ElemE>
auto	inv(E a)
template
accum< accfloat, Elems >	invsqrt(constaccum< accfloat, Elems > &v)
template<VectorVec>
auto	invsqrt(const Vec &v) ->aie_dm_resource_remove_t< Vec >
template<ElemE>
auto	invsqrt(E a)
template<RealVectorVec,RealElemE>
mask< Vec::size()>	le(const Vec &v, E a)
	More...
template<RealVectorVec1,RealVectorVec2>
mask< Vec1::size()>	le(const Vec1 &v1, const Vec2 &v2)
	More...
template<RealElemE,RealVectorVec>
mask< Vec::size()>	le(E a, const Vec &v)
	More...
template
bool	le(T a, T b)
	More...
templateaie_dm_resourceResource = aie_dm_resource::none,DecoratedElemBaseTypeT = void>
auto	load_floor_bytes_v(const T *ptr, size_t bytes) ->vector<aie_dm_resource_remove_t< T >, Elems >
	More...
templateaie_dm_resourceResource = aie_dm_resource::none,DecoratedElemBaseTypeT = void>
auto	load_floor_v(const T *ptr, unsigned n=Elems) ->vector<aie_dm_resource_remove_t< T >, Elems >
	More...
templateaie_dm_resourceResource = aie_dm_resource::none,DecoratedElemBaseTypeT = void>
auto	load_unaligned_v(const T *ptr, unsigned aligned_elems=1) ->vector<aie_dm_resource_remove_t< T >, Elems >
	More...
template<aie_dm_resourceResource = aie_dm_resource::none,DecoratedElemBaseTypeT = void>
auto	load_unaligned_v(const T *ptr, unsigned aligned_elems=1) ->vector<aie_dm_resource_remove_t< T >, native_vector_length_v< T >>
	More...
templateaie_dm_resourceResource = aie_dm_resource::none,DecoratedElemBaseTypeT = void>
auto	load_v(const T *ptr) ->vector<aie_dm_resource_remove_t< T >, Elems >
	More...
template<aie_dm_resourceResource = aie_dm_resource::none,DecoratedElemBaseTypeT = void>
auto	load_v(const T *ptr) ->vector<aie_dm_resource_remove_t< T >, native_vector_length_v< T >>
	More...
template<RealVectorVec,RealElemE>
mask< Vec::size()>	lt(const Vec &v, E a)
	More...
template<RealVectorVec1,RealVectorVec2>
mask< Vec1::size()>	lt(const Vec1 &v1, const Vec2 &v2)
	More...
template<RealElemE,RealVectorVec>
mask< Vec::size()>	lt(E a, const Vec &v)
	More...
template
bool	lt(T a, T b)
	More...
template<AccumOrOpAcc,VectorOrOpVec,ElemOrOpE>
constexpr auto	mac(const Acc &acc, const Vec &v, E a) ->operand_base_type_t< Acc >
	More...
template<AccumOrOpAcc,VectorOrOpVec1,VectorOrOpVec2>
constexpr auto	mac(const Acc &acc, const Vec1 &v1, const Vec2 &v2) ->operand_base_type_t< Acc >
	More...
template<AccumOrOpAcc,ElemOrOpE,VectorOrOpVec>
constexpr auto	mac(const Acc &acc, E a, const Vec &v) ->operand_base_type_t< Acc >
	More...
template
TR	mac(TR c, T1 a, T2 b)
template<AccumOrOpAcc,VectorVec>
constexpr auto	mac_square(const Acc &acc, const Vec &v)
	More...
template<RealVectorVec,RealElemE>
auto	max(const Vec &v, E a) ->aie_dm_resource_remove_t< Vec >
	More...
template<RealVectorVec1,RealVectorVec2>
auto	max(const Vec1 &v1, const Vec2 &v2) ->aie_dm_resource_remove_t< Vec1 >
	More...
template<RealElemE,RealVectorVec>
auto	max(E a, const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
template
T	max(T a, T b)
	More...
template<RealVectorVec1,RealVectorVec2>
auto	max_cmp(const Vec1 &v1, const Vec2 &v2) -> std::tuple<aie_dm_resource_remove_t< Vec1 >,mask< Vec1::size()>>
template<RealVectorVec>
Vec::value_type	max_reduce(const Vec &v)
template<RealVectorVec,RealElemE>
auto	maxdiff(const Vec &v, E a) ->aie_dm_resource_remove_t< Vec >
template<RealVectorVec1,RealVectorVec2>
auto	maxdiff(const Vec1 &v1, const Vec2 &v2) ->aie_dm_resource_remove_t< Vec1 >
template<RealElemE,RealVectorVec>
auto	maxdiff(E a, const Vec &v) ->aie_dm_resource_remove_t< Vec >
template<RealVectorVec,RealElemE>
auto	min(const Vec &v, E a) ->aie_dm_resource_remove_t< Vec >
	More...
template<RealVectorVec1,RealVectorVec2>
auto	min(const Vec1 &v1, const Vec2 &v2) ->aie_dm_resource_remove_t< Vec1 >
	More...
template<RealElemE,RealVectorVec>
auto	min(E a, const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
template
T	min(T a, T b)
	More...
template<RealVectorVec1,RealVectorVec2>
auto	min_cmp(const Vec1 &v1, const Vec2 &v2) -> std::tuple<aie_dm_resource_remove_t< Vec1 >,mask< Vec1::size()>>
template<RealVectorVec>
Vec::value_type	min_reduce(const Vec &v)
templateAccumAcc,VectorVecA,VectorVecB>
auto	mmac_fn(Acc &c, const VecA &a, const VecB &b)
templateAccumElemBaseTypeAccumTag = accauto,VectorVecA = void,VectorVecB = void>
auto	mmul_fn(const VecA &a, const VecB &b)
template<AccumAcc,VectorOrOpVec,ElemOrOpE>
constexpr auto	msc(const Acc &acc, const Vec &v, E a) ->aie_dm_resource_remove_t< Acc >
	More...
template<AccumAcc,VectorOrOpVec1,VectorOrOpVec2>
constexpr auto	msc(const Acc &acc, const Vec1 &v1, const Vec2 &v2) ->aie_dm_resource_remove_t< Acc >
	More...
template<AccumAcc,ElemOrOpE,VectorOrOpVec>
constexpr auto	msc(const Acc &acc, E a, const Vec &v) ->aie_dm_resource_remove_t< Acc >
	More...
template
TR	msc(TR c, T1 a, T2 b)
template<AccumAcc,VectorVec>
constexpr auto	msc_square(const Acc &acc, const Vec &v)
	More...
template<VectorOrOpVec,ElemOrOpE>
constexpr auto	mul(const Vec &v, E a)
	More...
template<AccumElemBaseTypeAccumTag,VectorOrOpVec,ElemOrOpE>
constexpr auto	mul(const Vec &v, E a) ->accum< AccumTag, Vec::size()>
	More...
template<VectorOrOpVec1,VectorOrOpVec2>
constexpr auto	mul(const Vec1 &v1, const Vec2 &v2)
	More...
template<AccumElemBaseTypeAccumTag,VectorOrOpVec1,VectorOrOpVec2>
constexpr auto	mul(const Vec1 &v1, const Vec2 &v2) ->accum< AccumTag, Vec1::size()>
	More...
template<ElemOrOpE,VectorOrOpVec>
constexpr auto	mul(E a, const Vec &v)
	More...
template<AccumElemBaseTypeAccumTag,ElemOrOpE,VectorOrOpVec>
constexpr auto	mul(E a, const Vec &v) ->accum< AccumTag, Vec::size()>
	More...
template
auto	mul(T1 a, T2 b)
template<AccumElemBaseTypeAccumTag,VectorVec>
Vec::value_type	mul_reduce(const Vec &v)
template<VectorVec>
constexpr Vec::value_type	mul_reduce(const Vec &v)
template<VectorVec>
constexpr auto	mul_square(const Vec &v)
	More...
template<AccumElemBaseTypeAccumTag,VectorVec>
constexpr auto	mul_square(const Vec &v) ->accum< AccumTag, Vec::size()>
	More...
template<ElemE>
constexpr auto	neg(const E &a) ->operand_base_type_t< E >
	More...
template<VectorVec>
constexpr auto	neg(const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
template<VectorOrOpVec,ElemOrOpE>
constexpr auto	negmul(const Vec &v, E a)
	More...
template<AccumElemBaseTypeAccumTag,VectorOrOpVec,ElemOrOpE>
constexpr auto	negmul(const Vec &v, E a) ->accum< AccumTag, Vec::size()>
	More...
template<VectorOrOpVec1,VectorOrOpVec2>
constexpr auto	negmul(const Vec1 &v1, const Vec2 &v2)
	More...
template<AccumElemBaseTypeAccumTag,VectorOrOpVec1,VectorOrOpVec2>
constexpr auto	negmul(const Vec1 &v1, const Vec2 &v2) ->accum< AccumTag, Vec1::size()>
	More...
template<ElemOrOpE,VectorOrOpVec>
constexpr auto	negmul(E a, const Vec &v)
	More...
template<AccumElemBaseTypeAccumTag,ElemOrOpE,VectorOrOpVec>
constexpr auto	negmul(E a, const Vec &v) ->accum< AccumTag, Vec::size()>
	More...
template<VectorVec,ElemE>
mask< Vec::size()>	neq(const Vec &v, E a)
	More...
template<VectorVec1,VectorVec2>
mask< Vec1::size()>	neq(const Vec1 &v1, const Vec2 &v2)
	More...
template<ElemE,VectorVec>
mask< Vec::size()>	neq(E a, const Vec &v)
	More...
template
bool	neq(T a, T b)
	More...
template<VectorVec1,VectorVec2>
constexpr bool	not_equal(const Vec1 &v1, const Vec2 &v2)
	More...
template
constexprunary_op< T,Operation::Abs>	op_abs(const T &e)
	More...
template<AccumAcc>
constexprunary_op< Acc,Operation::Acc_Add>	op_add(const Acc &acc)
	More...
template
constexprunary_op< T,Operation::Conj>	op_conj(const T &e)
	More...
template<VectorVec>
constexprbinary_op< Vec, Vec,Operation::Max>	op_max(const Vec &a, const Vec &b)
	More...
template<VectorVec>
constexprbinary_op< Vec, Vec,Operation::Min>	op_min(const Vec &a, const Vec &b)
	More...
template
constexprunary_op< T,Operation::None>	op_none(const T &e)
	More...
template<AccumAcc>
constexprunary_op< Acc,Operation::Acc_Sub>	op_sub(const Acc &acc)
	More...
template
void	print(constaie::mask< Elems > &m, bool nl=false, const char *prefix=nullptr)
template
void	print(constaie::vector< T, Elems > &v, bool nl=false, const char *prefix=nullptr)
template<VectorVec>
Vec::value_type	reduce_add(const Vec &v)
	More...
template<VectorVec, Vector... Others>
auto	reduce_add_v(const Vec &v, const Others &... others) ->aie_dm_resource_remove_t< Vec >
	More...
template<RealVectorVec>
Vec::value_type	reduce_max(const Vec &v)
	More...
template<RealVectorVec>
Vec::value_type	reduce_min(const Vec &v)
	More...
template<AccumElemBaseTypeAccumTag,VectorVec>
Vec::value_type	reduce_mul(const Vec &v)
template<VectorVec>
constexpr Vec::value_type	reduce_mul(const Vec &v)
template<VectorVec>
auto	reverse(const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
template<ElemE1,ElemE2,MaskM>
vector<operand_base_type_t< E1 >, M::size()>	select(const E1 &a, const E2 &b, const M &m)
	More...
template<VectorVec,ElemE,MaskM>
auto	select(const Vec &v, E a, const M &m) ->aie_dm_resource_remove_t< Vec >
	More...
template<VectorVec1,VectorVec2,MaskM>
auto	select(const Vec1 &v1, const Vec2 &v2, const M &m) ->aie_dm_resource_remove_t< Vec1 >
	More...
template<ElemE,VectorVec,MaskM>
auto	select(E a, const Vec &v, const M &m) ->aie_dm_resource_remove_t< Vec >
	More...
template<VectorVec>
auto	shuffle_down(const Vec &v, unsigned n) ->aie_dm_resource_remove_t< Vec >
	More...
template<VectorVec>
auto	shuffle_down_fill(const Vec &v, const Vec &fill, unsigned n) ->aie_dm_resource_remove_t< Vec >
	More...
template<VectorVec>
auto	shuffle_down_rotate(const Vec &v, unsigned n) ->aie_dm_resource_remove_t< Vec >
	More...
template<VectorVec>
auto	shuffle_up(const Vec &v, unsigned n) ->aie_dm_resource_remove_t< Vec >
	More...
template<VectorVec>
auto	shuffle_up_fill(const Vec &v, const Vec &fill, unsigned n) ->aie_dm_resource_remove_t< Vec >
	More...
template<VectorVec>
auto	shuffle_up_replicate(const Vec &v, unsigned n) ->aie_dm_resource_remove_t< Vec >
	More...
template<VectorVec>
auto	shuffle_up_rotate(const Vec &v, unsigned n) ->aie_dm_resource_remove_t< Vec >
	More...
template<RealVectorVec>
auto	sin(const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
template
auto	sin(E a)
	More...
template<RealVectorVec>
auto	sincos(const Vec &v) -> std::pair<aie_dm_resource_remove_t< Vec >,aie_dm_resource_remove_t< Vec >>
	More...
template
auto	sincos(E a)
	More...
template<RealVectorVec>
auto	sincos_complex(const Vec &v) ->vector< std::conditional_t< Vec::is_floating_point(), cfloat, cint16 >, Vec::size()>
	More...
template
auto	sincos_complex(E a) -> std::conditional_t< detail::is_floating_point_v<operand_base_type_t< E >>, cfloat, cint16 >
	More...
templateAccumAcc = void,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mac(const Acc &acc, const VecCoeff &coeff, const VecData &data, unsigned data_start)
templateAccumAcc = void,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mac(const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
templateAccumAcc = void,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mac_antisym(const Acc &acc, const VecCoeff &coeff, const VecData &data, unsigned data_start)
templateAccumAcc = void,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mac_antisym(const Acc &acc, const VecCoeff &coeff, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
templateAccumAcc = void,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mac_antisym(const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
templateAccumAcc = void,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mac_antisym(const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
templateAccumAcc = void,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
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)
templateAccumAcc = void,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mac_antisym_uct(const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)
templateAccumAcc = void,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
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)
templateAccumAcc = void,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mac_sym(const Acc &acc, const VecCoeff &coeff, const VecData &data, unsigned data_start)
templateAccumAcc = void,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mac_sym(const Acc &acc, const VecCoeff &coeff, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
templateAccumAcc = void,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mac_sym(const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
templateAccumAcc = void,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mac_sym(const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
templateAccumAcc = void,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
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)
templateAccumAcc = void,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mac_sym_uct(const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)
templateAccumAcc = void,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
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)
templateAccumElemBaseTypeAccumTag = accauto,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mul(const VecCoeff &coeff, const VecData &data, unsigned data_start)
templateAccumElemBaseTypeAccumTag = accauto,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mul(const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
templateAccumElemBaseTypeAccumTag = accauto,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mul_antisym(const VecCoeff &coeff, const VecData &data, unsigned data_start)
templateAccumElemBaseTypeAccumTag = accauto, typename VecCoeff = void, typename VecData = void>
auto	sliding_mul_antisym(const VecCoeff &coeff, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
templateAccumElemBaseTypeAccumTag = accauto,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mul_antisym(const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
templateAccumElemBaseTypeAccumTag = accauto,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mul_antisym(const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
templateAccumElemBaseTypeAccumTag = accauto,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mul_antisym(const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
templateAccumElemBaseTypeAccumTag = accauto,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mul_antisym_uct(const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)
templateAccumElemBaseTypeAccumTag = accauto,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
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)
templateAccumElemBaseTypeAccumTag = accauto,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mul_sym(const VecCoeff &coeff, const VecData &data, unsigned data_start)
templateAccumElemBaseTypeAccumTag = accauto, typename VecCoeff = void, typename VecData = void>
auto	sliding_mul_sym(const VecCoeff &coeff, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
templateAccumElemBaseTypeAccumTag = accauto,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mul_sym(const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
templateAccumElemBaseTypeAccumTag = accauto,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mul_sym(const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
templateAccumElemBaseTypeAccumTag = accauto,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mul_sym(const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
templateAccumElemBaseTypeAccumTag = accauto,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
auto	sliding_mul_sym_uct(const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)
templateAccumElemBaseTypeAccumTag = accauto,VectorOrOpVecCoeff = void,VectorOrOpVecData = void>
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
accum< accfloat, Elems >	sqrt(constaccum< accfloat, Elems > &v)
template<VectorVec>
auto	sqrt(const Vec &v) ->aie_dm_resource_remove_t< Vec >
template<ElemE>
auto	sqrt(E a)
templateaie_dm_resourceResource = aie_dm_resource::none,DecoratedElemBaseTypeT1 = void,ElemBaseTypeT2 = void>
T1 *	store_unaligned_v(T1 *ptr, constvector< T2, Elems > &v, unsigned aligned_elems=1)
	More...
template<aie_dm_resourceResource = aie_dm_resource::none,DecoratedElemBaseTypeT1 = void,ElemBaseTypeT2, unsigned Elems = 0>
T1 *	store_v(T1 *ptr, constvector< T2, Elems > &v)
	More...
template<AccumAcc,VectorVec>
constexpr auto	sub(const Acc &acc, const Vec &v) ->aie_dm_resource_remove_t< Acc >
	More...
template<AccumAcc,ElemE>
auto	sub(const Acc &acc, E a) ->aie_dm_resource_remove_t< Acc >
	More...
template<VectorVec,ElemE>
auto	sub(const Vec &v, E a) ->aie_dm_resource_remove_t< Vec >
	More...
template<VectorVec1,VectorVec2>
auto	sub(const Vec1 &v1, const Vec2 &v2) ->aie_dm_resource_remove_t< Vec1 >
	More...
template<ElemE,VectorVec>
auto	sub(E a, const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
template
T	sub(T a, T b)
template
auto	to_fixed(constvector< T, Elems > &v, int shift=0) ->vector< std::conditional_t< std::is_same_v< T, float >,int32, cint32 >, Elems >
	More...
template
auto	to_fixed(T a, int shift=0)
	More...
template
auto	to_float(constvector< T, Elems > &v, int shift=0)
	More...
template
auto	to_float(T a, int shift=0)
	More...
templateVectorVec>
auto	transpose(const Vec &v) ->aie_dm_resource_remove_t< Vec >
template<VectorVec>
constexpr auto	upshift(const Vec &v, unsigned shift) ->aie_dm_resource_remove_t< Vec >
	More...
template<ElemBaseTypeDstT,VectorVec>
auto	vector_cast(const Vec &v)
	More...
template<ElemBaseTypeT>
constexpr T	zero()
	More...
template<ElemBaseTypeT, unsigned Elems = native_vector_length_v>
vector< T, Elems >	zeros()
	More...
template<AccumElemBaseTypeT, unsigned Elems = native_vector_length_v>
accum< T, Elems >	zeros()
	More...

---

Class Documentation

aie::accauto

struct aie::accauto

aie::accum

class aie::accum

template
class aie::accum< AccumTag, Elems >

aie::binary_op

struct aie::binary_op

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

aie::cfr

struct aie::cfr

template
struct aie::cfr< T >

aie::circular_iterator

struct aie::circular_iterator

template
struct aie::circular_iterator< T, Elems >

aie::const_circular_iterator

struct aie::const_circular_iterator

template
struct aie::const_circular_iterator< T, Elems >

aie::const_pattern_iterator

struct aie::const_pattern_iterator

template
struct aie::const_pattern_iterator< T, Steps >

aie::const_random_circular_iterator

struct aie::const_random_circular_iterator

template
struct aie::const_random_circular_iterator< T, Elems >

aie::const_restrict_vector_iterator

struct aie::const_restrict_vector_iterator

templateaie_dm_resourceResource = aie_dm_resource::none>
struct aie::const_restrict_vector_iterator< T, Elems, Resource >

aie::const_vector_iterator

struct aie::const_vector_iterator

templateaie_dm_resourceResource = aie_dm_resource::none>
struct aie::const_vector_iterator< T, Elems, Resource >

aie::fft_dit

struct aie::fft_dit

template
struct aie::fft_dit< Stage, Radix, T1, T2 >

aie::mask

class aie::mask

template
class aie::mask< Elems >

aie::op_result_helper

struct aie::op_result_helper

templateOperationOp>
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 >

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

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

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

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

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

Class Members
typedef T	type

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

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

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

Class Members
typedef T	type

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

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

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

Class Members
typedef Parent	type

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

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

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

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

aie::op_value_type_helper

struct aie::op_value_type_helper

template
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 > >

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

Class Members
typedef typename value_type	type

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

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

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

Class Members
typedef typename value_type	type

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

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

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

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

templateOperationOp>
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
struct aie::op_value_type_helper< vector< T, Elems > >

Class Members
typedef typename value_type	type

aie::operand_base_type

struct aie::operand_base_type

template
struct aie::operand_base_type< T >

Class Members
typedefaie_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 > >

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

Class Members
typedef typename value_type	type

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

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

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

Class Members
typedef T	type

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

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

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

Class Members
typedef T	type

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

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

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

Class Members
typedef typename value_type	type

aie::pattern_iterator

struct aie::pattern_iterator

template
struct aie::pattern_iterator< T, Steps >

aie::random_circular_iterator

struct aie::random_circular_iterator

template
struct aie::random_circular_iterator< T, Elems >

aie::restrict_vector_iterator

struct aie::restrict_vector_iterator

templateaie_dm_resourceResource = aie_dm_resource::none>
struct aie::restrict_vector_iterator< T, Elems, Resource >

aie::unary_op

struct aie::unary_op

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

aie::vector

class aie::vector

template
class aie::vector< T, Elems >

aie::vector_iterator

struct aie::vector_iterator

templateaie_dm_resourceResource = aie_dm_resource::none>
struct aie::vector_iterator< T, Elems, Resource >

Enumeration Type Documentation

Operation

enum classaie::Operation

strong

Enumerator
None
Acc_Add
Acc_Sub
Abs
Conj
Max
Min

Function Documentation

bit_and()

template< VectorVec1, VectorVec2>

auto aie::bit_and	(	const Vec1 &	v1,
		const Vec2 &	v2
	)		->aie_dm_resource_remove_t

Returns a vector with the bit-wise AND of the elements of the two input vectors. The vectors must have the same type and size.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = v1[i] & v2[i];
       

Parameters

v1	First input vector. The type must meetVector.
v2	Second input vector. The type must meetVector.

bit_not()

template< VectorVec>

auto aie::bit_not

(

const Vec &

v

)

->aie_dm_resource_remove_t

Returns a vector with the bit-wise NEG of the elements of the input vector.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = ~v[i];
       

Parameters

v	Input vector. The type must meetVector.

bit_or()

template< VectorVec1, VectorVec2>

auto aie::bit_or	(	const Vec1 &	v1,
		const Vec2 &	v2
	)		->aie_dm_resource_remove_t

Returns a vector with the bit-wise OR of the elements of the two input vectors. The vectors must have the same type and size.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = v1[i] | v2[i];
       

Parameters

v1	First input vector. The type must meetVector.
v2	Second input vector. The type must meetVector.

bit_xor()

template< VectorVec1, VectorVec2>

auto aie::bit_xor	(	const Vec1 &	v1,
		const Vec2 &	v2
	)		->aie_dm_resource_remove_t

Returns a vector with the bit-wise XOR of the elements of the two input vectors. The vectors must have the same type and size.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = v1[i] ^ v2[i];
       

Parameters

v1	First input vector. The type must meetVector.
v2	Second input vector. The type must meetVector.

downshift()

template< VectorVec>

constexpr auto aie::downshift ( const Vec & v, unsigned shift ) ->aie_dm_resource_remove_t

constexpr

Returns a vector with all values downshifted by specified number of bits

Parameters

v	Input vector
shift	Number of bits to downshift by

upshift()

template< VectorVec>

constexpr auto aie::upshift ( const Vec & v, unsigned shift ) ->aie_dm_resource_remove_t

constexpr

Returns a vector with all values upshifted by specified number of bits

Parameters

v	Input vector
shift	Number of bits to upshift by

zero()

template< ElemBaseTypeT>

constexpr T aie::zero ( )

constexpr

Returns the zero value for the requested data type.

Template Parameters

Requested

data type

zeros()

template< AccumElemBaseTypeT, unsigned Elems = native_vector_length_v>

accum aie::zeros

(

)

Returns a vector whose elements are initialized to zero.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = 0;
       

Template Parameters

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