| AI Engine API User Guide (AIE-API) 2025.2

Loading...
Searching...
No Matches
Namespaces | Classes | Concepts | Typedefs | Enumerations | Functions | Variables
aie Namespace Reference

## Detailed Description

Base namespace for AIE operations and types.

## Namespaces
namespace | operators
namespace | sync
namespace | utils

## Classes
class | accum
| Type for vector accumulators. More...
struct | arch
| Structure used to represent the AIE architecture being compiled against. More...
struct | back_idx
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 | binary_op_common_const
struct | binary_op_common_ref
struct | circular_index
class | circular_iterator
| Implements an iterator that wraps around when it reaches the end of the buffer and, thus, has no end. More...
struct | fft_dit
class | filter_mode
| Enables precomputation of the filter element selection. More...
struct | front_idx
class | interleave_unzip_mode
| Enables precomputation of the interleave element selection. More...
class | interleave_zip_mode
| Enables precomputation of the interleave element selection. More...
struct | is_accum_op
struct | is_accum_op< binary_op< Parent1, Parent2, Op > >
struct | is_accum_op< unary_op< Parent, Op > >
struct | is_binary_op
struct | is_binary_op< binary_op< Parent1, Parent2, Op > >
struct | is_block_vector_op
struct | is_complex_op
struct | is_complex_op< binary_op< Parent1, Parent2, Op > >
struct | is_complex_op< unary_op< Parent, Op > >
struct | is_elem
struct | is_elem_op
struct | is_elem_op< binary_op< Parent1, Parent2, Op > >
struct | is_elem_op< unary_op< Parent, Op > >
struct | is_lut
struct | is_lut< lut< ParallelAccesses, OffsetType, SlopeType > >
struct | is_mmul
struct | is_mmul< mmul< M, K, N, TypeA, TypeB, AccumTag > >
struct | is_mmul_op
struct | is_real_op
struct | is_same_vector
struct | is_same_vector< unaligned_vector_ref< T, N, Resource >, Vec >
struct | is_same_vector< vector< T, N >, vector< T, N > >
struct | is_same_vector< vector< T1, N1 >, unaligned_vector_ref< T2, N2, Resource > >
struct | is_same_vector< vector< T1, N1 >, vector_ref< T2, N2, Resource > >
struct | is_same_vector< vector_ref< T, N, Resource >, Vec >
struct | is_sparse_vector_op
struct | is_sparse_vector_op< binary_op< Parent1, Parent2, Op > >
struct | is_sparse_vector_op< unary_op< Parent, Op > >
struct | is_tbs
struct | is_tbs< detail::tbs< T, Elems, Level, NumLevels, SlidingInner, IterDesc, ResourceType, Resource, Mode, Restrict, U > >
struct | is_tbs_op
struct | is_tbs_op< binary_op< Parent1, Parent2, Op > >
struct | is_tbs_op< unary_op< Parent, Op > >
struct | is_unary_op
struct | is_unary_op< unary_op< Parent, Op > >
struct | is_valid_elem_op
struct | is_valid_mul_op
struct | is_valid_mul_op< binary_op< Parent1, Parent2, Op >, T2 >
struct | is_valid_mul_op< T, binary_op< Parent1, Parent2, Op > >
struct | is_valid_mul_op< T, unary_op< Parent, Op > >
struct | is_valid_mul_op< unary_op< Parent, Op >, T2 >
struct | is_valid_size
struct | is_valid_size< T, T2 >
struct | is_vector_op
struct | is_vector_op< binary_op< Parent1, Parent2, Op > >
struct | is_vector_op< unary_op< Parent, Op > >
struct | linear_approx
struct | loop_idx
struct | loop_options
| A structure containing options related to loop iteration peeling. More...
struct | lut
| Abstraction to represent a LUT that is stored in memory, instantiated with pointer(s) to the already appropriately populated memory and the number of elements. More...
class | mask
| Type for vector element masks. More...
struct | mmul
| Type that encapsulates a blocked matrix multiplication C = A x B. More...
struct | op_result_helper
struct | op_result_helper< binary_op< Parent1, Parent2, ParentOp >, Op >
struct | op_result_helper< detail::tbs< T, Elems, Level, NumLevels, SlidingInner, IterDesc, ResourceType, Resource, Mode, Restrict, U >, 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< detail::tbs< T, Elems, Level, NumLevels, SlidingInner, IterDesc, ResourceType, Resource, Mode, Restrict, U > >
struct | op_value_type_helper< mmul< M, K, N, TypeA, TypeB, AccumTag > >
struct | op_value_type_helper< sparse_vector< T, Elems > >
struct | op_value_type_helper< unaligned_vector_ref< T, Elems, Resource > >
struct | op_value_type_helper< unary_op< Parent, Op > >
struct | op_value_type_helper< vector< T, Elems > >
struct | op_value_type_helper< vector_elem_const_ref< T, Elems > >
struct | op_value_type_helper< vector_elem_ref< T, Elems > >
struct | op_value_type_helper< vector_ref< T, Elems, Resource > >
struct | operand_base_type
struct | operand_base_type< binary_op< Parent1, Parent2, Op > >
struct | operand_base_type< unary_op< Parent, Op > >
struct | operand_base_type< vector_elem_const_ref< T, Elems > >
struct | operand_base_type< vector_elem_ref< T, Elems > >
struct | parallel_lookup
class | partial_sliding_mul
| Object oriented interface to sliding_mul_ops. More...
class | pattern_iterator
struct | peel_idx
class | random_circular_iterator
| Implements an iterator that wraps around when it reaches the end or the beginning of the buffer and, thus, has no end. More...
class | restrict_vector_iterator
struct | result_type_helper
struct | result_type_helper< T >
class | scoped_mode
| Sets saturation/rounding mode in the current scope, restoring the existing mode upon exit. More...
struct | sliding_mul_ch_ops
struct | sliding_mul_ops
| This type provides a parametrized multiplication that implements the following compute pattern: More...
struct | sliding_mul_sym_ops
struct | sliding_mul_sym_uct_ops
class | sparse_vector
| Type for sparse vector registers. More...
class | sparse_vector_input_buffer_stream
| Implements an input stream that reads sparse vectors from a memory buffer. More...
class | tensor_descriptor
struct | tensor_dim
class | tile
struct | tile_id
| Identifies a particular tile within the AIE array. More...
struct | tlast
| Type used to wrap objects read/written from/to streams that also encapsulates TLAST information. More...
class | unaligned_vector_input_buffer_stream
| Implements an input stream that reads from a memory buffer with vector granularity. More...
class | unaligned_vector_iterator
| Implements an iterator that traverses an array using vectors instead of scalar values. More...
class | unaligned_vector_output_buffer_stream
| Implements an output stream that writes into a memory buffer with vector granularity. More...
class | unaligned_vector_ref
| Type for references to vector registers. More...
struct | unary_op
struct | unary_op< Parent, Operation::Abs >
struct | unary_op< Parent, Operation::Acc_Add >
struct | unary_op< Parent, Operation::Acc_Sub >
struct | unary_op< Parent, Operation::Conj >
struct | unary_op< Parent, Operation::None >
struct | unary_op< Parent, Operation::Transpose >
struct | unary_op_common
struct | unary_op_common_const
struct | unary_op_common_ref
class | vector
| Type for vector registers. More...
class | vector_circular_iterator
| Implements a vector iterator that wraps around when it reaches the end of the buffer and, thus, has no end. More...
class | vector_elem_const_ref
| Reference to immutable vector element. More...
class | vector_elem_ref
| Reference to vector element. More...
class | vector_input_buffer_stream
| Implements an input stream that reads from a memory buffer with vector granularity. More...
class | vector_iterator
| Implements an iterator that traverses an array using vectors instead of scalar values. More...
class | vector_output_buffer_stream
| Implements an output stream that writes into a memory buffer with vector granularity. More...
class | vector_random_circular_iterator
| Implements a vector iterator that wraps around when it reaches the end or the beginning of the buffer and, thus, has no end. More...
class | vector_ref
| Type for references to vector registers. More...

