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 "iterator.hpp"
#include "mask.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_mul_op< T1, T2 >
struct	aie::is_valid_mul_op< binary_op< Parent1, Parent2, Op >, T2 >
struct	aie::is_valid_mul_op< T, binary_op< Parent1, Parent2, Op > >
struct	aie::is_valid_mul_op< T, unary_op< Parent, Op > >
struct	aie::is_valid_mul_op< unary_op< Parent, Op >, 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 >
struct	aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >
struct	aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >
	This type provides a parametrized multiplication that implements the following compute pattern: More...
struct	aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >
struct	aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >
class	aie::tensor_descriptor< Rank, T, Elems, NativeRepr >
struct	aie::tensor_dim

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 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 >
using	aie::dim_2d = detail::dim_2d
using	aie::dim_3d = detail::dim_3d
template<unsigned Vectorization, unsigned Radix, typename Input , typename Output = Input, typename Twiddle = detail::default_twiddle_type_t<Input, Output>>
using	aie::fft_dit = detail::fft_dit< Vectorization, detail::fft_get_stage< Vectorization, Radix, Input, Output, Twiddle >(), Radix, Input, Output, Twiddle >
	Type that encapsulates the functionality for decimation-in-time FFTs.
template<typename T >
using	aie::operand_base_type_t = typename operand_base_type< Utils::remove_all_t< T > >::type
template<typename T >
using	aie::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	aie::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	aie::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	aie::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	aie::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	aie::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	aie::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	aie::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	aie::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	aie::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	aie::sliding_window_dim_1d = detail::sliding_window_dim_1d
using	aie::sliding_window_dim_2d = detail::sliding_window_dim_2d
using	aie::sliding_window_dim_3d = detail::sliding_window_dim_3d

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::utils::get_complex_component_type_t< operand_base_type_t< E > >
	Compute the absolute square of a scalar complex value.
template<typename TR = int32, ComplexVector 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 Elems> requires (arch::is(arch::AIE) || (arch::is(arch::AIE_ML) && __AIE_API_COMPLEX_FP32_EMULATION__ == 1))
constexpr vector< float, Elems >	aie::abs_square (const vector< cfloat, Elems > &v)
	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::AIE_ML) && 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<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<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) && __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::utils::get_complex_component_type_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) && __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::utils::get_complex_component_type_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>
constexpr 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<unsigned Vectorization, typename Input , typename Output , typename Twiddle > requires (arch::is(arch::AIE) && detail::is_floating_point_v<Input>)
void	aie::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::AIE, arch::AIE_ML))
void	aie::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<unsigned Vectorization, typename Input , typename Output , typename Twiddle > requires (arch::is(arch::AIE) && detail::is_floating_point_v<Input>)
void	aie::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::AIE, arch::AIE_ML))
void	aie::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<unsigned Vectorization, typename Input , typename Output , typename Twiddle > requires (arch::is(arch::AIE, arch::AIE_ML))
void	aie::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<unsigned Vectorization, typename Input , typename Output , typename Twiddle > requires (arch::is(arch::AIE) && detail::is_floating_point_v<Input>)
void	aie::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::AIE, arch::AIE_ML))
void	aie::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<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) -> vector< detail::utils::get_complex_component_type_t< typename Vec::value_type >, Vec::size()>
	Gather and return the imaginary components of a complex vector.
