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

Loading...
Searching...
No Matches
Classes | Namespaces | Concepts | Macros | Typedefs | Enumerations | Functions | Variables
aie.hpp File Reference

## Detailed Description

AIE API main entry point.

`#include <algorithm>`
`#include <array>`
`#include <cmath>`
`#include <cstdlib>`
`#include <tuple>`
`#include <type_traits>`
`#include <utility>`
`#include "detail/abs.hpp"`
`#include "detail/abs_square.hpp"`
`#include "detail/accumulate.hpp"`
`#include "detail/add.hpp"`
`#include "detail/bit.hpp"`
`#include "detail/blend.hpp"`
`#include "detail/cfr.hpp"`
`#include "detail/compare.hpp"`
`#include "detail/conj.hpp"`
`#include "detail/elementary.hpp"`
`#include "detail/fft.hpp"`
`#include "detail/filter.hpp"`
`#include "detail/interleave.hpp"`
`#include "detail/ld_st.hpp"`
`#include "detail/linear_approx.hpp"`
`#include "detail/lut.hpp"`
`#include "detail/max_min.hpp"`
`#include "detail/mmul.hpp"`
`#include "detail/mul.hpp"`
`#include "detail/neg.hpp"`
`#include "detail/parallel_lookup.hpp"`
`#include "detail/reverse.hpp"`
`#include "detail/shift.hpp"`
`#include "detail/shuffle.hpp"`
`#include "detail/square.hpp"`
`#include "detail/transpose.hpp"`
`#include "detail/vector_accum_cast.hpp"`
`#include "accum.hpp"`
`#include "aie_doc.hpp"`
`#include "aie_types.hpp"`
`#include "concepts.hpp"`
`#include "expr.hpp"`
`#include "fft.hpp"`
`#include "iterator.hpp"`
`#include "mask.hpp"`
`#include "sliding_mul.hpp"`
`#include "sparse_vector.hpp"`
`#include "tile.hpp"`
`#include "types.hpp"`
`#include "vector.hpp"`
`#include "vector_elem_ref.hpp"`
`#include "aie_adf.hpp"`
`#include "operators.hpp"`

## Classes
class | aie::filter_mode< T, Elems >
| Enables precomputation of the filter element selection. More...
class | aie::interleave_unzip_mode< T, Elems >
| Enables precomputation of the interleave element selection. More...
class | aie::interleave_zip_mode< T, Elems >
| Enables precomputation of the interleave element selection. More...
struct | aie::is_lut< T >
struct | aie::is_lut< lut< ParallelAccesses, OffsetType, SlopeType > >
struct | aie::is_mmul< T >
struct | aie::is_mmul< mmul< M, K, N, TypeA, TypeB, AccumTag > >
struct | aie::is_same_vector< Vec1, Vec2 >
struct | aie::is_same_vector< unaligned_vector_ref< T, N, Resource >, Vec >
struct | aie::is_same_vector< vector< T, N >, vector< T, N > >
struct | aie::is_same_vector< vector< T1, N1 >, unaligned_vector_ref< T2, N2, Resource > >
struct | aie::is_same_vector< vector< T1, N1 >, vector_ref< T2, N2, Resource > >
struct | aie::is_same_vector< vector_ref< T, N, Resource >, Vec >
struct | aie::is_valid_elem_op< T1, T2 >
struct | aie::is_valid_size< T, T2, Other >
struct | aie::is_valid_size< T, T2 >
struct | aie::linear_approx< T, MyLUT >
struct | aie::lut< ParallelAccesses, OffsetType, SlopeType >
| 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...
struct | aie::mmul< M_Elems, K_Elems, N_Elems, TypeA, TypeB, AccumTag >
| Type that encapsulates a blocked matrix multiplication C = A x B. More...
struct | aie::op_value_type_helper< mmul< M, K, N, TypeA, TypeB, AccumTag > >
struct | aie::operand_base_type< T >
struct | aie::operand_base_type< binary_op< Parent1, Parent2, Op > >
struct | aie::operand_base_type< unary_op< Parent, Op > >
struct | aie::operand_base_type< vector_elem_const_ref< T, Elems > >
struct | aie::operand_base_type< vector_elem_ref< T, Elems > >
struct | aie::parallel_lookup< T, MyLUT, oor_policy >
struct | aie::result_type_helper< T >