## Concepts
concept | TLast
concept | Mmul
concept | MmulOrOp
concept | TupleLike
| Accepts any type implementing tuple interface.
concept | ParallelLUT
concept | ElemBaseType
| Concept for all the basic types that can be used in operations and as vector element type.
concept | Elem
| Concept for element operands.
concept | ComplexElem
| Concept similar to aie::Elem, but it only accepts complex types.
concept | RealElem
| Concept similar to aie::Elem, but it only accepts real (i.e.
concept | ElemOrOp
| Concept that allows aie::Elem or an element operation modifier.
concept | Vector
| Concept for vector types.
concept | ComplexVector
| Similar to aie::Vector, but it only accepts vectors with complex element types.
concept | ComplexIntegralVector
| Similar to aie::ComplexVector, but it only accepts vectors with integral element types.
concept | ComplexFloatVector
| Similar to aie::ComplexVector, but it only accepts vectors with floating point element types.
concept | RealVector
| Similar to aie::Vector, but it only accepts vectors with real element types.
concept | VectorOrOp
| Concept that allows aie::Vector or a vector operation modifier.
concept | SparseVector
| Concept for vector types.
concept | SparseVectorOrOp
| Concept that allows aie::SparseVector or a vector operation modifier.
concept | Accum
| Concept for accumulator types.
concept | AccumOrOp
| Concept that allows aie::Accum or an accumulator operation modifier.
concept | Mask
| Concept for mask types.
concept | DecoratedElemBaseType
| Concept for the pointers to basic types that can be used in operations and as vector element type.
concept | DecoratedElemBaseOrBlockType
| Concept for the pointers to basic or block types that can be used in operations and as vector element type.
concept | AccumElemBaseType
| Concept for the supported accumulator element types.
concept | NativeVectorType
concept | NativeAccumType
concept | ArithmeticType
concept | PackableFrom
| The concept PackableFrom is satisfied when all the following requirements are met:
concept | TensorBufferStream
| Concept for a tensor buffer stream.
concept | TensorBufferStreamOp
| Concept for a tensor buffer stream with an operation modifier.
concept | IOBuffer
| Concept for an ADF io_buffer.
concept | AsyncIOBuffer
| Concept for an asynchronous ADF io_buffer.
concept | TensorBufferStreamOrOp
| Concept for a tensor buffer stream or an operation modifier.
concept | UnpackableFrom
| The concept UnpackableFrom is satisfied when all the following requirements are met:
concept | TensorDim
concept | NativeDim
concept | SlidingDim
concept | NativeOrSlidingDim

## Typedefs
template<AccumClass Class, unsigned Bits>
using | accum_tag_t
template<AccumClass Class, unsigned Bits>
using | accum_tag_t
template<AccumClass Class, unsigned Bits>
using | accum_tag_t
template<AccumClass Class, unsigned Bits>
using | accum_tag_t
using | AccumClass = detail::AccumClass
template<typename T>
using | cfr = detail::cfr<T>
template<typename T, size_t Size = dynamic_extent, aie_dm_resource Resource = aie_dm_resource::none>
using | const_circular_iterator = circular_iterator<const T, Size, Resource>
| Same as circular_iterator, but the contents of the iterated array cannot be modified.
template<typename T, unsigned Steps>
using | const_pattern_iterator = pattern_iterator<std::add_const_t<T>, Steps>
template<typename T, size_t Size, aie_dm_resource Resource = aie_dm_resource::none>
using | const_random_circular_iterator = random_circular_iterator<const T, Size, Resource>
| Same as random_circular_iterator, but the contents of the iterated array cannot be modified.
template<typename T, unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none>
using | const_restrict_vector_iterator = restrict_vector_iterator<const std::remove_const_t<T>, Elems, Resource>
template<typename T, unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none>
using | const_unaligned_vector_iterator = unaligned_vector_iterator<const std::remove_const_t<T>, Elems, Resource>
| Same as unaligned_vector_iterator, but the contents of the iterated array cannot be modified.
template<typename T, unsigned Elems, size_t Size = dynamic_extent, aie_dm_resource Resource = aie_dm_resource::none>
using | const_vector_circular_iterator = vector_circular_iterator<const T, Elems, Size, Resource>
| Same as circular_iterator, but the contents of the iterated array cannot be modified.
template<typename T, unsigned Elems, aie_dm_resource Resource = aie_dm_resource::none>
using | const_vector_iterator = vector_iterator<const std::remove_const_t<T>, Elems, Resource>
| Same as vector_iterator, but the contents of the iterated array cannot be modified.
template<typename T, unsigned Elems, size_t Size, aie_dm_resource Resource = aie_dm_resource::none>
using | const_vector_random_circular_iterator = vector_random_circular_iterator<const T, Elems, Size, Resource>
| Same as vector_random_circular_iterator, but the contents of the iterated array cannot be modified.
using | contiguous_dim = detail::contiguous_dim
using | dim_2d = detail::dim_2d
using | dim_3d = detail::dim_3d
template<size_t... Extents>
using | extents = detail::extents<Extents...>
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<typename detail::utils::remove_all<T>::type>::type
template<typename T, size_t... Extents>
using | restrict_mdspan = detail::basic_mdspan<T, extents<Extents...>, void, detail::accessor_restrict<T>>
template<typename T, size_t Extents1 = dynamic_extent>
using | restrict_span = restrict_span_1d<T, Extents1>
template<typename T, size_t Extents1 = dynamic_extent>
using | restrict_span_1d = restrict_mdspan<T, Extents1>
template<typename T, size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent>
using | restrict_span_2d = restrict_mdspan<T, Extents1, Extents2>
template<typename T, size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent>
using | restrict_span_3d = restrict_mdspan<T, Extents1, Extents2, Extents3>
template<typename T, size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent, size_t Extents4 = dynamic_extent>
using | restrict_span_4d = restrict_mdspan<T, Extents1, Extents2, Extents3, Extents4>
template<typename T, typename TileExtents, size_t... Extents>
using | restrict_tiled_mdspan = detail::basic_tiled_mdspan<T, TileExtents, extents<Extents...>, void, detail::accessor_restrict<T>>
template<typename T, typename TileExtents, size_t Extents1 = dynamic_extent>
using | restrict_tiled_span = tiled_span_1d<T, TileExtents, Extents1>
template<typename T, typename TileExtents, size_t Extents1 = dynamic_extent>
using | restrict_tiled_span_1d = tiled_mdspan<T, TileExtents, Extents1>
template<typename T, typename TileExtents, size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent>
using | restrict_tiled_span_2d = tiled_mdspan<T, TileExtents, Extents1, Extents2>
template<typename T, typename TileExtents, size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent>
using | restrict_tiled_span_3d = tiled_mdspan<T, TileExtents, Extents1, Extents2, Extents3>
template<typename T, typename TileExtents, size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent, size_t Extents4 = dynamic_extent>
using | restrict_tiled_span_4d = tiled_mdspan<T, TileExtents, Extents1, Extents2, Extents3, Extents4>
template<typename T>
using | result_type_t = typename result_type_helper<T>::type
template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using | sliding_mul_ch_x_ops = sliding_mul_ch_ops<Outputs, Channels, Points, CoeffStep, DataStepX, 1, CoeffType, DataType, AccumTag>
template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using | sliding_mul_ch_xy_ops = sliding_mul_ch_ops<Outputs, Channels, Points, CoeffStep, DataStep, DataStep, CoeffType, DataType, AccumTag>
template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using | sliding_mul_ch_y_ops = sliding_mul_ch_ops<Outputs, Channels, Points, CoeffStep, 1, DataStepY, CoeffType, DataType, AccumTag>
template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using | sliding_mul_sym_x_ops = sliding_mul_sym_ops<Lanes, Points, CoeffStep, DataStepX, 1, CoeffType, DataType, AccumTag>
template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepXY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using | sliding_mul_sym_xy_ops = sliding_mul_sym_ops<Lanes, Points, CoeffStep, DataStepXY, DataStepXY, CoeffType, DataType, AccumTag>
template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using | sliding_mul_sym_y_ops = sliding_mul_sym_ops<Lanes, Points, CoeffStep, 1, DataStepY, CoeffType, DataType, AccumTag>
template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using | sliding_mul_x_ops = sliding_mul_ops<Lanes, Points, CoeffStep, DataStepX, 1, CoeffType, DataType, AccumTag>
| Similar to sliding_mul_ops, but DataStepY is always 1.
template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepXY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using | sliding_mul_xy_ops = sliding_mul_ops<Lanes, Points, CoeffStep, DataStepXY, DataStepXY, CoeffType, DataType, AccumTag>
| Similar to sliding_mul_ops, but DataStepX is equal to DataStepY.
template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
using | sliding_mul_y_ops = sliding_mul_ops<Lanes, Points, CoeffStep, 1, DataStepY, CoeffType, DataType, AccumTag>
| Similar to sliding_mul_ops, but DataStepX is always 1.
using | sliding_window_dim_1d = detail::sliding_window_dim_1d
using | sliding_window_dim_2d = detail::sliding_window_dim_2d
using | sliding_window_dim_3d = detail::sliding_window_dim_3d
template<typename T, size_t Extents1 = dynamic_extent>
using | span = span_1d<T, Extents1>
template<typename T, size_t Extents1 = dynamic_extent>
using | span_1d = mdspan<T, Extents1>
template<typename T, size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent>
using | span_2d = mdspan<T, Extents1, Extents2>
template<typename T, size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent>
using | span_3d = mdspan<T, Extents1, Extents2, Extents3>
template<typename T, size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent, size_t Extents4 = dynamic_extent>
using | span_4d = mdspan<T, Extents1, Extents2, Extents3, Extents4>
using | tbs_mode = detail::tbs_mode
template<typename T, typename TileExtents, size_t... Extents>
using | tiled_mdspan = detail::basic_tiled_mdspan<T, TileExtents, extents<Extents...>, void, detail::accessor_basic<T>>
template<typename T, typename TileExtents, size_t Extents1 = dynamic_extent>
using | tiled_span = tiled_span_1d<T, TileExtents, Extents1>
template<typename T, typename TileExtents, size_t Extents1 = dynamic_extent>
using | tiled_span_1d = tiled_mdspan<T, TileExtents, Extents1>
template<typename T, typename TileExtents, size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent>
using | tiled_span_2d = tiled_mdspan<T, TileExtents, Extents1, Extents2>
template<typename T, typename TileExtents, size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent>
using | tiled_span_3d = tiled_mdspan<T, TileExtents, Extents1, Extents2, Extents3>
template<typename T, typename TileExtents, size_t Extents1 = dynamic_extent, size_t Extents2 = dynamic_extent, size_t Extents3 = dynamic_extent, size_t Extents4 = dynamic_extent>
using | tiled_span_4d = tiled_mdspan<T, TileExtents, Extents1, Extents2, Extents3, Extents4>

## Enumerations
enum class | lut_oor_policy
enum class | Operation
enum class | rounding_mode : unsigned
| Rounding modes. More...
enum class | saturation_mode : unsigned
| Saturation modes. More...

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

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

## Class Documentation

## ◆ aie::binary_op

struct aie::binary_op

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

## ◆ aie::circular_index

struct aie::circular_index

template<unsigned Max>
struct aie::circular_index< Max >

## ◆ aie::fft_dit

struct aie::fft_dit

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

## ◆ aie::is_block_vector_op

struct aie::is_block_vector_op

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

## ◆ 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 T |

## ◆ 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 binary_op< Parent1, Parent2, ParentOp > | type |
typedef typename result_type, Op >::type | type typename op_result_helper<typename binary_op<Parent1, Parent2, ParentOp>::result_type, Op>::type |

## ◆ aie::op_result_helper< detail::tbs< T, Elems, Level, NumLevels, SlidingInner, IterDesc, ResourceType, Resource, Mode, Restrict, U >, Op >

struct aie::op_result_helper< detail::tbs< T, Elems, Level, NumLevels, SlidingInner, IterDesc, ResourceType, Resource, Mode, Restrict, U >, Op >

template<typename T, unsigned Elems, unsigned Level, unsigned NumLevels, bool SlidingInner, typename IterDesc, typename ResourceType, ResourceType Resource, detail::tbs_mode Mode, bool Restrict, typename U, Operation Op>
requires (Op != Operation::None)
struct aie::op_result_helper< detail::tbs< T, Elems, Level, NumLevels, SlidingInner, IterDesc, ResourceType, Resource, Mode, Restrict, U >, Op >

Class Members
typedef T | type |
typedef tbs< T, Elems, Level, NumLevels, SlidingInner, IterDesc, ResourceType, Resource, Mode, Restrict, U > | type detail::tbs<T, Elems, Level, NumLevels, SlidingInner, IterDesc, ResourceType, Resource, Mode, Restrict, U> |

## ◆ 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 |
typedef Parent | type Parent |

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

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

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

Class Members
typedef T | type |
typedef vector< T, Elems > | type vector<T, Elems> |

## ◆ 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 unary_op< Parent, ParentOp > | type |
typedef typename result_type, Op >::type | type typename op_result_helper<typename unary_op<Parent, ParentOp>::result_type, Op>::type |

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

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

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

Class Members
typedef T | type |
typedef T | type T |

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

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

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

Class Members
typedef T | type |
typedef T | type T |

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

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

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

Class Members
typedef T | type |
typedef vector< T, Elems > | type vector<T, Elems> |

## ◆ 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 T |

## ◆ 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 binary_op< Parent1, Parent2, Op > | type |
typedef typename value_type | type typename binary_op<Parent1, Parent2, Op>::value_type |

## ◆ aie::op_value_type_helper< detail::tbs< T, Elems, Level, NumLevels, SlidingInner, IterDesc, ResourceType, Resource, Mode, Restrict, U > >

struct aie::op_value_type_helper< detail::tbs< T, Elems, Level, NumLevels, SlidingInner, IterDesc, ResourceType, Resource, Mode, Restrict, U > >

template<typename T, unsigned Elems, unsigned Level, unsigned NumLevels, bool SlidingInner, typename IterDesc, typename ResourceType, ResourceType Resource, detail::tbs_mode Mode, bool Restrict, typename U>
struct aie::op_value_type_helper< detail::tbs< T, Elems, Level, NumLevels, SlidingInner, IterDesc, ResourceType, Resource, Mode, Restrict, U > >

Class Members
typedef T | type |
typedef typename value_type | type typename detail::tbs<T, Elems, Level, NumLevels, SlidingInner, IterDesc, ResourceType, Resource, Mode, Restrict, U>::value_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 typename mmul<M, K, N, TypeA, TypeB, AccumTag>::value_type |
typedef mmul< M, K, N, TypeA, TypeB, AccumTag > | type |

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

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

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

Class Members
typedef T | type |
typedef typename value_type | type typename sparse_vector<T, Elems>::value_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 T | type |
typedef typename value_type | type typename unaligned_vector_ref<T, Elems, Resource>::value_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 unary_op< Parent, Op > | type |
typedef typename value_type | type typename unary_op<Parent, Op>::value_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 T | type |
typedef typename value_type | type typename vector<T, Elems>::value_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 T | type |
typedef typename value_type | type typename vector_elem_const_ref<T, Elems>::value_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 T | type |
typedef typename value_type | type typename vector_elem_ref<T, Elems>::value_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 T | type |
typedef typename value_type | type typename vector_ref<T, Elems, Resource>::value_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_dm_resource_remove_t<T> |

## ◆ 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 aie_dm_resource_remove_t< binary_op< Parent1, Parent2, Op > > | type |
typedef typename value_type | type typename binary_op<Parent1, Parent2, Op>::value_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 aie_dm_resource_remove_t< unary_op< Parent, Op > > | type |
typedef typename value_type | type typename unary_op<Parent, Op>::value_type |

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

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

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

Class Members
typedef aie_dm_resource_remove_t< T > | type |
typedef T | type T |

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

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

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

Class Members
typedef aie_dm_resource_remove_t< T > | type |
typedef T | type T |

## ◆ aie::result_type_helper

struct aie::result_type_helper

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

## ◆ aie::result_type_helper< T >

struct aie::result_type_helper< T >

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

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

## ◆ aie::tile_id

struct aie::tile_id

Identifies a particular tile within the AIE array.

Class Members
uint16_t | col |
uint16_t | row |

## ◆ aie::unary_op

struct aie::unary_op

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

## Typedef Documentation

## ◆ accum_tag_t [1/4]

template<AccumClass Class, unsigned Bits>

using aie::detail::accum_tag_t

## ◆ accum_tag_t [2/4]

template<AccumClass Class, unsigned Bits>

using aie::detail::accum_tag_t

## ◆ accum_tag_t [3/4]

template<AccumClass Class, unsigned Bits>

using aie::detail::accum_tag_t

## ◆ accum_tag_t [4/4]

template<AccumClass Class, unsigned Bits>

using aie::detail::accum_tag_t

## ◆ AccumClass

using aie::AccumClass = detail::AccumClass

## ◆ cfr

template<typename T>

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

## ◆ const_pattern_iterator

template<typename T, unsigned Steps>

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

## ◆ const_restrict_vector_iterator

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

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

## ◆ contiguous_dim

using aie::contiguous_dim = detail::contiguous_dim

## ◆ dim_2d

using aie::dim_2d = detail::dim_2d

## ◆ dim_3d

using aie::dim_3d = detail::dim_3d

## ◆ extents

template<size_t... Extents>

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

## ◆ mdspan

template<typename T, size_t... Extents>

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

## ◆ op_result_type_t

template<typename T, Operation Op>

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

## ◆ op_value_type_t

template<typename T>

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

## ◆ operand_base_type_t

template<typename T>

using aie::operand_base_type_t = typename operand_base_type<typename detail::utils::remove_all<T>::type>::type

## ◆ restrict_mdspan

template<typename T, size_t... Extents>

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

## ◆ restrict_span

template<typename T, size_t Extents1 = dynamic_extent>

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

## ◆ restrict_span_1d

template<typename T, size_t Extents1 = dynamic_extent>

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

## ◆ restrict_span_2d

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

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

## ◆ restrict_span_3d

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

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

## ◆ restrict_span_4d

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

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

## ◆ restrict_tiled_mdspan

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

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

## ◆ restrict_tiled_span

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

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

## ◆ restrict_tiled_span_1d

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

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

## ◆ restrict_tiled_span_2d

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

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

## ◆ restrict_tiled_span_3d

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

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

## ◆ restrict_tiled_span_4d

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

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

## ◆ result_type_t

template<typename T>

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

## ◆ sliding_window_dim_1d

using aie::sliding_window_dim_1d = detail::sliding_window_dim_1d

## ◆ sliding_window_dim_2d

using aie::sliding_window_dim_2d = detail::sliding_window_dim_2d

## ◆ sliding_window_dim_3d

using aie::sliding_window_dim_3d = detail::sliding_window_dim_3d

## ◆ span

template<typename T, size_t Extents1 = dynamic_extent>

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

## ◆ span_1d

template<typename T, size_t Extents1 = dynamic_extent>

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

## ◆ span_2d

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

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

## ◆ span_3d

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

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

## ◆ span_4d

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

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

## ◆ tbs_mode

using aie::tbs_mode = detail::tbs_mode

## ◆ tiled_mdspan

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

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

## ◆ tiled_span

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

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

## ◆ tiled_span_1d

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

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

## ◆ tiled_span_2d

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

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

## ◆ tiled_span_3d

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

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

## ◆ tiled_span_4d

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

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

## Enumeration Type Documentation

## ◆ lut_oor_policy

enum class aie::detail::lut_oor_policy
| strong

## ◆ Operation

enum class aie::Operation
| strong

Enumerator
None |
Acc_Add |
Acc_Sub |
Abs |
Conj |
Transpose |
Max |
Min |
Sign |
Zero |

## Function Documentation

## ◆ accum()

template<detail::NativeAccumType T>

aie::accum | ( | T |  | ) | -> accum< typename detail::native_accum_traits< T >::value_type, detail::native_accum_traits< T >::size >

Template deduction guidelines for aie::accum.

## ◆ add()

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

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

## ◆ add_reduce()

template<Vector Vec>

Vec::value_type aie::add_reduce | ( | const Vec & | v | ) |

## ◆ add_reduce_v()

template<Vector Vec, Vector... Others>

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

## ◆ begin_vectors()

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

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

## ◆ cbegin_vectors()

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

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

## ◆ concat()

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

auto aie::concat | ( | const T & | t | ) |

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

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

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

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

aie::vector<int8, 64> even = ..., odd = ...;
aie::vector<int8, 128> mixed = aie::concat( aie::interleave_zip(even, odd, 1) );
aie::vector
Type for vector registers.
Definition vector.hpp:79
aie::concat
auto concat(const Acc &acc, const Accums &...accums) -> accum< typename Acc::value_type, Acc::size() *(1+sizeof...(Accums))>
Concatenate the contents of all input accumulators into a larger accumulator.
Definition aie.hpp:999
aie::interleave_zip
auto interleave_zip(const Vec1 &v, const Vec2 &w, unsigned chunk_size) -> std::pair< aie_dm_resource_remove_t< Vec1 >, aie_dm_resource_remove_t< Vec1 > >
Picks elements alternatively from the input vectors and writes them sequentially into the output vect...
Definition aie.hpp:2971

Parameters

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

## ◆ contains()

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

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

## ◆ div()

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

## ◆ fft_get_stage()

template<typename Input, typename Output, typename Twiddle>

static constexpr unsigned aie::detail::fft_get_stage | ( | unsigned | Radix,
|  | unsigned | Vectorization )
| static constexpr

## ◆ interleave_butterfly()

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

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

## ◆ interleave_butterfly_half()

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

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

## ◆ interleave_crossover()

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

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

## ◆ interleave_custom()

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

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

## ◆ interleave_custom_static()

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

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

## ◆ is_ct_elem_zero()

template<typename T, Elem E>

bool aie::is_ct_elem_zero | ( | E | a | ) |
| constexpr

## ◆ mac()

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

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

## ◆ make_restrict_tensor_buffer_stream()

template<aie_dm_resource Resource = aie_dm_resource::none, tbs_mode Mode = tbs_mode::default_mode, DecoratedElemBaseOrBlockType T, typename TensorDescriptor>
requires (arch::is(arch::Gen2))

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

## ◆ make_tensor_buffer_stream() [1/4]

template<aie_dm_resource Resource = aie_dm_resource::none, aie::tbs_mode Mode = aie::tbs_mode::default_mode, IOBuffer T, typename TensorDescriptor>

auto aie::make_tensor_buffer_stream | ( | const T & | port,
|  | const TensorDescriptor & | tensor_desc )
| constexpr

## ◆ make_tensor_buffer_stream() [2/4]

template<aie_dm_resource Resource = aie_dm_resource::none, tbs_mode Mode = tbs_mode::default_mode, DecoratedElemBaseOrBlockType T, typename TensorDescriptor>
requires (arch::is(arch::Gen2))

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

## ◆ make_tensor_buffer_stream() [3/4]

template<aie_dm_resource Resource = aie_dm_resource::none, aie::tbs_mode Mode = aie::tbs_mode::default_mode, IOBuffer T, typename TensorDescriptor>

auto aie::make_tensor_buffer_stream | ( | T & | port,
|  | const TensorDescriptor & | tensor_desc )
| constexpr

## ◆ make_tensor_buffer_stream() [4/4]

template<aie_dm_resource Resource = aie_dm_resource::none, tbs_mode Mode = tbs_mode::default_mode, DecoratedElemBaseOrBlockType T, typename TensorDescriptor>
requires (arch::is(arch::Gen2))

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

## ◆ make_tensor_descriptor_from_native()

template<typename T, unsigned Elems, NativeDim... Args>
requires (arch::is(arch::Gen2))

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

## ◆ make_tensor_descriptor_from_native_bytes()

template<typename T, unsigned Elems, NativeOrSlidingDim... Args>
requires (arch::is(arch::Gen2))

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

## ◆ make_unaligned_vector_input_buffer_stream()

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

auto aie::make_unaligned_vector_input_buffer_stream | ( | const T * | ptr | ) | -> unaligned_vector_input_buffer_stream<T, Elems, Resource>

## ◆ make_unaligned_vector_output_buffer_stream()

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

auto aie::make_unaligned_vector_output_buffer_stream | ( | T * | ptr | ) | -> unaligned_vector_output_buffer_stream<T, Elems, Resource>

## ◆ make_vector_input_buffer_stream()

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

auto aie::make_vector_input_buffer_stream | ( | const T * | ptr | ) | -> vector_input_buffer_stream<T, Elems, Resource>

## ◆ make_vector_output_buffer_stream()

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

auto aie::make_vector_output_buffer_stream | ( | T * | ptr | ) | -> vector_output_buffer_stream<T, Elems, Resource>

## ◆ max_cmp()

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

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

## ◆ max_reduce()

template<RealVector Vec>

Vec::value_type aie::max_reduce | ( | const Vec & | v | ) |

## ◆ min_cmp()

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

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

## ◆ min_reduce()

template<RealVector Vec>

Vec::value_type aie::min_reduce | ( | const Vec & | v | ) |

## ◆ mmac_fn() [1/2]

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

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

## ◆ mmac_fn() [2/2]

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

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

## ◆ mmul_fn()

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

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

## ◆ msc()

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

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

## ◆ mul()

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

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

## ◆ mul_reduce() [1/2]

template<AccumElemBaseType AccumTag, Vector Vec>

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

## ◆ mul_reduce() [2/2]

template<Vector Vec>

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

## ◆ operator&()

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

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

## ◆ operator*()

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

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

## ◆ operator+()

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

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

## ◆ operator-()

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

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

## ◆ operator<<() [1/2]

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

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

## ◆ operator<<() [2/2]

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

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

## ◆ operator>>() [1/2]

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

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

## ◆ operator>>() [2/2]

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

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

## ◆ operator^()

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

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

## ◆ operator|()

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

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

## ◆ operator~()

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

auto aie::operator~ | ( | T | v | ) |
| constexpr

## ◆ peeled_pipelined_loop()

template<unsigned MinIters, loop_options Opts = loop_options{}, bool use_pipelining, typename Fn>

void aie::peeled_pipelined_loop | ( | unsigned | count,
|  | Fn && | fn )

## ◆ reduce_mul()

template<AccumElemBaseType AccumTag, Vector Vec>

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

## ◆ scoped_mode() [1/2]

aie::scoped_mode | ( | rounding_mode |  | ) | -> scoped_mode< rounding_mode >

## ◆ scoped_mode() [2/2]

aie::scoped_mode | ( | saturation_mode |  | ) | -> scoped_mode< saturation_mode >

## ◆ sliding_mac() [1/2]

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

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

## ◆ sliding_mac() [2/2]

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

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

## ◆ sliding_mac_antisym() [1/5]

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

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

## ◆ sliding_mac_antisym() [2/5]

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

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

## ◆ sliding_mac_antisym() [3/5]

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

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

## ◆ sliding_mac_antisym() [4/5]

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

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

## ◆ sliding_mac_antisym() [5/5]

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

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

## ◆ sliding_mac_antisym_uct() [1/2]

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

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

## ◆ sliding_mac_antisym_uct() [2/2]

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

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

## ◆ sliding_mac_ch()

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

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

## ◆ sliding_mac_sym() [1/5]

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

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

## ◆ sliding_mac_sym() [2/5]

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

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

## ◆ sliding_mac_sym() [3/5]

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

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

## ◆ sliding_mac_sym() [4/5]

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

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

## ◆ sliding_mac_sym() [5/5]

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

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

## ◆ sliding_mac_sym_uct() [1/2]

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

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

## ◆ sliding_mac_sym_uct() [2/2]

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

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

## ◆ sliding_mul() [1/2]

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

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

## ◆ sliding_mul() [2/2]

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

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

## ◆ sliding_mul_antisym() [1/5]

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

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

## ◆ sliding_mul_antisym() [2/5]

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

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

## ◆ sliding_mul_antisym() [3/5]

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

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

## ◆ sliding_mul_antisym() [4/5]

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

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

## ◆ sliding_mul_antisym() [5/5]

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

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

## ◆ sliding_mul_antisym_uct() [1/2]

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

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

## ◆ sliding_mul_antisym_uct() [2/2]

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

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

## ◆ sliding_mul_ch()

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

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

## ◆ sliding_mul_sym() [1/5]

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

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

## ◆ sliding_mul_sym() [2/5]

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

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

## ◆ sliding_mul_sym() [3/5]

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

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

## ◆ sliding_mul_sym() [4/5]

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

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

## ◆ sliding_mul_sym() [5/5]

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

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

## ◆ sliding_mul_sym_uct() [1/2]

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

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

## ◆ sliding_mul_sym_uct() [2/2]

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

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

## ◆ sparse_vector()

template<detail::NativeSparseVector T>

aie::sparse_vector | ( | T |  | ) | -> sparse_vector< typename detail::native_vector_traits< T >::value_type, detail::native_vector_traits< T >::size >

Template deduction guidelines for aie::sparse_vector.

## ◆ sub()

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

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

## ◆ tlast() [1/2]

template<typename T>

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

## ◆ tlast() [2/2]

template<typename T>

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

## ◆ vector()

template<detail::NativeVectorType T>

aie::vector | ( | T |  | ) | -> vector< typename detail::native_vector_traits< T >::value_type, detail::native_vector_traits< T >::size >

Template deduction guidelines for aie::vector.

## ◆ vector_cast()

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

auto aie::vector_cast | ( | const Vec & | v | ) |

Reinterpret a vector as an accumulator.

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

Template Parameters

  DstTag | Accumulator tag for the returned accumulator.

Parameters

  v | Input vector.

## ◆ zero()

template<ElemBaseType T>

T aie::zero | ( |  | ) |
| constexpr

Returns the zero value for the requested data type.

Template Parameters

  Requested | data type

## ◆ zeros()

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

accum< AccumTag, Elems > aie::zeros | ( |  | ) |

Returns a vector whose elements are initialized to zero.

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

Template Parameters

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

## Variable Documentation

## ◆ dynamic_extent

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

## ◆ is_accum_op_v

template<typename T>

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

## ◆ is_binary_op_v

template<typename T>

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

## ◆ is_block_vector_op_v

template<typename T>

bool aie::is_block_vector_op_v = is_block_vector_op<T>::value
| static constexpr

## ◆ is_complex_op_v

template<typename T>

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

## ◆ is_elem_op_v

template<typename T>

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

## ◆ is_lut_v

template<typename T>

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

## ◆ is_mmul_or_op_v

template<typename T>

bool aie::is_mmul_or_op_v
| static constexpr

Initial value:
= is_mmul_v<aie_dm_resource_remove_t<T>> ||
is_op_v<T>
aie::is_op_v
static constexpr bool is_op_v
Definition expr.hpp:238
aie::is_mmul_v
static constexpr bool is_mmul_v
Definition aie.hpp:153

## ◆ is_mmul_v

template<typename T>

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

## ◆ is_op_v

template<typename T>

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

## ◆ is_real_op_v

template<typename T>

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

## ◆ is_same_accum_v

template<Accum Acc1, Accum Acc2>

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

## ◆ is_same_vector_v

template<Vector Vec1, Vector Vec2>

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

## ◆ is_sparse_vector_op_v

template<typename T>

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

## ◆ is_tbs_op_v

template<typename T>

bool aie::is_tbs_op_v = is_tbs_op<T>::value
| static constexpr

## ◆ is_unary_op_v

template<typename T>

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

## ◆ is_valid_elem_op_v

template<typename T1, typename T2>

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

## ◆ is_valid_mul_op_v

template<typename T, typename T2>

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

## ◆ is_valid_size_v

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

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

## ◆ is_vector_op_v

template<typename T>

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

## ◆ max_shift

int aie::max_shift = detail::max_shift
| static constexpr

## ◆ min_shift

int aie::min_shift = detail::min_shift
| static constexpr

## ◆ native_vector_length_v

template<typename T>

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