template<ComplexElem Elem>
auto	aie::imag (Elem e) -> detail::utils::get_complex_component_type_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::AIE_ML) && 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::AIE_ML) && 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<unsigned Elems> requires (arch::is(arch::AIE))
accum< accfloat, Elems >	aie::inv (const accum< accfloat, Elems > &v)
template<Vector Vec>
auto	aie::inv (const Vec &v) -> aie_dm_resource_remove_t< Vec >
template<RealElem E>
auto	aie::inv (E a)
template<unsigned Elems> requires (arch::is(arch::AIE))
accum< accfloat, Elems >	aie::invsqrt (const accum< accfloat, Elems > &v)
template<Vector Vec>
auto	aie::invsqrt (const Vec &v) -> aie_dm_resource_remove_t< Vec >
template<Elem E>
auto	aie::invsqrt (E a)
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>
constexpr 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<aie_dm_resource Resource = aie_dm_resource::none, typename T , typename TensorDescriptor >
constexpr auto	aie::make_restrict_tensor_buffer_stream (T *__restrict base, const TensorDescriptor &tensor_desc)
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , typename TensorDescriptor >
constexpr auto	aie::make_tensor_buffer_stream (const T *base, const TensorDescriptor &tensor_desc)
template<aie_dm_resource Resource = aie_dm_resource::none, typename T , typename TensorDescriptor >
constexpr auto	aie::make_tensor_buffer_stream (T *base, const TensorDescriptor &tensor_desc)
template<typename T , unsigned Elems, typename... Args> requires (arch::is(arch::AIE_ML) && (std::is_same_v<Args, tensor_dim> && ...))
constexpr auto	aie::make_tensor_descriptor (Args &&... args)
template<typename T , unsigned Elems, typename... Args> requires (arch::is(arch::AIE_ML) && (std::is_same_v<Args, tensor_dim> && ...))
constexpr auto	aie::make_tensor_descriptor_bytes (Args &&... args)
template<typename T , unsigned Elems, typename... Args>
constexpr auto	aie::make_tensor_descriptor_from_native (Args &&... args)
template<typename T , unsigned Elems, typename... Args>
constexpr auto	aie::make_tensor_descriptor_from_native_bytes (Args &&... args)
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::AIE_ML) && 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::AIE_ML) && 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::AIE_ML) && 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::AIE_ML) && 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::AIE_ML) && 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::AIE_ML) && 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::AIE_ML) && 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::AIE_ML) && 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::AIE_ML) && 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 , Vector VecA, Vector 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, Accum Acc, Vector VecA, Vector 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, Vector VecA, Vector 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<Accum 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) -> aie_dm_resource_remove_t< Acc >
	Returns an accumulator with the element-wise multiply-add of input vector, value and accumulator.
template<Accum 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) -> aie_dm_resource_remove_t< Acc >
	Returns an accumulator with the element-wise multiply-add of the two input vectors and accumulator.
template<Accum 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) -> aie_dm_resource_remove_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::msc (TR c, T1 a, T2 b)
template<Accum 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<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<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<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) -> vector< detail::utils::get_complex_component_type_t< typename Vec::value_type >, Vec::size()>
	Gather and return the real components of a complex vector.
template<ComplexElem Elem>
auto	aie::real (Elem e) -> detail::utils::get_complex_component_type_t< operand_base_type_t< Elem > >
	Return the real component of a complex value.
template<Vector Vec>
Vec::value_type	aie::reduce_add (const Vec &v)
	Returns sum of the elements in the input vector.
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)
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 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)
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)
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)
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)
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)
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)
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)
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)
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)
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::AIE_ML) && 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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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::AIE_ML) && 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)
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)
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)
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)
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)
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)
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)
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)
template<unsigned Elems> requires (arch::is(arch::AIE))
accum< accfloat, Elems >	aie::sqrt (const accum< accfloat, Elems > &v)
template<Vector Vec>
auto	aie::sqrt (const Vec &v) -> aie_dm_resource_remove_t< Vec >
template<Elem E>
auto	aie::sqrt (E a)
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::AIE_ML) && 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 = 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::AIE_ML))
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 (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 = float, typename T , unsigned Elems> requires (Utils::is_one_of_v<T, int16, int32>)
auto	aie::to_float (const vector< T, Elems > &v, int shift=0) -> vector< TR, Elems >
	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>
constexpr 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::AIE_ML))
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::AIE_ML))
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 >
static constexpr bool	aie::is_valid_mul_op_v = is_valid_mul_op<T, 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_v = detail::vector_ldst_align_v<T, Elems>
	Specifies the minimum alignment requirement 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

aie::operand_base_type

struct aie::operand_base_type

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

Class Members
typedef aie_dm_resource_remove_t< T >	type

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

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

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

Class Members
typedef typename value_type	type

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

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

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

Class Members
typedef typename value_type	type

aie::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 T	type

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

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
typedef T	type
typedef operand_base_type_t< T >	type
typedef typename result_type	type

Macro Definition Documentation

__AIE_API_AIE__HPP__

#define __AIE_API_AIE__HPP__

AIE_API_CXX_VERSION

#define AIE_API_CXX_VERSION   202002L