AI Engine API User Guide (AIE) 2022.2
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< Parent1, Parent2, Operation::Sign >
 
struct  binary_op< Parent1, Parent2, Operation::Zero >
 
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< binary_op< Parent1, Parent2, Op > >
 
struct  is_accum_op< unary_op< Parent, Op > >
 
struct  is_binary_op
 
struct  is_binary_op< binary_op< Parent1, Parent2, Op > >
 
struct  is_complex_op
 
struct  is_complex_op< binary_op< Parent1, Parent2, Op > >
 
struct  is_complex_op< unary_op< Parent, Op > >
 
struct  is_elem_op
 
struct  is_elem_op< binary_op< Parent1, Parent2, Op > >
 
struct  is_elem_op< unary_op< Parent, Op > >
 
struct  is_mmul
 
struct  is_mmul< mmul< M, K, N, TypeA, TypeB, AccumTag > >
 
struct  is_mmul_op
 
struct  is_real_op
 
struct  is_same_vector
 
struct  is_same_vector< unaligned_vector_ref< T1, N >, vector_ref< T2, N, Resource > >
 
struct  is_same_vector< unaligned_vector_ref< T1, N, Resource >, vector< T2, N > >
 
struct  is_same_vector< unaligned_vector_ref< T1, N, Resource1 >, unaligned_vector_ref< T2, N, Resource2 > >
 
struct  is_same_vector< vector< T, N >, vector< T, N > >
 
struct  is_same_vector< vector< T1, N >, detail::unaligned_vector_ref< T2, N, Resource > >
 
struct  is_same_vector< vector< T1, N >, vector_ref< T2, N, Resource > >
 
struct  is_same_vector< vector_ref< T1, N >, unaligned_vector_ref< T2, N, Resource > >
 
struct  is_same_vector< vector_ref< T1, N, Resource >, vector< T2, N > >
 
struct  is_same_vector< vector_ref< T1, N, Resource1 >, vector_ref< T2, N, Resource2 > >
 
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< Parent, Operation::None >
 
struct  op_result_helper< unaligned_vector_ref< T, Elems, Resource >, Op >
 
struct  op_result_helper< unary_op< Parent, ParentOp >, Op >
 
struct  op_result_helper< vector_elem_const_ref< T, Elems >, Op >
 
struct  op_result_helper< vector_elem_ref< T, Elems >, Op >
 
struct  op_result_helper< vector_ref< T, Elems, Resource >, Op >
 
struct  op_value_type_helper
 
struct  op_value_type_helper< binary_op< Parent1, Parent2, Op > >
 
struct  op_value_type_helper< mmul< M, K, N, TypeA, TypeB, AccumTag > >
 
struct  op_value_type_helper< unaligned_vector_ref< T, Elems, Resource > >
 
struct  op_value_type_helper< unary_op< Parent, Op > >
 
struct  op_value_type_helper< vector< T, Elems > >
 
struct  op_value_type_helper< vector_elem_const_ref< T, Elems > >
 
struct  op_value_type_helper< vector_elem_ref< T, Elems > >
 
struct  op_value_type_helper< vector_ref< T, Elems, Resource > >
 
struct  operand_base_type
 
struct  operand_base_type< binary_op< Parent1, Parent2, Op > >
 
struct  operand_base_type< 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  tlast
 
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<AccumElemBaseType MinAccumTag, 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<unsigned MinAccumBits, unsigned Elems>
using cfp_accum = detail::accum< AccumClass::CFP, detail::to_native_accum_bits< AccumClass::CFP, MinAccumBits >(), Elems >
 
template<typename T >
using cfr = detail::cfr< T >
 
template<unsigned MinAccumBits, unsigned Elems>
using cint_accum = detail::accum< AccumClass::CInt, detail::to_native_accum_bits< AccumClass::CInt, MinAccumBits >(), Elems >
 
template<typename T , size_t Elems = dynamic_extent, aie_dm_resource Resource = aie_dm_resource::none>
using circular_iterator = detail::circular_iterator< T, Elems, 1, Resource >
  More...
 
template<typename T , size_t Elems = dynamic_extent, aie_dm_resource Resource = aie_dm_resource::none>
using const_circular_iterator = detail::const_circular_iterator< T, Elems, 1, Resource >
  More...
 
template<typename T , unsigned Steps>
using const_pattern_iterator = detail::const_pattern_iterator< T, Steps >
 
template<typename T , size_t Elems = dynamic_extent, aie_dm_resource Resource = aie_dm_resource::none>
using const_random_circular_iterator = detail::const_random_circular_iterator< T, Elems, 1, Resource >
  More...
 
template<DecoratedElemBaseType T, unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none>
using const_restrict_vector_iterator = detail::const_restrict_vector_iterator< T, Elems, 1, Resource >
 
template<DecoratedElemBaseType T, unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none>
using const_unaligned_vector_iterator = detail::unaligned_vector_iterator< T, Elems, Resource >
 
template<typename T , unsigned N, size_t Elems = dynamic_extent, aie_dm_resource Resource = aie_dm_resource::none>
using const_vector_circular_iterator = detail::const_vector_circular_iterator< T, N, Elems, 1, Resource >
  More...
 
template<DecoratedElemBaseType T, unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none>
using const_vector_iterator = detail::const_vector_iterator< T, Elems, 1, Resource >
 
template<typename T , unsigned Elems, size_t ArrayElems = dynamic_extent, aie_dm_resource Resource = aie_dm_resource::none>
using const_vector_random_circular_iterator = detail::const_vector_random_circular_iterator< T, Elems, ArrayElems, 1, Resource >
  More...
 
template<size_t... Extents>
using extents = detail::extents< Extents... >
 
template<unsigned Vectorization, unsigned Radix, typename T1 , typename T2 = T1>
using fft_dit = detail::fft_dit< Vectorization, detail::fft_get_stage< Vectorization, Radix, T1, T2 >(), Radix, T1, T2 >
  More...
 
template<unsigned MinAccumBits, unsigned Elems>
using fp_accum = detail::accum< AccumClass::FP, detail::to_native_accum_bits< AccumClass::FP, MinAccumBits >(), Elems >
 
template<unsigned MinAccumBits, unsigned Elems>
using int_accum = detail::accum< AccumClass::Int, detail::to_native_accum_bits< AccumClass::Int, MinAccumBits >(), Elems >
 
template<unsigned Elems>
using mask = detail::mask< Elems >
  More...
 
template<typename T , size_t... Extents>
using mdspan = detail::basic_mdspan< T, extents< Extents... >, void, detail::accessor_basic< T > >
 
template<typename T , Operation Op>
using op_result_type_t = typename op_result_helper< T, Op >::type
 
template<typename T >
using op_value_type_t = typename op_value_type_helper< aie_dm_resource_remove_t< T > >::type
 
template<typename T >
using operand_base_type_t = typename operand_base_type< Utils::remove_all_t< T > >::type
 