## Namespaces
namespace | aie
| Base namespace for AIE operations and types.

## Concepts
concept | aie::Mmul
concept | aie::MmulOrOp
concept | aie::TupleLike
| Accepts any type implementing tuple interface.
concept | aie::ParallelLUT
concept | aie::aie::ParallelLUT
| Concept for parallel access LUT types.

## Macros
#define | __AIE_API_AIE__HPP__
#define | AIE_API_CXX_VERSION 202002L

## Typedefs
template<typename T>
using | aie::cfr = detail::cfr<T>
template<typename T>
using | aie::result_type_t = typename result_type_helper<T>::type

## Enumerations
enum class | aie::lut_oor_policy

## Functions
template<Elem E>
constexpr auto | aie::abs (const E &a) -> operand_base_type_t< E >
| Compute the absolute value of a value.
template<Vector Vec>
constexpr auto | aie::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 | aie::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 | aie::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 | aie::abs_square (const Vec &v, int shift=0)
| Compute the absolute square of each element in the given complex vector.
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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::add (T a, T b)
template<Vector Vec>
Vec::value_type | aie::add_reduce (const Vec &v)
template<Vector Vec, Vector... Others>
auto | aie::add_reduce_v (const Vec &v, const Others &... others) -> aie_dm_resource_remove_t< Vec >
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 | aie::bit_and (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
| Returns a vector with the bit-wise AND of the elements of the two input vectors.
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 | aie::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 | aie::bit_not (const Vec &v) -> aie_dm_resource_remove_t< Vec >
| Returns a vector with the bit-wise NEG of the elements of the input vector.
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 | aie::bit_or (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
| Returns a vector with the bit-wise OR of the elements of the two input vectors.
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 | aie::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 | aie::bit_xor (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
| Returns a vector with the bit-wise XOR of the elements of the two input vectors.
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 | aie::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 > | aie::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 > | aie::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 > | aie::broadcast_vector (const vector< T, Elems2 > &v, unsigned index)
| Returns a vector whose elements are initialized to a repeating set of values.
template<RealVector Vec, RealVector VecL, RealVector VecH> requires (is_same_vector_v<Vec, VecL> && is_same_vector_v<Vec, VecH>)
auto | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::conj (const E &a) -> operand_base_type_t< E >
| Compute the conjugate in the given complex value.
template<ComplexVector Vec>
auto | aie::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 | aie::contains (E a, const Vec &v)
template<RealVector Vec> requires (arch::is(arch::AIE))
auto | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::div (float a, float b)
template<Vector Vec>
auto | aie::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<Vector Vec, Elem E> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()> | aie::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()> | aie::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()> | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::exp2 (const vector< float, Elems > &v) -> vector< TR, Elems >
| Compute the 2 raised to the power function for all elements in a vector.
template<Vector Vec, ElemBaseType T, unsigned Elems> requires (std::is_same_v<typename Vec::value_type, T> && Vec::size() == Elems)
auto | aie::filter (const Vec &v, filter_mode< T, Elems > mode) -> vector< T, Elems/2 >
| Returns a vector of half the size.
template<Vector Vec>
auto | aie::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 | aie::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()> | aie::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()> | aie::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()> | aie::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()> | aie::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 | aie::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 | aie::get_rounding ()
| Get the current rounding mode used in accumulator to vector conversions.
static saturation_mode | aie::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()> | aie::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()> | aie::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()> | aie::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 | aie::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 | aie::imag (const Vec &v) -> detail::remove_complex_t< Vec >
| Gather and return the imaginary components of a complex vector.
template<ComplexElem Elem>
auto | aie::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 | 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 > >
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 > >
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 > >
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 > >
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 > >
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
auto | aie::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 | aie::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 | aie::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 | aie::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 | aie::inv (C a)
| Returns the inverse value of a complex number.
template<unsigned Elems> requires (arch::is(arch::AIE))
accum< accfloat, Elems > | aie::inv (const accum< accfloat, Elems > &v)
| Returns the inverse value of every element in an accumulator.
template<Vector Vec>
auto | aie::inv (const Vec &v) -> aie_dm_resource_remove_t< Vec >
| Returns the inverse value of every element in a vector.
template<RealElem E>
auto | aie::inv (E a)
| Returns the inverse value.
template<unsigned Elems> requires (arch::is(arch::AIE))
accum< accfloat, Elems > | aie::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 | aie::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 | aie::invsqrt (E a)
| Performs an approximation of the inversed square root of a single value.
template<typename T, Elem E>
constexpr bool | aie::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()> | aie::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()> | aie::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()> | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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()> | aie::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()> | aie::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()> | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::mac (TR c, T1 a, T2 b)
template<AccumOrOp Acc, Vector Vec> requires (Vec::size() == Acc::size())
constexpr auto | aie::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<RealVector Vec, RealElem E> requires (is_valid_elem_op_v<typename Vec::value_type, E>)
auto | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::max_reduce (const Vec &v)
template<RealVector Vec, RealElem E> requires (is_valid_elem_op_v<typename Vec::value_type, E>)
auto | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::msc (TR c, T1 a, T2 b)
template<AccumOrOp Acc, Vector Vec> requires (Vec::size() == Acc::size())
constexpr auto | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::mul (T1 a, T2 b)
template<AccumElemBaseType AccumTag, Vector Vec>
Vec::value_type | aie::mul_reduce (const Vec &v)
template<Vector Vec>
constexpr Vec::value_type | aie::mul_reduce (const Vec &v)
template<Vector Vec>
constexpr auto | aie::mul_square (const Vec &v)
| Returns an accumulator with the element-wise square of the input vector.
template<AccumElemBaseType AccumTag, Vector Vec>
constexpr auto | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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()> | aie::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()> | aie::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()> | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 > | aie::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 > | aie::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 > | aie::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 > | aie::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 > | aie::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 > | aie::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 > | aie::op_none (T &e)
| Returns an empty operation modifier for the given tensor buffer stream.
template<typename T>
auto | aie::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 > | aie::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 > | aie::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 > | aie::op_sub (const Acc &acc)
| Returns a subtraction operation modifier for the given accumulator.
template<Accum Acc>
constexpr binary_op< Acc, bool, Operation::Zero > | aie::op_zero (const Acc &acc, bool to_zero)
| Zeroes out the given accumulator or not depending on the zero parameter.
template<VectorOrOp Vec, typename T2 = Utils::get_prev_integer_type_t<typename Vec::value_type>> requires (!detail::is_floating_point_v<Vec>)
auto | aie::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<ComplexVector Vec>
auto | aie::real (const Vec &v) -> detail::remove_complex_t< Vec >
| Gather and return the real components of a complex vector.
template<ComplexElem Elem>
auto | aie::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 | aie::reduce_add (const Acc &acc)
| Returns the sum of all input vector elements.
template<Vector Vec>
Vec::value_type | aie::reduce_add (const Vec &v)
| Returns the sum of all input vector elements.
template<Vector Vec, Vector... Others>
auto | aie::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 | aie::reduce_max (const Vec &v)
| Returns the element from the input vector with the largest value.
template<RealVector Vec>
Vec::value_type | aie::reduce_min (const Vec &v)
| Returns the element from the input vector with the smallest value.
template<AccumElemBaseType AccumTag, Vector Vec>
Vec::value_type | aie::reduce_mul (const Vec &v)
template<Vector Vec>
constexpr Vec::value_type | aie::reduce_mul (const Vec &v)
| Returns a product of the elements in the input vector.
template<Vector Vec>
auto | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::saturating_sub (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
| Returns a vector with the subtraction of a value to all the elements of the input vector.
template<Elem E1, Elem E2, Mask M> requires (is_valid_elem_op_v<E1, E2>)
vector< operand_base_type_t< E1 >, M::size()> | aie::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 | aie::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 | aie::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 | aie::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 | aie::set_rounding (rounding_mode m)
| Set the rounding mode used in accumulator to vector conversions.
static void | aie::set_saturation (saturation_mode m)
| Set the saturation mode.
template<Vector Vec>
auto | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::sin (E a)
| Performs a sine operation on a single value.
template<RealVector Vec> requires (arch::is(arch::AIE))
auto | aie::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 | aie::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 | aie::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 | aie::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 Elems> requires (arch::is(arch::AIE))
accum< accfloat, Elems > | aie::sqrt (const accum< accfloat, Elems > &v)
| Returns the square root of all values in an accumulator.
template<RealVector Vec>
auto | aie::sqrt (const Vec &v) -> aie_dm_resource_remove_t< Vec >
| Returns the square root of all values in a vector.
template<RealElem E>
auto | aie::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 * | aie::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 * | aie::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 * | aie::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 * | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::sub (T a, T b)
static rounding_mode | aie::swap_rounding (rounding_mode m)
| Set the rounding mode used in accumulator to vector conversions and return the previously set mode.
static saturation_mode | aie::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 | aie::tanh (const vector< float, Elems > &v) -> vector< TR, Elems >
| Compute the hyperbolic tangent function on the elements of the input vector.
template<typename TR = cint32> requires (arch::is(arch::AIE, arch::AIE_ML) && Utils::is_one_of_v<TR, cint16, cint32>)
auto | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::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 | aie::to_float (const vector< T, Elems > &v, int shift=0) -> vector< TR, Elems >
| Convert the elements in a complex fixed-point vector into floating point values.
template<typename TR = float>
auto | aie::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 | aie::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()> | aie::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 | aie::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 | aie::unpack (const Vec &v) -> vector< T2, Vec::size()>
| Returns a conversion of the passed vector to the next larger integer datatype, with the same number of elements.
template<Vector Vec>
auto | aie::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<ElemBaseType DstT, Accum Acc> requires (arch::is(arch::Gen2))
auto | aie::vector_cast (const Acc &acc)
| Reinterpret an accumulator as a vector.
template<ElemBaseType DstT, Vector Vec>
auto | aie::vector_cast (const Vec &v)
| Reinterpret a vector using a different element type.
template<AccumElemBaseType DstTag, Vector Vec> requires (arch::is(arch::Gen2))
auto | aie::vector_cast (const Vec &v)
| Reinterpret a vector as an accumulator.
template<ElemBaseType T>
constexpr T | aie::zero ()
| Returns the zero value for the requested data type.
template<ElemBaseType T, unsigned Elems = native_vector_length_v<T>>
vector< T, Elems > | aie::zeros ()
| Returns a vector whose elements are initialized to zero.
template<AccumElemBaseType AccumTag, unsigned Elems = native_vector_length_v<AccumTag>>
accum< AccumTag, Elems > | aie::zeros ()
| Returns a vector whose elements are initialized to zero.

## Variables
template<typename T>
static constexpr bool | aie::is_lut_v = is_lut<T>::value()
template<typename T>
static constexpr bool | aie::is_mmul_or_op_v
template<typename T>
static constexpr bool | aie::is_mmul_v = is_mmul<T>::value
template<Accum Acc1, Accum Acc2>
static constexpr bool | aie::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 | aie::is_same_vector_v = is_same_vector<aie_dm_resource_remove_t<Vec1>, aie_dm_resource_remove_t<Vec2>>::value
template<typename T1, typename T2>
static constexpr bool | aie::is_valid_elem_op_v = is_valid_elem_op<T1, T2>::value
template<typename T, typename T2, typename... Other>
static constexpr bool | aie::is_valid_size_v = is_valid_size<T, T2, Other...>::value
static constexpr int | aie::max_shift = detail::max_shift
static constexpr int | aie::min_shift = detail::min_shift
static constexpr unsigned | aie::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 | aie::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 | aie::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::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::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< 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 |

## Macro Definition Documentation

## ◆ __AIE_API_AIE__HPP__

#define __AIE_API_AIE__HPP__

## ◆ AIE_API_CXX_VERSION

#define AIE_API_CXX_VERSION 202002L