template<typename T , unsigned Steps>
using pattern_iterator = detail::pattern_iterator< T, Steps >
 
template<typename T , size_t Elems = dynamic_extent, aie_dm_resource Resource = aie_dm_resource::none>
using random_circular_iterator = detail::random_circular_iterator< T, Elems, 1, Resource >
  More...
 
template<typename T , size_t... Extents>
using restrict_mdspan = detail::basic_mdspan< T, extents< Extents... >, void, detail::accessor_restrict< T > >
 
template<typename T , size_t Extents1 = dynamic_extent>
using restrict_span = restrict_span_1d< T, Extents1 >
 
template<typename T , size_t Extents1 = dynamic_extent>
using restrict_span_1d = restrict_mdspan< T, Extents1 >
 
template<typename T , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent>
using restrict_span_2d = restrict_mdspan< T, Extents1, Extents2 >
 
template<typename T , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent>
using restrict_span_3d = restrict_mdspan< T, Extents1, Extents2, Extents3 >
 
template<typename T , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent, size_t Extents4 = dynamic_extent>
using restrict_span_4d = restrict_mdspan< T, Extents1, Extents2, Extents3, Extents4 >
 
template<typename T , typename TileExtents , size_t... Extents>
using restrict_tiled_mdspan = detail::basic_tiled_mdspan< T, TileExtents, extents< Extents... >, void, detail::accessor_restrict< T > >
 
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent>
using restrict_tiled_span = tiled_span_1d< T, TileExtents, Extents1 >
 
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent>
using restrict_tiled_span_1d = tiled_mdspan< T, TileExtents, Extents1 >
 
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent>
using restrict_tiled_span_2d = tiled_mdspan< T, TileExtents, Extents1, Extents2 >
 
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent>
using restrict_tiled_span_3d = tiled_mdspan< T, TileExtents, Extents1, Extents2, Extents3 >
 
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent, size_t Extents4 = dynamic_extent>
using restrict_tiled_span_4d = tiled_mdspan< T, TileExtents, Extents1, Extents2, Extents3, Extents4 >
 
template<DecoratedElemBaseType T, unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none>
using restrict_vector_iterator = detail::restrict_vector_iterator< T, Elems, 1, Resource >
 
template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using sliding_mul_sym_x_ops = sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, 1, CoeffType, DataType, AccumTag >
  More...
 
template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepXY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using sliding_mul_sym_xy_ops = sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepXY, DataStepXY, CoeffType, DataType, AccumTag >
  More...
 
template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using sliding_mul_sym_y_ops = sliding_mul_sym_ops< Lanes, Points, CoeffStep, 1, DataStepY, CoeffType, DataType, AccumTag >
  More...
 
template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using sliding_mul_x_ops = sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, 1, CoeffType, DataType, AccumTag >
  More...
 
template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepXY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using sliding_mul_xy_ops = sliding_mul_ops< Lanes, Points, CoeffStep, DataStepXY, DataStepXY, CoeffType, DataType, AccumTag >
  More...
 
template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using sliding_mul_y_ops = sliding_mul_ops< Lanes, Points, CoeffStep, 1, DataStepY, CoeffType, DataType, AccumTag >
  More...
 
template<typename T , size_t Extents1 = dynamic_extent>
using span = span_1d< T, Extents1 >
 
template<typename T , size_t Extents1 = dynamic_extent>
using span_1d = mdspan< T, Extents1 >
 
template<typename T , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent>
using span_2d = mdspan< T, Extents1, Extents2 >
 
template<typename T , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent>
using span_3d = mdspan< T, Extents1, Extents2, Extents3 >
 
template<typename T , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent, size_t Extents4 = dynamic_extent>
using span_4d = mdspan< T, Extents1, Extents2, Extents3, Extents4 >
 
using tile = detail::tile
 
using tile_id = detail::tile_id
 
template<typename T , typename TileExtents , size_t... Extents>
using tiled_mdspan = detail::basic_tiled_mdspan< T, TileExtents, extents< Extents... >, void, detail::accessor_basic< T > >
 
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent>
using tiled_span = tiled_span_1d< T, TileExtents, Extents1 >
 
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent>
using tiled_span_1d = tiled_mdspan< T, TileExtents, Extents1 >
 
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent>
using tiled_span_2d = tiled_mdspan< T, TileExtents, Extents1, Extents2 >
 
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent>
using tiled_span_3d = tiled_mdspan< T, TileExtents, Extents1, Extents2, Extents3 >
 
template<typename T , typename TileExtents , size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent, size_t Extents4 = dynamic_extent>
using tiled_span_4d = tiled_mdspan< T, TileExtents, Extents1, Extents2, Extents3, Extents4 >
 
template<DecoratedElemBaseType T, unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none>
using unaligned_vector_iterator = detail::unaligned_vector_iterator< T, Elems, Resource >
 
template<ElemBaseType T, unsigned Elems = native_vector_length_v<T>, aie_dm_resource Resource = aie_dm_resource::none>
using unaligned_vector_ref = detail::unaligned_vector_ref< T, Elems, Resource >
  More...
 
template<ElemBaseType T, unsigned Elems = native_vector_length_v<T>>
using vector = detail::vector< T, Elems >
  More...
 
template<typename T , unsigned N, size_t Elems = dynamic_extent, aie_dm_resource Resource = aie_dm_resource::none>
using vector_circular_iterator = detail::vector_circular_iterator< T, N, Elems, 1, Resource >
  More...
 
template<ElemBaseType T, unsigned N>
using vector_elem_const_ref = detail::vector_elem_const_ref< T, N >
  More...
 
template<ElemBaseType T, unsigned N>
using vector_elem_ref = detail::vector_elem_ref< T, N >
  More...
 
template<DecoratedElemBaseType T, unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none>
using vector_iterator = detail::vector_iterator< T, Elems, 1, Resource >
 
template<typename T , unsigned Elems, size_t ArrayElems = dynamic_extent, aie_dm_resource Resource = aie_dm_resource::none>
using vector_random_circular_iterator = detail::vector_random_circular_iterator< T, Elems, ArrayElems, 1, Resource >
  More...
 
template<ElemBaseType T, unsigned Elems = native_vector_length_v<T>, aie_dm_resource Resource = aie_dm_resource::none>
using vector_ref = detail::vector_ref< T, Elems, Resource >
  More...
 

Enumerations

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

Functions

template<Elem E>
constexpr auto abs (const E &a) -> operand_base_type_t< E >
  More...
 
template<Vector Vec>
constexpr auto abs (const Vec &v) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<typename TR = int32, ComplexVector Vec>
constexpr auto abs_square (const Vec &v, int shift=0)
  More...
 
template<unsigned Elems>
constexpr vector< float, Elems > abs_square (const vector< cfloat, Elems > &v)
  More...
 
template<unsigned Lanes, AccumOrOp Acc, Vector VecCoeff = void, Vector VecData = 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...
 
template<unsigned Lanes, unsigned CoeffStart = 0, AccumElemBaseType AccumTag = accauto, Vector VecCoeff = void, Vector VecData = void, Vector... NextVecData>
auto accumulate (const VecCoeff &coeff, const VecData &data, const NextVecData &...next_data)
 
template<unsigned Lanes, AccumElemBaseType AccumTag = accauto, Vector VecCoeff = void, Vector VecData = 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<Accum Acc, Vector Vec>
Acc add (const Acc &acc, const Vec &v)
  More...
 
template<Accum Acc, Elem E>
Acc add (const Acc &acc, E a)
  More...
 
template<Vector Vec, Elem E>
auto add (const Vec &v, E a) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<Vector Vec1, Vector Vec2>
auto add (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
  More...
 
template<Elem E, Vector Vec>
auto add (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<typename T >
add (T a, T b)
 
template<Vector Vec>
Vec::value_type add_reduce (const Vec &v)
 
template<Vector Vec, Vector... Others>
auto add_reduce_v (const Vec &v, const Others &... others) -> aie_dm_resource_remove_t< Vec >
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void, adf::buffer_port_direction Dir = adf::buffer_port_direction::kInput, typename Config = void>
constexpr auto begin (adf::buffer_port< T, Dir, Config > &port)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void, adf::buffer_port_direction Dir = adf::buffer_port_direction::kInput, typename Config = void>
constexpr auto begin (const adf::buffer_port< T, Dir, Config > &port)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr auto begin (T *base, size_t n)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void, unsigned Elems = 0>
constexpr auto begin (T(&base)[Elems])
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void, adf::buffer_port_direction Dir = adf::buffer_port_direction::kInput, typename Config = void>
constexpr auto begin_circular (adf::buffer_port< T, Dir, Config > &port)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void, adf::buffer_port_direction Dir = adf::buffer_port_direction::kInput, typename Config = void>
constexpr auto begin_circular (const adf::buffer_port< T, Dir, Config > &port)
  More...
 
template<size_t Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr auto begin_circular (T *base)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr auto begin_circular (T *base, size_t n)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void, size_t Elems = 0>
constexpr auto begin_circular (T(&base)[Elems])
  More...
 
template<unsigned Steps, typename T , typename... Offsets>
constexpr auto begin_pattern (T *base, Offsets &&... offsets)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void, adf::buffer_port_direction Dir = adf::buffer_port_direction::kInput, typename Config = void>
constexpr auto begin_random_circular (adf::buffer_port< T, Dir, Config > &port)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void, adf::buffer_port_direction Dir = adf::buffer_port_direction::kInput, typename Config = void>
constexpr auto begin_random_circular (const adf::buffer_port< T, Dir, Config > &port)
  More...
 
template<size_t Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr auto begin_random_circular (T *base)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr auto begin_random_circular (T *base, size_t n)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void, size_t Elems = 0>
constexpr auto begin_random_circular (T(&base)[Elems])
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T = void>
constexpr auto begin_restrict_vector (const T *base)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T = void>
constexpr auto begin_restrict_vector (T *base)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T = void>
constexpr auto begin_unaligned_vector (T *base)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void, adf::buffer_port_direction Dir = adf::buffer_port_direction::kInput, typename Config = void>
constexpr auto begin_vector (adf::buffer_port< T, Dir, Config > &port)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void, adf::buffer_port_direction Dir = adf::buffer_port_direction::kInput, typename Config = void>
constexpr auto begin_vector (const adf::buffer_port< T, Dir, Config > &port)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T = void>
constexpr auto begin_vector (const T *base)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T = void>
constexpr auto begin_vector (T *base)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void, adf::buffer_port_direction Dir = adf::buffer_port_direction::kInput, typename Config = void>
constexpr auto begin_vector_circular (adf::buffer_port< T, Dir, Config > &port)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void, adf::buffer_port_direction Dir = adf::buffer_port_direction::kInput, typename Config = void>
constexpr auto begin_vector_circular (const adf::buffer_port< T, Dir, Config > &port)
  More...
 
template<unsigned Elems, size_t ArrayElems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr auto begin_vector_circular (T *base)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr auto begin_vector_circular (T *base, size_t n)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void, size_t ArrayElems = 0>
constexpr auto begin_vector_circular (T(&base)[ArrayElems])
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void, adf::buffer_port_direction Dir = adf::buffer_port_direction::kInput, typename Config = void>
constexpr auto begin_vector_random_circular (adf::buffer_port< T, Dir, Config > &port)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void, adf::buffer_port_direction Dir = adf::buffer_port_direction::kInput, typename Config = void>
constexpr auto begin_vector_random_circular (const adf::buffer_port< T, Dir, Config > &port)
  More...
 
template<unsigned Elems, size_t ArrayElems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr auto begin_vector_random_circular (T *base)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr auto begin_vector_random_circular (T *base, size_t n)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void, size_t ArrayElems = 0>
constexpr auto begin_vector_random_circular (T(&base)[ArrayElems])
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType... Types>
constexpr auto begin_vectors (Types *...ptrs)
 
template<Vector Vec1, Vector Vec2>
auto bit_and (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
  More...
 
template<Elem E, Vector Vec>
auto bit_and (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<Vector Vec>
auto bit_not (const Vec &v) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<Vector Vec1, Vector Vec2>
auto bit_or (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
  More...
 
template<Elem E, Vector Vec>
auto bit_or (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<Vector Vec1, Vector Vec2>
auto bit_xor (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
  More...
 
template<Elem E, Vector Vec>
auto bit_xor (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<Elem E, unsigned Elems = native_vector_length_v<E>>
vector< operand_base_type_t< E >, Elems > broadcast (E a)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void, adf::buffer_port_direction Dir = adf::buffer_port_direction::kInput, typename Config = void>
constexpr auto cbegin (const adf::buffer_port< T, Dir, Config > &port)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr auto cbegin (const T *base, size_t n)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void, adf::buffer_port_direction Dir = adf::buffer_port_direction::kInput, typename Config = void>
constexpr auto cbegin_circular (const adf::buffer_port< T, Dir, Config > &port)
  More...
 
template<size_t Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr const_circular_iterator< T, Elems, Resource > cbegin_circular (const T *base)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr const_circular_iterator< T, dynamic_extent, Resource > cbegin_circular (const T *base, size_t n)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void, size_t Elems = 0>
constexpr const_circular_iterator< T, Elems, Resource > cbegin_circular (const T(&base)[Elems])
  More...
 
template<unsigned Steps, typename T , typename... Offsets>
constexpr const_pattern_iterator< T, Steps > cbegin_pattern (const T *base, Offsets &&... offsets)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void, adf::buffer_port_direction Dir = adf::buffer_port_direction::kInput, typename Config = void>
constexpr auto cbegin_random_circular (const adf::buffer_port< T, Dir, Config > &port)
  More...
 
template<size_t Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr auto cbegin_random_circular (const T *base)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr auto cbegin_random_circular (const T *base, size_t n)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void, size_t Elems = 0>
constexpr auto cbegin_random_circular (const T(&base)[Elems])
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T = void>
constexpr auto cbegin_restrict_vector (const T *base)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T = void>
constexpr auto cbegin_unaligned_vector (T *base)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void, adf::buffer_port_direction Dir = adf::buffer_port_direction::kInput, typename Config = void>
constexpr auto cbegin_vector (const adf::buffer_port< T, Dir, Config > &port)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T = void>
constexpr auto cbegin_vector (const T *base)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void, adf::buffer_port_direction Dir = adf::buffer_port_direction::kInput, typename Config = void>
constexpr auto cbegin_vector_circular (const adf::buffer_port< T, Dir, Config > &port)
  More...
 
template<unsigned Elems, size_t ArrayElems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr auto cbegin_vector_circular (const T *base)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr auto cbegin_vector_circular (const T *base, size_t n)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void, size_t ArrayElems = 0>
constexpr auto cbegin_vector_circular (const T(&base)[ArrayElems])
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void, adf::buffer_port_direction Dir = adf::buffer_port_direction::kInput, typename Config = void>
constexpr auto cbegin_vector_random_circular (const adf::buffer_port< T, Dir, Config > &port)
  More...
 
template<unsigned Elems, size_t ArrayElems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr auto cbegin_vector_random_circular (const T *base)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr auto cbegin_vector_random_circular (const T *base, size_t n)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, typename T = void, size_t ArrayElems = 0>
constexpr auto cbegin_vector_random_circular (const T(&base)[ArrayElems])
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType... Types>
constexpr auto cbegin_vectors (const Types *...ptrs)
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr auto cend (const T *base, size_t n)
  More...
 
template<Accum Acc, Accum... Accums>
auto concat (const Acc &acc, const Accums &...accums) -> accum< typename Acc::value_type, Acc::size() *(1+sizeof...(Accums))>
  More...
 
template<Vector Vec, Vector... Vectors>
auto concat (const Vec &v, const Vectors &...vectors) -> vector< typename Vec::value_type, Vec::size() *(1+sizeof...(Vectors))>
  More...
 
template<ComplexElem E>
constexpr auto conj (const E &a) -> operand_base_type_t< E >
  More...
 
template<ComplexVector Vec>
auto conj (const Vec &v) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<Elem E, Vector Vec>
bool contains (E a, const Vec &v)
 
template<RealVector Vec>
auto cos (const Vec &v) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<typename E >
auto cos (E a)
  More...
 
float div (float a, float b)
 
template<Vector Vec>
constexpr auto downshift (const Vec &v, unsigned shift) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void>
constexpr auto end (T *base, size_t n)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, typename T = void, unsigned Elems = 0>
constexpr auto end (T(&base)[Elems])
  More...
 
template<Vector Vec, Elem E>
mask< Vec::size()> eq (const Vec &v, E a)
  More...
 
template<Vector Vec1, Vector Vec2>
mask< Vec1::size()> eq (const Vec1 &v1, const Vec2 &v2)
  More...
 
template<Elem E, Vector Vec>
mask< Vec::size()> eq (E a, const Vec &v)
  More...
 
template<typename T >
bool eq (T a, T b)
  More...
 
template<Vector Vec1, Vector Vec2>
constexpr bool equal (const Vec1 &v1, const Vec2 &v2)
  More...
 
template<Vector Vec>
auto filter_even (const Vec &v, unsigned step=1) -> vector< typename Vec::value_type, Vec::size()/2 >
  More...
 
template<Vector Vec>
auto filter_odd (const Vec &v, unsigned step=1) -> vector< typename Vec::value_type, Vec::size()/2 >
  More...
 
template<AccumElemBaseType AccumTag, VectorOrOp Vec>
accum< AccumTag, Vec::size()> from_vector (const Vec &v, const int shift=0)
  More...
 
template<RealVector Vec, RealElem E>
mask< Vec::size()> ge (const Vec &v, E a)
  More...
 
template<RealVector Vec1, RealVector Vec2>
mask< Vec1::size()> ge (const Vec1 &v1, const Vec2 &v2)
  More...
 
template<RealElem E, RealVector Vec>
mask< Vec::size()> ge (E a, const Vec &v)
  More...
 
template<typename T >
bool ge (T a, T b)
  More...
 
template<RealVector Vec, RealElem E>
mask< Vec::size()> gt (const Vec &v, E a)
  More...
 
template<RealVector Vec1, RealVector Vec2>
mask< Vec1::size()> gt (const Vec1 &v1, const Vec2 &v2)
  More...
 
template<RealElem E, RealVector Vec>
mask< Vec::size()> gt (E a, const Vec &v)
  More...
 
template<typename T >
bool gt (T a, T b)
  More...
 
template<Vector Vec1, Vector Vec2>
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<Vector Vec1, Vector Vec2>
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<Vector Vec1, Vector Vec2>
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<Vector Vec1, Vector Vec2, 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 >>
 
template<unsigned S0, unsigned S1, unsigned S2, unsigned S3, unsigned S4, unsigned S5, unsigned S6, unsigned S7, unsigned S8, unsigned S9, unsigned S10, unsigned S11, unsigned S12, unsigned S13, unsigned S14, unsigned S15, unsigned S16, unsigned S17, unsigned S18, unsigned S19, unsigned S20, unsigned S21, unsigned S22, unsigned S23, unsigned S24, unsigned S25, unsigned S26, unsigned S27, unsigned S28, unsigned S29, unsigned S30, unsigned S31, Vector Vec1, Vector Vec2>
auto interleave_custom_static (const Vec1 &v1, const Vec2 &v2) -> std::pair< aie_dm_resource_remove_t< Vec1 >, aie_dm_resource_remove_t< Vec1 >>
 
template<Vector Vec1, Vector Vec2>
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<Vector Vec1, Vector Vec2>
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<unsigned Elems>
accum< accfloat, Elems > inv (const accum< accfloat, Elems > &v)
 
template<Vector Vec>
auto inv (const Vec &v) -> aie_dm_resource_remove_t< Vec >
 
template<Elem E>
auto inv (E a)
 
template<unsigned Elems>
accum< accfloat, Elems > invsqrt (const accum< accfloat, Elems > &v)
 
template<Vector Vec>
auto invsqrt (const Vec &v) -> aie_dm_resource_remove_t< Vec >
 
template<Elem E>
auto invsqrt (E a)
 
template<RealVector Vec, RealElem E>
mask< Vec::size()> le (const Vec &v, E a)
  More...
 
template<RealVector Vec1, RealVector Vec2>
mask< Vec1::size()> le (const Vec1 &v1, const Vec2 &v2)
  More...
 
template<RealElem E, RealVector Vec>
mask< Vec::size()> le (E a, const Vec &v)
  More...
 
template<typename T >
bool le (T a, T b)
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T = void>
auto load_floor_bytes_v (const T *ptr, size_t bytes) -> vector< aie_dm_resource_remove_t< T >, Elems >
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T = void>
auto load_floor_v (const T *ptr, unsigned n=Elems) -> vector< aie_dm_resource_remove_t< T >, Elems >
  More...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T = void>
auto load_unaligned_v (const T *ptr, unsigned aligned_elems=1) -> vector< aie_dm_resource_remove_t< T >, Elems >
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T = 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...
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T = void>
auto load_v (const T *ptr) -> vector< aie_dm_resource_remove_t< T >, Elems >
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T = void>
auto load_v (const T *ptr) -> vector< aie_dm_resource_remove_t< T >, native_vector_length_v< T >>
  More...
 
template<RealVector Vec, RealElem E>
mask< Vec::size()> lt (const Vec &v, E a)
  More...
 
template<RealVector Vec1, RealVector Vec2>
mask< Vec1::size()> lt (const Vec1 &v1, const Vec2 &v2)
  More...
 
template<RealElem E, RealVector Vec>
mask< Vec::size()> lt (E a, const Vec &v)
  More...
 
template<typename T >
bool lt (T a, T b)
  More...
 
template<AccumOrOp Acc, VectorOrOp Vec, ElemOrOp E>
constexpr auto mac (const Acc &acc, const Vec &v, E a) -> operand_base_type_t< Acc >
  More...
 
template<AccumOrOp Acc, VectorOrOp Vec1, VectorOrOp Vec2>
constexpr auto mac (const Acc &acc, const Vec1 &v1, const Vec2 &v2) -> operand_base_type_t< Acc >
  More...
 
template<AccumOrOp Acc, ElemOrOp E, VectorOrOp Vec>
constexpr auto mac (const Acc &acc, E a, const Vec &v) -> operand_base_type_t< Acc >
  More...
 
template<typename TR , typename T1 , typename T2 >
TR mac (TR c, T1 a, T2 b)
 
template<AccumOrOp Acc, Vector Vec>
constexpr auto mac_square (const Acc &acc, const Vec &v)
  More...
 
template<RealVector Vec, RealElem E>
auto max (const Vec &v, E a) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<RealVector Vec1, RealVector Vec2>
auto max (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
  More...
 
template<RealElem E, RealVector Vec>
auto max (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<typename T >
max (T a, T b)
  More...
 
template<RealVector Vec1, RealVector Vec2>
auto max_cmp (const Vec1 &v1, const Vec2 &v2) -> std::tuple< aie_dm_resource_remove_t< Vec1 >, mask< Vec1::size()>>
 
template<RealVector Vec>
Vec::value_type max_reduce (const Vec &v)
 
template<RealVector Vec, RealElem E>
auto maxdiff (const Vec &v, E a) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<RealVector Vec1, RealVector Vec2>
auto maxdiff (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
  More...
 
template<RealElem E, RealVector Vec>
auto maxdiff (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<RealVector Vec, RealElem E>
auto min (const Vec &v, E a) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<RealVector Vec1, RealVector Vec2>
auto min (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
  More...
 
template<RealElem E, RealVector Vec>
auto min (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<typename T >
min (T a, T b)
  More...
 
template<RealVector Vec1, RealVector Vec2>
auto min_cmp (const Vec1 &v1, const Vec2 &v2) -> std::tuple< aie_dm_resource_remove_t< Vec1 >, mask< Vec1::size()>>
 
template<RealVector Vec>
Vec::value_type min_reduce (const Vec &v)
 
template<unsigned M, unsigned K, unsigned N, typename Acc , Vector VecA, Vector VecB>
auto mmac_fn (Acc &c, const VecA &a, const VecB &b)
 
template<unsigned M, unsigned K, unsigned N, Accum Acc, Vector VecA, Vector VecB>
auto mmac_fn (const Acc &c, const VecA &a, const VecB &b)
 
template<unsigned M, unsigned K, unsigned N, AccumElemBaseType AccumTag = accauto, Vector VecA = void, Vector VecB = void>
auto mmul_fn (const VecA &a, const VecB &b)
 
template<Accum Acc, VectorOrOp Vec, ElemOrOp E>
constexpr auto msc (const Acc &acc, const Vec &v, E a) -> aie_dm_resource_remove_t< Acc >
  More...
 
template<Accum Acc, VectorOrOp Vec1, VectorOrOp Vec2>
constexpr auto msc (const Acc &acc, const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Acc >
  More...
 
template<Accum Acc, ElemOrOp E, VectorOrOp Vec>
constexpr auto msc (const Acc &acc, E a, const Vec &v) -> aie_dm_resource_remove_t< Acc >
  More...
 
template<typename TR , typename T1 , typename T2 >
TR msc (TR c, T1 a, T2 b)
 
template<Accum Acc, Vector Vec>
constexpr auto msc_square (const Acc &acc, const Vec &v)
  More...
 
template<VectorOrOp Vec, ElemOrOp E>
constexpr auto mul (const Vec &v, E a)
  More...
 
template<AccumElemBaseType AccumTag, VectorOrOp Vec, ElemOrOp E>
constexpr auto mul (const Vec &v, E a) -> accum< AccumTag, Vec::size()>
  More...
 
template<VectorOrOp Vec1, VectorOrOp Vec2>
constexpr auto mul (const Vec1 &v1, const Vec2 &v2)
  More...
 
template<AccumElemBaseType AccumTag, VectorOrOp Vec1, VectorOrOp Vec2>
constexpr auto mul (const Vec1 &v1, const Vec2 &v2) -> accum< AccumTag, Vec1::size()>
  More...
 
template<ElemOrOp E, VectorOrOp Vec>
constexpr auto mul (E a, const Vec &v)
  More...
 
template<AccumElemBaseType AccumTag, ElemOrOp E, VectorOrOp Vec>
constexpr auto mul (E a, const Vec &v) -> accum< AccumTag, Vec::size()>
  More...
 
template<typename T1 , typename T2 >
auto mul (T1 a, T2 b)
 
template<AccumElemBaseType AccumTag, Vector Vec>
Vec::value_type mul_reduce (const Vec &v)
 
template<Vector Vec>
constexpr Vec::value_type mul_reduce (const Vec &v)
 
template<Vector Vec>
constexpr auto mul_square (const Vec &v)
  More...
 
template<AccumElemBaseType AccumTag, Vector Vec>
constexpr auto mul_square (const Vec &v) -> accum< AccumTag, Vec::size()>
  More...
 
template<Elem E>
constexpr auto neg (const E &a) -> operand_base_type_t< E >
  More...
 
template<Vector Vec>
constexpr auto neg (const Vec &v) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<VectorOrOp Vec, ElemOrOp E>
constexpr auto negmul (const Vec &v, E a)
  More...
 
template<AccumElemBaseType AccumTag, VectorOrOp Vec, ElemOrOp E>
constexpr auto negmul (const Vec &v, E a) -> accum< AccumTag, Vec::size()>
  More...
 
template<VectorOrOp Vec1, VectorOrOp Vec2>
constexpr auto negmul (const Vec1 &v1, const Vec2 &v2)
  More...
 
template<AccumElemBaseType AccumTag, VectorOrOp Vec1, VectorOrOp Vec2>
constexpr auto negmul (const Vec1 &v1, const Vec2 &v2) -> accum< AccumTag, Vec1::size()>
  More...
 
template<ElemOrOp E, VectorOrOp Vec>
constexpr auto negmul (E a, const Vec &v)
  More...
 
template<AccumElemBaseType AccumTag, ElemOrOp E, VectorOrOp Vec>
constexpr auto negmul (E a, const Vec &v) -> accum< AccumTag, Vec::size()>
  More...
 
template<Vector Vec, Elem E>
mask< Vec::size()> neq (const Vec &v, E a)
  More...
 
template<Vector Vec1, Vector Vec2>
mask< Vec1::size()> neq (const Vec1 &v1, const Vec2 &v2)
  More...
 
template<Elem E, Vector Vec>
mask< Vec::size()> neq (E a, const Vec &v)
  More...
 
template<typename T >
bool neq (T a, T b)
  More...
 
template<Vector Vec1, Vector Vec2>
constexpr bool not_equal (const Vec1 &v1, const Vec2 &v2)
  More...
 
template<typename T >
constexpr unary_op< T, Operation::Absop_abs (const T &e)
  More...
 
template<Accum Acc>
constexpr unary_op< Acc, Operation::Acc_Addop_add (const Acc &acc)
  More...
 
template<typename T >
constexpr unary_op< T, Operation::Conjop_conj (const T &e)
  More...
 
template<VectorOrOp Vec1, VectorOrOp Vec2>
constexpr binary_op< Vec1, Vec2, Operation::Maxop_max (const Vec1 &a, const Vec2 &b)
  More...
 
template<VectorOrOp Vec1, VectorOrOp Vec2>
constexpr binary_op< Vec1, Vec2, Operation::Minop_min (const Vec1 &a, const Vec2 &b)
  More...
 
template<typename T >
constexpr unary_op< T, Operation::Noneop_none (const T &e)
  More...
 
template<typename T >
constexpr binary_op< T, bool, Operation::Signop_sign (const T &e, bool is_signed)
  More...
 
template<Accum Acc>
constexpr unary_op< Acc, Operation::Acc_Subop_sub (const Acc &acc)
  More...
 
template<Accum Acc>
constexpr binary_op< Acc, bool, Operation::Zeroop_zero (const Acc &acc, const bool to_zero)
  More...
 
template<VectorOrOp Vec, typename T2 = Utils::get_prev_integer_type_t<typename Vec::value_type>>
auto pack (const Vec &v) -> vector< T2, Vec::size()>
  More...
 
template<Accum Acc>
void print (const Acc &acc, bool nl=false, const char *prefix=nullptr)
 
template<unsigned N>
void print (const aie::mask< N > &m, bool nl=false, const char *prefix=nullptr)
 
template<typename T , unsigned Elems>
void print (const aie::vector< T, Elems > &v, bool nl=false, const char *prefix=nullptr)
 
template<typename T , unsigned Elems>
void print_matrix (const aie::vector< T, Elems > &v, unsigned cols, const char *prefix=nullptr)
 
template<Vector Vec>
Vec::value_type reduce_add (const Vec &v)
  More...
 
template<Vector Vec, Vector... Others>
auto reduce_add_v (const Vec &v, const Others &... others) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<RealVector Vec>
Vec::value_type reduce_max (const Vec &v)
  More...
 
template<RealVector Vec>
Vec::value_type reduce_min (const Vec &v)
  More...
 
template<AccumElemBaseType AccumTag, Vector Vec>
Vec::value_type reduce_mul (const Vec &v)
 
template<Vector Vec>
constexpr Vec::value_type reduce_mul (const Vec &v)
 
template<Vector Vec>
auto reverse (const Vec &v) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<Elem E1, Elem E2, Mask M>
vector< operand_base_type_t< E1 >, M::size()> select (const E1 &a, const E2 &b, const M &m)
  More...
 
template<Vector Vec, Elem E, Mask M>
auto select (const Vec &v, E a, const M &m) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<Vector Vec1, Vector Vec2, Mask M>
auto select (const Vec1 &v1, const Vec2 &v2, const M &m) -> aie_dm_resource_remove_t< Vec1 >
  More...
 
template<Elem E, Vector Vec, Mask M>
auto select (E a, const Vec &v, const M &m) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<Vector Vec>
auto shuffle_down (const Vec &v, unsigned n) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<Vector Vec>
auto shuffle_down_fill (const Vec &v, const Vec &fill, unsigned n) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<Vector Vec>
auto shuffle_down_replicate (const Vec &v, unsigned n) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<Vector Vec>
auto shuffle_down_rotate (const Vec &v, unsigned n) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<Vector Vec>
auto shuffle_up (const Vec &v, unsigned n) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<Vector Vec>
auto shuffle_up_fill (const Vec &v, const Vec &fill, unsigned n) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<Vector Vec>
auto shuffle_up_replicate (const Vec &v, unsigned n) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<Vector Vec>
auto shuffle_up_rotate (const Vec &v, unsigned n) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<RealVector Vec>
auto sin (const Vec &v) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<typename E >
auto sin (E a)
  More...
 
template<RealVector Vec>
auto sincos (const Vec &v) -> std::pair< aie_dm_resource_remove_t< Vec >, aie_dm_resource_remove_t< Vec >>
  More...
 
template<typename E >
auto sincos (E a)
  More...
 
template<RealVector Vec>
auto sincos_complex (const Vec &v) -> vector< std::conditional_t< Vec::is_floating_point(), cfloat, cint16 >, Vec::size()>
  More...
 
template<typename E >
auto sincos_complex (E a) -> std::conditional_t< detail::is_floating_point_v< operand_base_type_t< E >>, cfloat, cint16 >
  More...
 
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, Accum Acc = void, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mac (const Acc &acc, const VecCoeff &coeff, const VecData &data, unsigned data_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, Accum Acc = void, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mac (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, Accum Acc = void, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mac_antisym (const Acc &acc, const VecCoeff &coeff, const VecData &data, unsigned data_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, Accum Acc = void, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mac_antisym (const Acc &acc, const VecCoeff &coeff, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, Accum Acc = void, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mac_antisym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, Accum Acc = void, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mac_antisym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, Accum Acc = void, VectorOrOp VecCoeff = void, VectorOrOp VecData = 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)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, Accum Acc = void, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mac_antisym_uct (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, Accum Acc = void, VectorOrOp VecCoeff = void, VectorOrOp VecData = 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)
 
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, Accum Acc = void, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mac_sym (const Acc &acc, const VecCoeff &coeff, const VecData &data, unsigned data_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, Accum Acc = void, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mac_sym (const Acc &acc, const VecCoeff &coeff, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, Accum Acc = void, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mac_sym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, Accum Acc = void, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mac_sym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, Accum Acc = void, VectorOrOp VecCoeff = void, VectorOrOp VecData = 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)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, Accum Acc = void, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mac_sym_uct (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, Accum Acc = void, VectorOrOp VecCoeff = void, VectorOrOp VecData = 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)
 
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mul (const VecCoeff &coeff, const VecData &data, unsigned data_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mul (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mul_antisym (const VecCoeff &coeff, const VecData &data, unsigned data_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, typename VecCoeff = void, typename VecData = void>
auto sliding_mul_antisym (const VecCoeff &coeff, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mul_antisym (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mul_antisym (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mul_antisym (const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mul_antisym_uct (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff = void, VectorOrOp VecData = 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)
 
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mul_sym (const VecCoeff &coeff, const VecData &data, unsigned data_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStart = 0, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, typename VecCoeff = void, typename VecData = void>
auto sliding_mul_sym (const VecCoeff &coeff, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mul_sym (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mul_sym (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStepX = 1, int DataStepY = DataStepX, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mul_sym (const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff = void, VectorOrOp VecData = void>
auto sliding_mul_sym_uct (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)
 
template<unsigned Lanes, unsigned Points, int CoeffStep = 1, int DataStep = 1, AccumElemBaseType AccumTag = accauto, VectorOrOp VecCoeff = void, VectorOrOp VecData = 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<unsigned Elems>
accum< accfloat, Elems > sqrt (const accum< accfloat, Elems > &v)
 
template<Vector Vec>
auto sqrt (const Vec &v) -> aie_dm_resource_remove_t< Vec >
 
template<Elem E>
auto sqrt (E a)
 
template<unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T1 = void, ElemBaseType T2 = void>
T1 * store_unaligned_v (T1 *ptr, const vector< T2, Elems > &v, unsigned aligned_elems=1)
  More...
 
template<aie_dm_resource Resource = aie_dm_resource::none, DecoratedElemBaseType T1 = void, ElemBaseType T2, unsigned Elems = 0>
T1 * store_v (T1 *ptr, const vector< T2, Elems > &v)
  More...
 
template<Accum Acc, Vector Vec>
constexpr auto sub (const Acc &acc, const Vec &v) -> aie_dm_resource_remove_t< Acc >
  More...
 
template<Accum Acc, Elem E>
auto sub (const Acc &acc, E a) -> aie_dm_resource_remove_t< Acc >
  More...
 
template<Vector Vec, Elem E>
auto sub (const Vec &v, E a) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<Vector Vec1, Vector Vec2>
auto sub (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
  More...
 
template<Elem E, Vector Vec>
auto sub (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<typename T >
sub (T a, T b)
 
template<typename T >
 tlast (const T &, bool) -> tlast< const T &, bool >
 
template<typename T >
 tlast (T &, bool &) -> tlast< T &, bool & >
 
template<typename TR = cint32>
auto to_fixed (cfloat a, int shift=0)
  More...
 
template<typename TR = cint32, unsigned Elems = 0>
auto to_fixed (const vector< cfloat, Elems > &v, int shift=0) -> vector< TR, Elems >
  More...
 
template<typename TR = int32, unsigned Elems = 0>
auto to_fixed (const vector< float, Elems > &v, int shift=0) -> vector< TR, Elems >
  More...
 
template<typename TR = int32>
auto to_fixed (float a, int shift=0)
  More...
 
template<typename T , unsigned Elems>
auto to_float (const vector< T, Elems > &v, int shift=0)
  More...
 
template<Elem E>
auto to_float (E a, int shift=0)
  More...
 
template<typename TR , typename T >
vector< TR, T::size()> to_vector (const T &acc, const int shift=0)
  More...
 
template<Vector Vec>
auto transpose (const Vec &v, unsigned Row, unsigned Col) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<VectorOrOp Vec, typename T2 = Utils::get_next_integer_type_t<typename Vec::value_type>>
auto unpack (const Vec &v) -> vector< T2, Vec::size()>
  More...
 
template<Vector Vec>
constexpr auto upshift (const Vec &v, unsigned shift) -> aie_dm_resource_remove_t< Vec >
  More...
 
template<ElemBaseType DstT, Vector Vec>
auto vector_cast (const Vec &v)
  More...
 
template<ElemBaseType T>
constexpr T zero ()
  More...
 
template<ElemBaseType T, unsigned Elems = native_vector_length_v<T>>
vector< T, Elems > zeros ()
  More...
 
template<AccumElemBaseType AccumTag, unsigned Elems = native_vector_length_v<AccumTag>>
accum< AccumTag, Elems > zeros ()
  More...
 

Class Documentation

◆ aie::accauto

struct aie::accauto

◆ aie::accum

class aie::accum
template<typename AccumTag, unsigned Elems>
class aie::accum< AccumTag, Elems >

◆ aie::binary_op

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

◆ aie::cfr

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

◆ aie::circular_iterator

struct aie::circular_iterator
template<typename T, size_t Elems = dynamic_extent, aie_dm_resource Resource = aie_dm_resource::none>
struct aie::circular_iterator< T, Elems, Resource >

◆ aie::const_circular_iterator

struct aie::const_circular_iterator
template<typename T, size_t Elems = dynamic_extent, aie_dm_resource Resource = aie_dm_resource::none>
struct aie::const_circular_iterator< T, Elems, Resource >

◆ aie::const_pattern_iterator

struct aie::const_pattern_iterator
template<typename T, unsigned Steps>
struct aie::const_pattern_iterator< T, Steps >

◆ aie::const_random_circular_iterator

struct aie::const_random_circular_iterator
template<typename T, size_t Elems = dynamic_extent, aie_dm_resource Resource = aie_dm_resource::none>
struct aie::const_random_circular_iterator< T, Elems, Resource >

◆ aie::const_restrict_vector_iterator

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

◆ aie::const_vector_iterator

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

◆ aie::fft_dit

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

◆ aie::is_same_vector

struct aie::is_same_vector
template<Vector Vec1, Vector Vec2>
struct aie::is_same_vector< Vec1, Vec2 >

◆ aie::mask

class aie::mask
template<unsigned Elems>
class aie::mask< Elems >

◆ aie::op_result_helper

struct aie::op_result_helper
template<typename T, Operation Op>
struct aie::op_result_helper< T, Op >
Class Members
typedef T type

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

struct aie::op_result_helper< binary_op< Parent1, Parent2, ParentOp >, Op >
template<typename Parent1, typename Parent2, Operation ParentOp, Operation Op>
struct aie::op_result_helper< binary_op< Parent1, Parent2, ParentOp >, Op >
Class Members
typedef typename result_type, Op >::type type

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

struct aie::op_result_helper< Parent, Operation::None >
template<typename Parent>
struct aie::op_result_helper< Parent, Operation::None >
Class Members
typedef Parent type

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

struct aie::op_result_helper< unaligned_vector_ref< T, Elems, Resource >, Op >
template<typename T, unsigned Elems, aie_dm_resource Resource, Operation Op>
struct aie::op_result_helper< unaligned_vector_ref< T, Elems, Resource >, Op >
Class Members
typedef vector< T, Elems > type

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

struct aie::op_result_helper< unary_op< Parent, ParentOp >, Op >
template<typename Parent, Operation ParentOp, Operation Op>
struct aie::op_result_helper< unary_op< Parent, ParentOp >, Op >
Class Members
typedef typename result_type, Op >::type type

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

struct aie::op_result_helper< vector_elem_const_ref< T, Elems >, Op >
template<typename T, unsigned Elems, Operation Op>
struct aie::op_result_helper< vector_elem_const_ref< T, Elems >, Op >
Class Members
typedef T type

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

struct aie::op_result_helper< vector_elem_ref< T, Elems >, Op >
template<typename T, unsigned Elems, Operation Op>
struct aie::op_result_helper< vector_elem_ref< T, Elems >, Op >
Class Members
typedef T type

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

struct aie::op_result_helper< vector_ref< T, Elems, Resource >, Op >
template<typename T, unsigned Elems, aie_dm_resource Resource, Operation Op>
struct aie::op_result_helper< vector_ref< T, Elems, Resource >, Op >
Class Members
typedef vector< T, Elems > type

◆ aie::op_value_type_helper

struct aie::op_value_type_helper
template<typename T>
struct aie::op_value_type_helper< T >
Class Members
typedef T type

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

struct aie::op_value_type_helper< binary_op< Parent1, Parent2, Op > >
template<typename Parent1, typename Parent2, Operation Op>
struct aie::op_value_type_helper< binary_op< Parent1, Parent2, Op > >
Class Members
typedef typename value_type type

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

struct aie::op_value_type_helper< mmul< M, K, N, TypeA, TypeB, AccumTag > >
template<unsigned M, unsigned K, unsigned N, ElemBaseType TypeA, ElemBaseType TypeB, AccumElemBaseType AccumTag>
struct aie::op_value_type_helper< mmul< M, K, N, TypeA, TypeB, AccumTag > >
Class Members
typedef typename value_type type

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

struct aie::op_value_type_helper< unaligned_vector_ref< T, Elems, Resource > >
template<typename T, unsigned Elems, aie_dm_resource Resource>
struct aie::op_value_type_helper< unaligned_vector_ref< T, Elems, Resource > >
Class Members
typedef typename value_type type

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

struct aie::op_value_type_helper< unary_op< Parent, Op > >
template<typename Parent, Operation Op>
struct aie::op_value_type_helper< unary_op< Parent, Op > >
Class Members
typedef typename value_type type

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

struct aie::op_value_type_helper< vector< T, Elems > >
template<typename T, unsigned Elems>
struct aie::op_value_type_helper< vector< T, Elems > >
Class Members
typedef typename value_type type

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

struct aie::op_value_type_helper< vector_elem_const_ref< T, Elems > >
template<typename T, unsigned Elems>
struct aie::op_value_type_helper< vector_elem_const_ref< T, Elems > >
Class Members
typedef typename value_type type

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

struct aie::op_value_type_helper< vector_elem_ref< T, Elems > >
template<typename T, unsigned Elems>
struct aie::op_value_type_helper< vector_elem_ref< T, Elems > >
Class Members
typedef typename value_type type

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

struct aie::op_value_type_helper< vector_ref< T, Elems, Resource > >
template<typename T, unsigned Elems, aie_dm_resource Resource>
struct aie::op_value_type_helper< vector_ref< T, Elems, Resource > >
Class Members
typedef typename value_type type

◆ aie::operand_base_type

struct aie::operand_base_type
template<typename T>
struct aie::operand_base_type< T >
Class Members
typedef aie_dm_resource_remove_t< T > type

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

struct aie::operand_base_type< binary_op< Parent1, Parent2, Op > >
template<typename Parent1, typename Parent2, Operation Op>
struct aie::operand_base_type< binary_op< Parent1, Parent2, Op > >
Class Members
typedef typename value_type type

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

struct aie::operand_base_type< detail::vector_elem_const_ref< T, Elems > >
template<typename T, unsigned Elems>
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<typename T, unsigned Elems>
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 > >
template<typename Parent, Operation Op>
struct aie::operand_base_type< unary_op< Parent, Op > >
Class Members
typedef typename value_type type

◆ aie::pattern_iterator

struct aie::pattern_iterator
template<typename T, unsigned Steps>
struct aie::pattern_iterator< T, Steps >

◆ aie::random_circular_iterator

struct aie::random_circular_iterator
template<typename T, size_t Elems = dynamic_extent, aie_dm_resource Resource = aie_dm_resource::none>
struct aie::random_circular_iterator< T, Elems, Resource >

◆ aie::restrict_vector_iterator

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

◆ aie::unary_op

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

◆ aie::vector

class aie::vector
template<typename T, unsigned Elems>
class aie::vector< T, Elems >

◆ aie::vector_iterator

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

Enumeration Type Documentation

◆ Operation

enum class aie::Operation
strong
Enumerator
None 
Acc_Add 
Acc_Sub 
Abs 
Conj 
Max 
Min 
Sign 
Zero 

Function Documentation

◆ bit_and()

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

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

for (unsigned i = 0; i < Elems; ++i)
out[i] = v1[i] & v2[i];
Parameters
v1First input vector. The type must meet Vector.
v2Second input vector. The type must meet Vector.

◆ bit_not()

template<Vector Vec>
auto aie::bit_not ( const Vec &  v) -> aie_dm_resource_remove_t<Vec>

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

for (unsigned i = 0; i < Elems; ++i)
out[i] = ~v[i];
Parameters
vInput vector. The type must meet Vector.

◆ bit_or()

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

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

for (unsigned i = 0; i < Elems; ++i)
out[i] = v1[i] | v2[i];
Parameters
v1First input vector. The type must meet Vector.
v2Second input vector. The type must meet Vector.

◆ bit_xor()

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

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

for (unsigned i = 0; i < Elems; ++i)
out[i] = v1[i] ^ v2[i];
Parameters
v1First input vector. The type must meet Vector.
v2Second input vector. The type must meet Vector.

◆ downshift()

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

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

Parameters
vInput vector
shiftNumber of bits to downshift by

◆ upshift()

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

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

Parameters
vInput vector
shiftNumber of bits to upshift by

◆ zero()

template<ElemBaseType T>
constexpr T aie::zero ( )
constexpr

Returns the zero value for the requested data type.

Template Parameters
Requesteddata type

◆ zeros()

template<AccumElemBaseType AccumTag, unsigned Elems = native_vector_length_v<AccumTag>>
accum<AccumTag, Elems> aie::zeros ( )

Returns a vector whose elements are initialized to zero.

for (unsigned i = 0; i < Elems; ++i)
out[i] = 0;
Template Parameters
AccumTag.Accumulator tag.
Elems.Size of the accumulator.