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

Loading...
Searching...
No Matches
Special Multiplications

## Overview

AIE provides hardware support to accelerate special multiplications that can be used to accelerate specific application use cases like (but not limited to) signal processing.

## Classes
class | aie::partial_sliding_mul< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >
| Object oriented interface to sliding_mul_ops. More...
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 >

## Typedefs
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.

## Functions
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.

## Class Documentation

## ◆ aie::partial_sliding_mul

class aie::partial_sliding_mul

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
class aie::partial_sliding_mul< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >

Object oriented interface to sliding_mul_ops.

It allows the implementation to pick a better partial result internally when it differs from the layout of the result type.

constexpr unsigned Lanes = 16;
constexpr unsigned Points = 32;
using sliding_mul_t = aie::partial_sliding_mul<Lanes, Points / 2, 1, 1, 1, cint16, cint16, cacc64>;
sliding_mul_t kernel(const cint16 *coeff, const cint16 *data) {
aie::vector coeffs = aie::load_v<32>(coeff);
aie::vector_iterator data_it = aie::begin_vector<32>(data);
unsigned c_start = 0, d_start = 0;
sliding_mul_t result;
result.mul(coeffs, c_start, *data_it++, d_start);
result.mac(coeffs, c_start, *data_it++, d_start);
return result;
}

See also
  sliding_mul_ops

### Public Types
using | accum_type = accum<AccumTag, Lanes>
using | real_accum_type = detail::remove_complex_t<accum_type>
### Public Member Functions
| partial_sliding_mul ()=default
| Default constructor.
| partial_sliding_mul (const accum_type &acc)
| Initialise partial result from an existing accumulator.
| partial_sliding_mul (const partial_sliding_mul &)=default
| Copy constructor.
| partial_sliding_mul (const std::array< real_accum_type, 2 > &acc)
| Initialise partial result from each of the complex components (real and imaginary).
template<VectorOrOp VecCoeff, VectorOrOp VecData>
void | mac (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
| Performs a multiplication operation following sliding_mul_ops formula, adding its result to its previous internal value, if there is any.
template<VectorOrOp VecCoeff, VectorOrOp VecData>
void | mul (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
| Performs a multiplication operation following sliding_mul_ops formula, overwriting any existing internal value.
accum_type | to_accum () const
| Returns the result.
std::array< real_accum_type, 2 > | to_accum_components () const
| Returns the result of the operation in separate real and imaginary components.
template<ElemBaseType T>
vector< T, Lanes > | to_vector (int shift=0) const
| Returns the result of the operation in a vector, applying shift-round-saturate.
template<ElemBaseType T> requires (accum_type::is_complex())
std::array< vector< T, Lanes >, 2 > | to_vector_components (int shift=0) const
| Returns the result of the operation in separate real and imaginary vetor components.

#### Member Typedef Documentation

## ◆ accum_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::partial_sliding_mul< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::accum_type = accum<AccumTag, Lanes>

## ◆ real_accum_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::partial_sliding_mul< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::real_accum_type = detail::remove_complex_t<accum_type>

#### Constructor & Destructor Documentation

## ◆ partial_sliding_mul() [1/4]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

aie::partial_sliding_mul< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::partial_sliding_mul | ( |  | ) |
| default

Default constructor.

## ◆ partial_sliding_mul() [2/4]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

aie::partial_sliding_mul< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::partial_sliding_mul | ( | const partial_sliding_mul< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag > & |  | ) |
| default

Copy constructor.

## ◆ partial_sliding_mul() [3/4]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

aie::partial_sliding_mul< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::partial_sliding_mul | ( | const accum_type & | acc | ) |
| inline explicit

Initialise partial result from an existing accumulator.

## ◆ partial_sliding_mul() [4/4]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

aie::partial_sliding_mul< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::partial_sliding_mul | ( | const std::array< real_accum_type, 2 > & | acc | ) |
| inline explicit

Initialise partial result from each of the complex components (real and imaginary).

This is only available when the result of the operation is a series of complex values.

#### Member Function Documentation

## ◆ mac()

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<VectorOrOp VecCoeff, VectorOrOp VecData>

void aie::partial_sliding_mul< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mac | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start )
| inline

Performs a multiplication operation following sliding_mul_ops formula, adding its result to its previous internal value, if there is any.

## ◆ mul()

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<VectorOrOp VecCoeff, VectorOrOp VecData>

void aie::partial_sliding_mul< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start )
| inline

Performs a multiplication operation following sliding_mul_ops formula, overwriting any existing internal value.

## ◆ to_accum()

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

accum_type aie::partial_sliding_mul< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::to_accum | ( |  | ) | const
| inline

Returns the result.

## ◆ to_accum_components()

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

std::array< real_accum_type, 2 > aie::partial_sliding_mul< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::to_accum_components | ( |  | ) | const
| inline

Returns the result of the operation in separate real and imaginary components.

This is only allowed when the result of the operation is a series of complex values.

## ◆ to_vector()

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<ElemBaseType T>

vector< T, Lanes > aie::partial_sliding_mul< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::to_vector | ( | int | shift = 0 | ) | const
| inline

Returns the result of the operation in a vector, applying shift-round-saturate.

See also
  accum::to_vector

## ◆ to_vector_components()

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<ElemBaseType T>
requires (accum_type::is_complex())

std::array< vector< T, Lanes >, 2 > aie::partial_sliding_mul< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::to_vector_components | ( | int | shift = 0 | ) | const
| inline

Returns the result of the operation in separate real and imaginary vetor components.

This is only allowed when the result of the operation is a series of complex values.

See also
  accum::to_vector
  to_vector
  to_accum_components

#### Friends And Related Symbol Documentation

## ◆ operator<<

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

output_cascade< AccumTag, void > & operator<< | ( | output_cascade< AccumTag, void > & | cascade,
|  | const partial_sliding_mul< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag > & | value )
| friend

Writes a partial_sliding_mul value to a cascade output port.

The value's internal sum must have a valid initialised accumulator, that is, it must not be a default initialised value.

## ◆ operator>>

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

input_cascade< AccumTag, void > & operator>> | ( | input_cascade< AccumTag, void > & | cascade,
|  | partial_sliding_mul< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag > & | value )
| friend

Reads a partial_sliding_mul value from a cascade port.

## ◆ aie::sliding_mul_ch_ops

struct aie::sliding_mul_ch_ops

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>
requires (arch::is(arch::Gen2))
struct aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >

Note
  Supported since AIE-ML/XDNA1.

This type provides a parametrized multiplication that implements the following compute pattern:

DSX = DataStepX
DSY = DataStepY
CS = CoeffStep
P = Points
C = Channels
L = Lanes
c_s = coeff_start
d_s = data_start
for l in 0:L
for p in 0:P
out[l] += coeff[(c_s + (p * CS)) * C + (l % C)] * data[(d_s + ((l / C + p) * DSX)) * C + (l % C) * DSY]
More explicitly:
out[0] = coeff[c_s * C ] * data[ d_s * C ] + coeff[(c_s + CS) * C ] * data[(d_s + DSX) * C ] + ... + coeff[(c_s + (P-1) * CS) * C ] * data[(d_s + (P-1) * DSX) * C ]
out[1] = coeff[c_s * C + 1 ] * data[ d_s * C + DSY] + coeff[(c_s + CS) * C + 1 ] * data[(d_s + DSX) * C + DSY] + ... + coeff[(c_s + (P-1) * CS) * C + 1 ] * data[(d_s + (P-1) * DSX) * C + DSY]
...
out[C-1] = coeff[c_s * C + (C-1)] * data[ d_s * C + (C-1) * DSY] + coeff[(c_s + CS) * C + (C-1)] * data[(d_s + DSX) * C + (C-1) * DSY] + ... + coeff[(c_s + (P-1) * CS) + C + (C-1)] * data[(d_s + (P-1) * DSX) * C + (C-1) * DSY]
out[C] = coeff[c_s * C + ] * data[(d_s + DSX) * C ] + coeff[(c_s + CS) * C ] * data[(d_s + (1 + 1) * DSX) * C ] + ... + coeff[(c_s + (P-1) * CS) + C ] * data[(d_s + (1 + (P-1)) * DSX) * C ]
out[C+1] = coeff[c_s * C + 1 ] * data[(d_s + DSX) * C + DSY] + coeff[(c_s + CS) * C + 1 ] * data[(d_s + (1 + 1) * DSX) * C + DSY] + ... + coeff[(c_s + (P-1) * CS) + C + 1 ] * data[(d_s + (1 + (P-1)) * DSX) * C + DSY]
...
out[L-1] = coeff[c_s * C + (C-1)] * data[(d_s + (L-1)/C * DSX) * C + (C-1) * DSY] + coeff[(c_s + CS) * C + (C-1)] * data[(d_s + ((L-1)/C + 1) * DSX) * C + (C-1) * DSY] + ... + coeff[(c_s + (P-1) * CS) * C + (C-1)] * data[(d_s + ((L-1)/C + (P-1)) * DSX) * C + (C-1) * DSY]
aie::sliding_mul_ch_ops::Lanes
static constexpr unsigned Lanes
Definition sliding_mul.hpp:2058

Supported parameters for sliding_mul_ch with 32b accumulation
Types (coeff x data) | Native accum. | Native lanes | Native points | Channels | CoeffStep | DataStep | coeff_start | data_start
--- | --- | --- | --- | --- | --- | --- | --- | ---
8b x 8b | AIE-ML/XDNA1 | acc32 | 4 | 4 | 8 | 1 | 1 | Unsigned | Signed
acc32 | 8 | 8 | 4 | 1 | 1 | Unsigned | Signed
XDNA2 | acc32 | 8 | 8 | 8 | 1 | 1 | Unsigned | Signed
AIE-MLv2 | acc32 | 8 | 8 | 8 | 1 | 1 | Unsigned | Signed
16b x 16b | XDNA2 | acc64 | 4 | 4 | 8 | 1 | 1 | Unsigned | Signed
AIE-MLv2 | acc64 | 4 | 4 | 8 | 1 | 1 | Unsigned | Signed

Note
  Native lanes denotes the number of outputs handled by a single intrinsic call. For Lanes = N * Native lanes, N calls to the underlying intrinsic are made. For Lanes < Native lanes, a single call is made and the requested lanes extracted.
  Native points denotes the number of multiplications and additions handled by a single intrinsic call. Other values are emulated internally by zeroing certain coeff lanes and/or unrolling multiple intrinsic calls.
  coeff_start and data_start wrap around if greater than the number of values.

Template Parameters

  Outputs | Number of output samples per channel.
  Channels | Number of channels.
  Points | Number of data elements used to compute each lane.
  CoeffStep | Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
  DataStepX | Step used to select elements from the data buffer. This step is applied to element selection within a lane.
  DataStepY | Step used to select elements from the data buffer. This step is applied to element selection within a lane.
  CoeffType | Type of the coefficient elements.
  DataType | Type of the data elements.
  AccumTag | Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

See also
  sliding_mul_ch_x_ops, sliding_mul_ch_y_ops, sliding_mul_ch_xy_ops

### Public Types
using | accum_type = accum<detail::accum_tag_or_default_t<AccumTag, CoeffType, DataType>, Lanes>
using | coeff_type = typename impl_type::coeff_type
using | data_type = typename impl_type::data_type
using | impl_type = detail::sliding_mul_ch<Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, accum_bits, CoeffType, DataType>
enum class | MulType
### Static Public Member Functions
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits) && (VecData::bits() <= max_data_bits))
static constexpr accum_type | mac (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
| Performs a multiply-add with the pattern defined by the class parameters using the input coefficient and data arguments.
template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits) && (VecData::bits() <= max_data_bits))
static constexpr accum_type | mul (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
| Performs the multiplication pattern defined by the class parameters using the input coefficient and data arguments.
template<MulType Mul, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
static constexpr accum_type | mul_common (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, const Acc &...acc)
template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits) && (VecData::bits() <= max_data_bits))
static constexpr accum_type | negmul (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
| Performs a negation of the multiplication pattern defined by the class parameters using the input coefficient and data arguments.
### Static Public Attributes
static constexpr unsigned | columns_per_mul = impl_type::columns_per_mul
static constexpr unsigned | Lanes = Outputs * Channels
static constexpr unsigned | lanes = impl_type::lanes
static constexpr unsigned | lanes_per_mul = impl_type::lanes_per_mul
static constexpr unsigned | num_mul = impl_type::num_mul
static constexpr unsigned | points = impl_type::points

#### Member Typedef Documentation

## ◆ accum_type

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::accum_type = accum<detail::accum_tag_or_default_t<AccumTag, CoeffType, DataType>, Lanes>

## ◆ coeff_type

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::coeff_type = typename impl_type::coeff_type

## ◆ data_type

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::data_type = typename impl_type::data_type

## ◆ impl_type

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::impl_type = detail::sliding_mul_ch<Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, accum_bits, CoeffType, DataType>

#### Member Enumeration Documentation

## ◆ MulType

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

enum class aie::sliding_mul_ch_ops::MulType
| strong

Enumerator
Mul |
Acc_Mul |
NegMul |

#### Member Function Documentation

## ◆ mac()

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits) && (VecData::bits() <= max_data_bits))

constexpr accum_type aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mac | ( | const Acc & | acc,
|  | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start )
| inline static constexpr

Performs a multiply-add with the pattern defined by the class parameters using the input coefficient and data arguments.

Parameters

  acc | Accumulator that is added to the result of the multiplication.
  coeff | Vector of coefficients. Vectors limited to 256b and 512b on AIE and AIE-ML/XDNA1 respectively.
  coeff_start | Index of the first coefficient element to be used in the multiplication.
  data | Vector of data samples.
  data_start | Index of the first data element to be used in the multiplication.

## ◆ mul()

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>
template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits) && (VecData::bits() <= max_data_bits))

constexpr accum_type aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start )
| inline static constexpr

Performs the multiplication pattern defined by the class parameters using the input coefficient and data arguments.

Parameters

  coeff | Vector of coefficients. Vectors limited to 256b and 512b on AIE and AIE-ML/XDNA1 respectively.
  coeff_start | Index of the first coefficient element to be used in the multiplication.
  data | Vector of data samples.
  data_start | Index of the first data element to be used in the multiplication.

## ◆ mul_common()

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>
template<MulType Mul, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

constexpr accum_type aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_common | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start,
|  | const Acc &... | acc )
| inline static constexpr

## ◆ negmul()

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>
template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits) && (VecData::bits() <= max_data_bits))

constexpr accum_type aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::negmul | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start )
| inline static constexpr

Performs a negation of the multiplication pattern defined by the class parameters using the input coefficient and data arguments.

Parameters

  coeff | Vector of coefficients. Vectors limited to 256b and 512b on AIE and AIE-ML/XDNA1 respectively.
  coeff_start | Index of the first coefficient element to be used in the multiplication.
  data | Vector of data samples.
  data_start | Index of the first data element to be used in the multiplication.

#### Member Data Documentation

## ◆ columns_per_mul

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::columns_per_mul = impl_type::columns_per_mul
| static constexpr

## ◆ Lanes

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::Lanes = Outputs * Channels
| static constexpr

## ◆ lanes

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::lanes = impl_type::lanes
| static constexpr

## ◆ lanes_per_mul

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::lanes_per_mul = impl_type::lanes_per_mul
| static constexpr

## ◆ num_mul

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::num_mul = impl_type::num_mul
| static constexpr

## ◆ points

template<unsigned Outputs, unsigned Channels, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::sliding_mul_ch_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_ch_ops< Outputs, Channels, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::points = impl_type::points
| static constexpr

## ◆ aie::sliding_mul_ops

struct aie::sliding_mul_ops

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
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:

DSX = DataStepX
DSY = DataStepY
CS = CoeffStep
P = Points
L = Lanes
c_s = coeff_start
d_s = data_start
out[0] = coeff[c_s] * data[d_s + ] + coeff[c_s + CS] * data[d_s + DSX] + ... + coeff[c_s + (P-1) * CS] * data[d_s + (P-1) * DSX]
out[1] = coeff[c_s] * data[d_s + DSY] + coeff[c_s + CS] * data[d_s + DSY + DSX] + ... + coeff[c_s + (P-1) * CS] * data[d_s + DSY + (P-1) * DSX]
...
out[L-1] = coeff[c_s] * data[d_s + (L-1) * DSY] + coeff[c_s + CS] * data[d_s + (L-1) * DSY + DSX] + ... + coeff[c_s + (P-1) * CS] * data[d_s + (L-1) * DSY + (P-1) * DSX]

Supported AIE parameters for sliding_mul
Types (coeff x data) | Native accum. | Native lanes | Native points | CoeffStep | DataStepX | DataStepY | coeff_start | data_start
--- | --- | --- | --- | --- | --- | --- | --- | ---
8b x 8b | AIE-ML/XDNA1 | acc32 | 32 | 8 | 1,2 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
XDNA2 | acc32 | 64 | 8 | 1,2 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
AIE-MLv2 | acc32 | 64 | 8 | 1,2 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
16b x 16b | AIE | acc48 | 8 16 | 32/Lanes | 1,2,3,4 | 1 | 1 | Unsigned smaller than 16 | Signed
AIE-ML/XDNA1 | acc32 | 16 | 4 | 1,2 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
acc64 | 16 | 4 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
XDNA2 | acc32 | 32 | 4 | 1,2 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
AIE-MLv2 | acc32 | 32 | 4 | 1,2 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
16b x 32b | AIE | acc48 | 8 16 | 16/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2 1 | Unsigned smaller than 16 | Signed
acc80 | 8 | 16/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2 | Unsigned smaller than 16 | Signed
AIE-ML/XDNA1 | acc64 | 16 | 4 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
XDNA2 | acc64 | 32 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
AIE-MLv2 | acc64 | 32 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
32b x 16b | AIE | acc48 | 8 16 | 16/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2 1 | Unsigned smaller than 16 | Signed
acc80 | 8 | 16/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2 | Unsigned smaller than 16 | Signed
AIE-ML/XDNA1 | acc64 | 16 | 4 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
XDNA2 | acc64 | 32 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
AIE-MLv2 | acc64 | 32 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
32b x 32b | AIE | acc80 | 4 8 | 8/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 1,2 | Unsigned smaller than 16 | Signed
AIE-ML/XDNA1 | acc64 | 16 | 4 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
XDNA2 | acc64 | 32 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
AIE-MLv2 | acc64 | 32 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
16b x c16b | AIE | cacc48 | 4 8 | 16/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 1,2 | Unsigned smaller than 16 | Signed
AIE-ML/XDNA1 | cacc64 | 161 | 4 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
XDNA2 | cacc64 | 321 | 4 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
AIE-MLv2 | cacc64 | 321 | 4 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
16b x c32b | AIE | cacc48 | 4 8 | 8/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 1,2 | Unsigned smaller than 16 | Signed
cacc80 | 4 | 8/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
AIE-ML/XDNA1 | cacc64 | 161, 2 | 4 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
XDNA2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
AIE-MLv2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
32b x c16b | AIE | cacc48 | 4 8 | 8/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 1,2 | Unsigned smaller than 16 | Signed
cacc80 | 4 | 8/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
AIE-ML/XDNA1 | cacc64 | 161 | 4 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
XDNA2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
AIE-MLv2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
32b x c32b | AIE | cacc80 | 2 4 | 4/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
AIE-ML/XDNA1 | cacc64 | 161, 2 | 4 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
XDNA2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
AIE-MLv2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
c16b x 16b | AIE | cacc48 | 4 8 | 16/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 1,2 | Unsigned smaller than 16 | Signed
AIE-ML/XDNA1 | cacc64 | 161 | 4 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
XDNA2 | cacc64 | 321 | 4 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
AIE-MLv2 | cacc64 | 321 | 4 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
c16b x 32b | AIE | cacc48 | 4 8 | 8/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 1,2 | Unsigned smaller than 16 | Signed
cacc80 | 4 | 8/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
AIE-ML/XDNA1 | cacc64 | 161 | 4 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
XDNA2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
AIE-MLv2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
c16b x c16b | AIE | cacc48 | 4 8 | 8/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 1,2 | Unsigned smaller than 16 | Signed
AIE-ML/XDNA1 | cacc64 | 161 | 4 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
XDNA2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
AIE-MLv2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
c16b x c32b | AIE | cacc48 | 4 | 4/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
cacc80 | 4 | 4/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
AIE-ML/XDNA1 | cacc64 | 81 | 4 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
XDNA2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
AIE-MLv2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
c32b x 16b | AIE | cacc48 | 4 8 | 8/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 1,2 | Unsigned smaller than 16 | Signed
cacc80 | 4 | 8/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
AIE-ML/XDNA1 | cacc64 | 161 | 4 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
XDNA2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
AIE-MLv2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
c32b x 32b | AIE | cacc80 | 2 4 | 4/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
AIE-ML/XDNA1 | cacc64 | 161 | 4 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
XDNA2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
AIE-MLv2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
c32b x c16b | AIE | cacc48 | 4 | 4/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
cacc80 | 4 | 4/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
AIE-ML/XDNA1 | cacc64 | 81 | 4 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
XDNA2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
AIE-MLv2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
c32b x c32b | AIE | cacc80 | 2 | 2/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
AIE-ML/XDNA1 | cacc64 | 8 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
XDNA2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
AIE-MLv2 | cacc64 | 161 | 1 | 1 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed

Note
  1
    Complex multiplication is emulated by decomposing the product into real x real multiplications. Real and complex results are shuffled into the result vector at the end.
  2
    These real-coeff by complex-data operations compute real and complex components separately.

Supported AIE parameters for sliding_mul with floating point accumulation
Types (coeff x data) | Native accum. | Native lanes | Native points | CoeffStep | DataStepX | DataStepY | coeff_start | data_start
--- | --- | --- | --- | --- | --- | --- | --- | ---
bfloat16 x bfloat16 | AIE-ML/XDNA1 | accfloat | 16 | 1 | 1,2 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
XDNA2 | accfloat | 64 | 1 | 1,2 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
AIE-MLv2 | accfloat | 64 | 1 | 1,2 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
float x float | AIE | accfloat | 8 | 1 | 1,2,3,4 | 1,2,3,4 | 1,2 | Unsigned smaller than 16 | Signed
AIE-ML/XDNA1 | accfloat | 32 | 1 | 1,2 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
XDNA2 | accfloat | 32 | 1 | 1,2 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
AIE-MLv2 | accfloat | 16 | 1 | 1,2 | 1,2 | 1,2 (needs to match DataStepX) | Unsigned | Signed
float x cfloat | AIE | caccfloat | 4 | 1 | 1,2,3 | 1,2,3,4 | 1,2,3 | Unsigned smaller than 16 | Signed
cfloat x float | AIE | caccfloat | 4 | 1 | 1,2,3,4 | 1,2,3,4 | 1,2,3 | Unsigned smaller than 16 | Signed
cfloat x cfloat | AIE | caccfloat | 4 | 1 | 1,2,3 | 1,2,3,4 | 1,2,3 | Unsigned smaller than 16 | Signed

Note
  Native lanes denotes the number of outputs handled by a single intrinsic call. For Lanes = N * Native lanes, N calls to the underlying intrinsic are made. For Lanes < Native lanes, a single call is made and the requested lanes extracted.
  Native points denotes the number of multiplications and additions handled by a single intrinsic call. Multiples of points are emulated by unrolling multiple intrinsic calls. For 32b accumulation modes, arbitrary points can be used and are emulated by zeroing coeff lanes.
  coeff_start and data_start wrap around if greater than the number of values.

Template Parameters

  Lanes | Number of output elements.
  Points | Number of data elements used to compute each lane.
  CoeffStep | Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
  DataStepX | Step used to select elements from the data buffer. This step is applied to element selection within a lane.
  DataStepY | Step used to select elements from the data buffer. This step is applied to element selection accross lanes.
  CoeffType | Type of the coefficient elements.
  DataType | Type of the data elements.
  AccumTag | Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

### Public Types
using | accum_type = accum<detail::accum_tag_or_default_t<AccumTag, CoeffType, DataType>, Lanes>
using | coeff_type = typename impl_type::coeff_type
using | data_type = typename impl_type::data_type
using | impl_type = detail::sliding_mul<Lanes, Points, CoeffStep, DataStepX, DataStepY, accum_bits, CoeffType, DataType>
enum class | MulType
### Static Public Member Functions
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits) && (VecData::bits() <= max_data_bits))
static constexpr accum_type | mac (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
| Performs a multiply-add with the pattern defined by the class parameters using the input coefficient and data arguments.
template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits) && (VecData::bits() <= max_data_bits))
static constexpr accum_type | mul (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
| Performs the multiplication pattern defined by the class parameters using the input coefficient and data arguments.
template<MulType Mul, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)
static constexpr accum_type | mul_common (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, const Acc &...acc)
template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits) && (VecData::bits() <= max_data_bits))
static constexpr accum_type | negmul (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
| Performs a negation of the multiplication pattern defined by the class parameters using the input coefficient and data arguments.
### Static Public Attributes
static constexpr unsigned | columns_per_mul = impl_type::columns_per_mul
static constexpr unsigned | lanes = impl_type::lanes
static constexpr unsigned | lanes_per_mul = impl_type::lanes_per_mul
static constexpr unsigned | num_mul = impl_type::num_mul
static constexpr unsigned | points = impl_type::points

#### Member Typedef Documentation

## ◆ accum_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::accum_type = accum<detail::accum_tag_or_default_t<AccumTag, CoeffType, DataType>, Lanes>

## ◆ coeff_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::coeff_type = typename impl_type::coeff_type

## ◆ data_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::data_type = typename impl_type::data_type

## ◆ impl_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::impl_type = detail::sliding_mul<Lanes, Points, CoeffStep, DataStepX, DataStepY, accum_bits, CoeffType, DataType>

#### Member Enumeration Documentation

## ◆ MulType

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

enum class aie::sliding_mul_ops::MulType
| strong

Enumerator
Mul |
Acc_Mul |
NegMul |

#### Member Function Documentation

## ◆ mac()

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits) && (VecData::bits() <= max_data_bits))

constexpr accum_type aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mac | ( | const Acc & | acc,
|  | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start )
| inline static constexpr

Performs a multiply-add with the pattern defined by the class parameters using the input coefficient and data arguments.

Parameters

  acc | Accumulator that is added to the result of the multiplication.
  coeff | Vector of coefficients. Vectors limited to 256b and 512b on AIE and AIE-ML/XDNA1 respectively.
  coeff_start | Index of the first coefficient element to be used in the multiplication.
  data | Vector of data samples.
  data_start | Index of the first data element to be used in the multiplication.

## ◆ mul()

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits) && (VecData::bits() <= max_data_bits))

constexpr accum_type aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start )
| inline static constexpr

Performs the multiplication pattern defined by the class parameters using the input coefficient and data arguments.

Parameters

  coeff | Vector of coefficients. Vectors limited to 256b and 512b on AIE and AIE-ML/XDNA1 respectively.
  coeff_start | Index of the first coefficient element to be used in the multiplication.
  data | Vector of data samples.
  data_start | Index of the first data element to be used in the multiplication.

## ◆ mul_common()

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<MulType Mul, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type>)

constexpr accum_type aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_common | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start,
|  | const Acc &... | acc )
| inline static constexpr

## ◆ negmul()

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<typename VecCoeff::value_type, typename VecData::value_type> && (VecCoeff::bits() <= max_coeff_bits) && (VecData::bits() <= max_data_bits))

constexpr accum_type aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::negmul | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start )
| inline static constexpr

Performs a negation of the multiplication pattern defined by the class parameters using the input coefficient and data arguments.

Parameters

  coeff | Vector of coefficients. Vectors limited to 256b and 512b on AIE and AIE-ML/XDNA1 respectively.
  coeff_start | Index of the first coefficient element to be used in the multiplication.
  data | Vector of data samples.
  data_start | Index of the first data element to be used in the multiplication.

#### Member Data Documentation

## ◆ columns_per_mul

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::columns_per_mul = impl_type::columns_per_mul
| static constexpr

## ◆ lanes

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::lanes = impl_type::lanes
| static constexpr

## ◆ lanes_per_mul

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::lanes_per_mul = impl_type::lanes_per_mul
| static constexpr

## ◆ num_mul

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::num_mul = impl_type::num_mul
| static constexpr

## ◆ points

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::points = impl_type::points
| static constexpr

## ◆ aie::sliding_mul_sym_ops

struct aie::sliding_mul_sym_ops

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
requires (arch::is(arch::AIE))
struct aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >

Note
  Only supported in AIE.

This type provides a parametrized multiplication that implements the following compute pattern:

L = Lanes
P = Points
CS = CoeffStep
DSX = DataStepX
DSY = DataStepY
c_s = coeff_start
d_s = data_start
OP = Operation type: '+' for symmetric, '-' for anisymmetric
out[0] = coeff[c_s] * (data[d_s + ] OP data[d_s + (P-1) * DSX]) + coeff[c_s + CS] * (data[d_s + DSX] OP data[d_s + (P-2) * DSX]) + ...
+ coeff[c_s + (P/2-1 * CS)] * (data[d_s + (P/2-1) * DSX] OP data[d_s + P/2 * DSX]);
out[1] = coeff[c_s] * (data[d_s + DSY] OP data[d_s + DSY + (P-1) * DSX]) + coeff[c_s + CS] * (data[d_s + DSY + DSX] OP data[d_s + DSY + (P-2) * DSX]) + ...
+ coeff[c_s + (P/2-1 * CS)] * (data[d_s + DSY + (P/2-1) * DSX] OP data[d_s + DSY + P/2 * DSX]);
...
out[L-1] = coeff[c_s] * (data[d_s + (L-1) * DSY] OP data[d_s + (L-1) * DSY + (P-1) * DSX]) + coeff[c_s + CS] * (data[d_s + (L-1) * DSY + DSX] OP data[d_s + (L-1) * DSY + (P-2) * DSX]) + ...
+ coeff[c_s + (P/2-1 * CS)] * (data[d_s + (L-1) * DSY + (P/2-1) * DSX] OP data[d_s + (L-1) * DSY + P/2 * DSX]);
aie::saturation_mode::symmetric
@ symmetric
Retain maximum/minimum value on positive/negative overflow (signed types only). Max and min limits ha...
Definition aie_types.hpp:38
aie::Operation
Operation
Definition expr.hpp:20

Supported parameters for sliding_mul_sym with 48b accumulation
Types (coeff x data) | Native lanes | Native points | CoeffStep | DataStepX | DataStepY | coeff_start | data_start
--- | --- | --- | --- | --- | --- | --- | ---
16b x 16b | 8 16 | 64/Lanes | 1,2,3,4 | 1 | 1 | Unsigned smaller than 16 | Signed
16b x 32b | 8 16 | 32/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2 1 | Unsigned smaller than 16 | Signed
32b x 16b | 8 16 | 32/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2 1 | Unsigned smaller than 16 | Signed
16b x c16b | 4 8 | 32/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 1,2 | Unsigned smaller than 16 | Signed
c16b x 16b | 4 8 | 32/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 1,2 | Unsigned smaller than 16 | Signed
c16b x c16b | 4 8 | 16/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 1,2 | Unsigned smaller than 16 | Signed
c16b x 32b | 4 8 | 16/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 1,2 | Unsigned smaller than 16 | Signed
32b x c16b | 4 8 | 16/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 1,2 | Unsigned smaller than 16 | Signed
c32b x 16b | 4 8 | 16/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 1,2 | Unsigned smaller than 16 | Signed
16b x c32b | 4 8 | 16/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 1,2 | Unsigned smaller than 16 | Signed
c32b x c16b | 4 | 2 | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
c16b x c32b | 4 | 2 | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed

Supported parameters for sliding_mul_sym with 80b accumulation
Types (coeff x data) | Native lanes | Native points | CoeffStep | DataStepX | DataStepY | coeff_start | data_start
--- | --- | --- | --- | --- | --- | --- | ---
32b x 16b | 8 | 4 | 1,2,3,4 | 1,2,3,4 | 1,2 | Unsigned smaller than 16 | Signed
16b x 32b | 8 | 4 | 1,2,3,4 | 1,2,3,4 | 1,2 | Unsigned smaller than 16 | Signed
32b x 32b | 4 | 4 | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 1,2 | Unsigned smaller than 16 | Signed
32b x c16b | 4 | 4 | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
c16b x 32b | 4 | 4 | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
c32b x 16b | 4 | 2 | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
16b x c32b | 4 | 4 | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
c32b x c16b | 4 | 2 | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
c16b x c32b | 4 | 2 | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
c32b x 32b | 2 4 | 8/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
32b x c32b | 2 4 | 8/Lanes | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
c32b x c32b | 2 | 2 | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed

Note
  Native lanes denotes the number of outputs handled by a single intrinsic call. For Lanes = N * Native lanes, N calls to the underlying intrinsic are made. For Lanes < Native lanes, a single call is made and the requested lanes extracted.
  Native points denotes the number of multiplications and additions handled by a single intrinsic call. Multiples of points are emulated by unrolling multiple intrinsic calls. For 32b accumulation modes, arbitrary points can be used and are emulated by zeroing coeff lanes.

Template Parameters

  Lanes | Number of output elements.
  Points | Number of data elements used to compute each lane.
  CoeffStep | Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
  DataStepX | Step used to select elements from the data buffer. This step is applied to element selection within a lane.
  DataStepY | Step used to select elements from the data buffer. This step is applied to element selection across lanes.
  CoeffType | Type of the coefficient elements.
  DataType | Type of the data elements.
  AccumTag | Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

### Public Types
using | accum_type = accum<detail::accum_tag_or_default_t<AccumTag, CoeffType, DataType>, Lanes>
using | coeff_type = typename impl_type::coeff_type
using | data_type = typename impl_type::data_type
using | impl_type = detail::sliding_mul_sym<Lanes, Points, CoeffStep, DataStepX, DataStepY, accum_bits, CoeffType, DataType>
enum class | SymMulType
### Static Public Member Functions
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mac_antisym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
| Performs the antisymmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mac_antisym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
| Performs the antisymmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mac_antisym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
| Performs the antisymmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mac_sym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
| Performs the symmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mac_sym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
| Performs the symmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mac_sym (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
| Performs the symmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.
template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mul_antisym (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
| Performs the antisymmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.
template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mul_antisym (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
| Performs the antisymmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.
template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mul_antisym (const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
| Performs the antisymmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.
template<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mul_common (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, const Acc &...acc)
template<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mul_common (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start, const Acc &...acc)
template<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mul_common (const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start, const Acc &...acc)
template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mul_sym (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start)
| Performs the symmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.
template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mul_sym (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned ldata_start, unsigned rdata_start)
| Performs the symmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.
template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mul_sym (const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start)
| Performs the symmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.
### Static Public Attributes
static constexpr unsigned | columns_per_mul = impl_type::columns_per_mul
static constexpr unsigned | lanes = impl_type::lanes
static constexpr unsigned | lanes_per_mul = impl_type::lanes_per_mul
static constexpr unsigned | num_mul = impl_type::num_mul
static constexpr unsigned | points = impl_type::points

#### Member Typedef Documentation

## ◆ accum_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::accum_type = accum<detail::accum_tag_or_default_t<AccumTag, CoeffType, DataType>, Lanes>

## ◆ coeff_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::coeff_type = typename impl_type::coeff_type

## ◆ data_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::data_type = typename impl_type::data_type

## ◆ impl_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::impl_type = detail::sliding_mul_sym<Lanes, Points, CoeffStep, DataStepX, DataStepY, accum_bits, CoeffType, DataType>

#### Member Enumeration Documentation

## ◆ SymMulType

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

enum class aie::sliding_mul_sym_ops::SymMulType
| strong

Enumerator
Sym |
Antisym |
Acc_Sym |
Acc_Antisym |

#### Member Function Documentation

## ◆ mac_antisym() [1/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mac_antisym | ( | const Acc & | acc,
|  | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start )
| inline static constexpr

Performs the antisymmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.

This variant allows two separate start indices for left/right elements.

Parameters

  acc | Accumulator to be added to the result of the multiplication.
  coeff | Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
  coeff_start | Index of the first coefficient element to be used in the multiplication.
  data | Vector of data samples.
  data_start | Index of the first data element to be used in the multiplication.

## ◆ mac_antisym() [2/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mac_antisym | ( | const Acc & | acc,
|  | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | ldata_start,
|  | unsigned | rdata_start )
| inline static constexpr

Performs the antisymmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.

This variant allows two separate start indices for left/right elements.

Parameters

  acc | Accumulator to be added to the result of the multiplication.
  coeff | Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
  coeff_start | Index of the first coefficient element to be used in the multiplication.
  data | Vector of data samples.
  ldata_start | Index of the first left data element to be used in the multiplication.
  rdata_start | Index of the first right data element to be used in the multiplication.

## ◆ mac_antisym() [3/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mac_antisym | ( | const Acc & | acc,
|  | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | ldata,
|  | unsigned | ldata_start,
|  | const VecData & | rdata,
|  | unsigned | rdata_start )
| inline static constexpr

Performs the antisymmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.

This variant uses two input buffers for left/right elements.

Parameters

  acc | Accumulator to be added to the result of the multiplication.
  coeff | Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
  coeff_start | Index of the first coefficient element to be used in the multiplication.
  ldata | Vector of left data samples. The size is limitted to vectors of up to 512 bits.
  ldata_start | Index of the first left data element to be used in the multiplication.
  rdata | Vector of right data samples. The size is limitted to vectors of up to 512 bits.
  rdata_start | Index of the first right data element to be used in the multiplication.

## ◆ mac_sym() [1/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mac_sym | ( | const Acc & | acc,
|  | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start )
| inline static constexpr

Performs the symmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.

Parameters

  acc | Accumulator to be added to the result of the multiplication.
  coeff | Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
  coeff_start | Index of the first coefficient element to be used in the multiplication.
  data | Vector of data samples.
  data_start | Index of the first data element to be used in the multiplication.

## ◆ mac_sym() [2/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mac_sym | ( | const Acc & | acc,
|  | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | ldata_start,
|  | unsigned | rdata_start )
| inline static constexpr

Performs the symmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.

This variant allows two separate start indices for left/right elements.

Parameters

  acc | Accumulator to be added to the result of the multiplication.
  coeff | Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
  coeff_start | Index of the first coefficient element to be used in the multiplication.
  data | Vector of data samples.
  ldata_start | Index of the first left data element to be used in the multiplication.
  rdata_start | Index of the first right data element to be used in the multiplication.

## ◆ mac_sym() [3/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mac_sym | ( | const Acc & | acc,
|  | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | ldata,
|  | unsigned | ldata_start,
|  | const VecData & | rdata,
|  | unsigned | rdata_start )
| inline static constexpr

Performs the symmetric multiply-add pattern defined by the class parameters using the input coefficient and data arguments.

This variant uses two input buffers for left/right elements.

Parameters

  acc | Accumulator to be added to the result of the multiplication.
  coeff | Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
  coeff_start | Index of the first coefficient element to be used in the multiplication.
  ldata | Vector of left data samples. The size is limitted to vectors of up to 512 bits.
  ldata_start | Index of the first left data element to be used in the multiplication.
  rdata | Vector of right data samples. The size is limitted to vectors of up to 512 bits.
  rdata_start | Index of the first right data element to be used in the multiplication.

## ◆ mul_antisym() [1/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_antisym | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start )
| inline static constexpr

Performs the antisymmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.

This variant allows two separate start indices for left/right elements.

Parameters

  coeff | Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
  coeff_start | Index of the first coefficient element to be used in the multiplication.
  data | Vector of data samples.
  data_start | Index of the first data element to be used in the multiplication.

## ◆ mul_antisym() [2/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_antisym | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | ldata_start,
|  | unsigned | rdata_start )
| inline static constexpr

Performs the antisymmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.

This variant allows two separate start indices for left/right elements.

Parameters

  coeff | Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
  coeff_start | Index of the first coefficient element to be used in the multiplication.
  data | Vector of data samples.
  ldata_start | Index of the first left data element to be used in the multiplication.
  rdata_start | Index of the first right data element to be used in the multiplication.

## ◆ mul_antisym() [3/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_antisym | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | ldata,
|  | unsigned | ldata_start,
|  | const VecData & | rdata,
|  | unsigned | rdata_start )
| inline static constexpr

Performs the antisymmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.

This variant uses two input buffers for left/right elements.

Parameters

  coeff | Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
  coeff_start | Index of the first coefficient element to be used in the multiplication.
  ldata | Vector of left data samples. The size is limitted to vectors of up to 512 bits.
  ldata_start | Index of the first left data element to be used in the multiplication.
  rdata | Vector of right data samples. The size is limitted to vectors of up to 512 bits.
  rdata_start | Index of the first right data element to be used in the multiplication.

## ◆ mul_common() [1/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_common | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start,
|  | const Acc &... | acc )
| inline static constexpr

## ◆ mul_common() [2/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_common | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | ldata_start,
|  | unsigned | rdata_start,
|  | const Acc &... | acc )
| inline static constexpr

## ◆ mul_common() [3/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_common | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | ldata,
|  | unsigned | ldata_start,
|  | const VecData & | rdata,
|  | unsigned | rdata_start,
|  | const Acc &... | acc )
| inline static constexpr

## ◆ mul_sym() [1/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_sym | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start )
| inline static constexpr

Performs the symmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.

Parameters

  coeff | Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
  coeff_start | Index of the first coefficient element to be used in the multiplication.
  data | Vector of data samples.
  data_start | Index of the first data element to be used in the multiplication.

## ◆ mul_sym() [2/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_sym | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | ldata_start,
|  | unsigned | rdata_start )
| inline static constexpr

Performs the symmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.

This variant allows two separate start indices for left/right elements.

Parameters

  coeff | Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
  coeff_start | Index of the first coefficient element to be used in the multiplication.
  data | Vector of data samples.
  ldata_start | Index of the first left data element to be used in the multiplication.
  rdata_start | Index of the first right data element to be used in the multiplication.

## ◆ mul_sym() [3/3]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::mul_sym | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | ldata,
|  | unsigned | ldata_start,
|  | const VecData & | rdata,
|  | unsigned | rdata_start )
| inline static constexpr

Performs the symmetric multiplication pattern defined by the class parameters using the input coefficient and data arguments.

This variant uses two input buffers for left/right elements.

Parameters

  coeff | Vector of coefficients. On AIE the size is limited to vectors of up to 256 bits.
  coeff_start | Index of the first coefficient element to be used in the multiplication.
  ldata | Vector of left data samples. The size is limitted to vectors of up to 512 bits.
  ldata_start | Index of the first left data element to be used in the multiplication.
  rdata | Vector of right data samples. The size is limitted to vectors of up to 512 bits.
  rdata_start | Index of the first right data element to be used in the multiplication.

#### Member Data Documentation

## ◆ columns_per_mul

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::columns_per_mul = impl_type::columns_per_mul
| static constexpr

## ◆ lanes

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::lanes = impl_type::lanes
| static constexpr

## ◆ lanes_per_mul

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::lanes_per_mul = impl_type::lanes_per_mul
| static constexpr

## ◆ num_mul

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::num_mul = impl_type::num_mul
| static constexpr

## ◆ points

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStepX, int DataStepY, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_sym_ops< Lanes, Points, CoeffStep, DataStepX, DataStepY, CoeffType, DataType, AccumTag >::points = impl_type::points
| static constexpr

## ◆ aie::sliding_mul_sym_uct_ops

struct aie::sliding_mul_sym_uct_ops

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
requires (arch::is(arch::AIE))
struct aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >

Note
  Only supported in AIE.

This type provides a parametrized multiplication across the lower half of its lanes (equivalent to sliding_mul_sym_ops), and upshifts one selected set of data in the upper half of the lanes.

It implements the following compute pattern:

L = Lanes
P = Points
CS = CoeffStep
DS = DataStep
c_s = coeff_start
d_s = data_start
ups = uct_shift
out[0] = coeff[c_s] * (data[d_s + ] + data[d_s + (P-1) * DS]) + coeff[c_s + CS] * (data[d_s + DS] + data[d_s + (P-2) * DS]) + ...
+ coeff[c_s + (P/2-1 * CS)] * (data[d_s + (P/2-1) * DS] + data[d_s + P/2 * DS]);
out[1] = coeff[c_s] * (data[d_s + DS] + data[d_s + P * DS]) + coeff[c_s + CS] * (data[d_s + 2 * DS] + data[d_s + (P-1) * DS]) + ...
+ coeff[c_s + (P/2-1 * CS)] * (data[d_s + P/2 * DS] + data[d_s + (P/2+1) * DS]);
...
out[L/2-1] = coeff[c_s] * (data[d_s + (L/2-1) * DS] + data[d_s + (P+L/2-2) * DS]) + coeff[c_s + CS] * (data[d_s + L/2 * DS] + data[d_s + (P+L/2-3) * DS]) + ...
+ coeff[c_s + (P/2-1 * CS)] * (data[d_s + (P/2+L/2-2) * DS] + data[d_s + (P/2+L/2-1) * DS]);
out[L/2] = data[d_s + P/2 * DS] << ups
out[L/2+1] = data[d_s + (P/2+1) * DS] << ups
...
out[L-1] = data[d_s + (P/2+L/2-1) * DS] << ups

Supported parameters for sliding_mul_sym_uct with 48b accumulation
Types (coeff x data) | Native lanes | Native points | CoeffStep | DataStepX | DataStepY | coeff_start | data_start
--- | --- | --- | --- | --- | --- | --- | ---
c16b x c16b | 4 | 4 | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
32b x c16b | 4 | 4 | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed
c32b x c16b | 4 | 2 | 1,2,3,4 | 1,2,3,4 | 1,2,3,4 | Unsigned smaller than 16 | Signed

Note
  Native lanes denotes the number of outputs handled by a single intrinsic call. For Lanes = N * Native lanes, N calls to the underlying intrinsic are made. For Lanes < Native lanes, a single call is made and the requested lanes extracted.
  Native points denotes the number of multiplications and additions handled by a single intrinsic call. Multiples of points are emulated by unrolling multiple intrinsic calls. For 32b accumulation modes, arbitrary points can be used and are emulated by zeroing coeff lanes.

Template Parameters

  Lanes | Number of output elements.
  Points | Number of data elements used to compute each lane in the first half of the output Lanes.
  CoeffStep | Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
  DataStep | Step used to select elements from the data buffer. This step is applied to element selection within a lane and across lanes.
  CoeffType | Type of the coefficient elements.
  DataType | Type of the data elements.
  AccumTag | Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

See also
  sliding_mul_sym_ops

### Public Types
using | accum_type = accum<detail::accum_tag_or_default_t<AccumTag, CoeffType, DataType>, Lanes>
using | coeff_type = typename impl_type::coeff_type
using | data_type = typename impl_type::data_type
using | impl_type = detail::sliding_mul_sym_uct<Lanes, Points, CoeffStep, DataStep, accum_bits, CoeffType, DataType>
enum class | SymMulType
### Static Public Member Functions
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mac_antisym_uct (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | 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<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mac_sym_uct (const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | 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<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mul_antisym_uct (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)
template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | 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<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mul_common (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift, const Acc &...acc)
template<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mul_common (const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start, unsigned uct_shift, const Acc &...acc)
template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mul_sym_uct (const VecCoeff &coeff, unsigned coeff_start, const VecData &data, unsigned data_start, unsigned uct_shift)
template<VectorOrOp VecCoeff, VectorOrOp VecData> requires (is_valid_mul_op_v<CoeffType, DataType>)
static constexpr accum_type | mul_sym_uct (const VecCoeff &coeff, unsigned coeff_start, const VecData &ldata, unsigned ldata_start, const VecData &rdata, unsigned rdata_start, unsigned uct_shift)
### Static Public Attributes
static constexpr unsigned | columns_per_mul = impl_type::columns_per_mul
static constexpr unsigned | lanes = impl_type::lanes
static constexpr unsigned | lanes_per_mul = impl_type::lanes_per_mul
static constexpr unsigned | num_mul = impl_type::num_mul
static constexpr unsigned | points = impl_type::points

#### Member Typedef Documentation

## ◆ accum_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::accum_type = accum<detail::accum_tag_or_default_t<AccumTag, CoeffType, DataType>, Lanes>

## ◆ coeff_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::coeff_type = typename impl_type::coeff_type

## ◆ data_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::data_type = typename impl_type::data_type

## ◆ impl_type

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

using aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::impl_type = detail::sliding_mul_sym_uct<Lanes, Points, CoeffStep, DataStep, accum_bits, CoeffType, DataType>

#### Member Enumeration Documentation

## ◆ SymMulType

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

enum class aie::sliding_mul_sym_uct_ops::SymMulType
| strong

Enumerator
Sym |
Antisym |
Acc_Sym |
Acc_Antisym |

#### Member Function Documentation

## ◆ mac_antisym_uct() [1/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::mac_antisym_uct | ( | const Acc & | acc,
|  | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start,
|  | unsigned | uct_shift )
| inline static constexpr

## ◆ mac_antisym_uct() [2/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::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 )
| inline static constexpr

## ◆ mac_sym_uct() [1/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::mac_sym_uct | ( | const Acc & | acc,
|  | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start,
|  | unsigned | uct_shift )
| inline static constexpr

## ◆ mac_sym_uct() [2/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<AccumOrOp Acc, VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::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 )
| inline static constexpr

## ◆ mul_antisym_uct() [1/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::mul_antisym_uct | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start,
|  | unsigned | uct_shift )
| inline static constexpr

## ◆ mul_antisym_uct() [2/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::mul_antisym_uct | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | ldata,
|  | unsigned | ldata_start,
|  | const VecData & | rdata,
|  | unsigned | rdata_start,
|  | unsigned | uct_shift )
| inline static constexpr

## ◆ mul_common() [1/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::mul_common | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start,
|  | unsigned | uct_shift,
|  | const Acc &... | acc )
| inline static constexpr

## ◆ mul_common() [2/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<SymMulType MulType, VectorOrOp VecCoeff, VectorOrOp VecData, AccumOrOp... Acc>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::mul_common | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | ldata,
|  | unsigned | ldata_start,
|  | const VecData & | rdata,
|  | unsigned | rdata_start,
|  | unsigned | uct_shift,
|  | const Acc &... | acc )
| inline static constexpr

## ◆ mul_sym_uct() [1/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::mul_sym_uct | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | data,
|  | unsigned | data_start,
|  | unsigned | uct_shift )
| inline static constexpr

## ◆ mul_sym_uct() [2/2]

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>
template<VectorOrOp VecCoeff, VectorOrOp VecData>
requires (is_valid_mul_op_v<CoeffType, DataType>)

constexpr accum_type aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::mul_sym_uct | ( | const VecCoeff & | coeff,
|  | unsigned | coeff_start,
|  | const VecData & | ldata,
|  | unsigned | ldata_start,
|  | const VecData & | rdata,
|  | unsigned | rdata_start,
|  | unsigned | uct_shift )
| inline static constexpr

#### Member Data Documentation

## ◆ columns_per_mul

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::columns_per_mul = impl_type::columns_per_mul
| static constexpr

## ◆ lanes

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::lanes = impl_type::lanes
| static constexpr

## ◆ lanes_per_mul

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::lanes_per_mul = impl_type::lanes_per_mul
| static constexpr

## ◆ num_mul

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::num_mul = impl_type::num_mul
| static constexpr

## ◆ points

template<unsigned Lanes, unsigned Points, int CoeffStep, int DataStep, ElemBaseType CoeffType, ElemBaseType DataType, AccumElemBaseType AccumTag = detail::default_accum_tag_t<CoeffType, DataType>>

unsigned aie::sliding_mul_sym_uct_ops< Lanes, Points, CoeffStep, DataStep, CoeffType, DataType, AccumTag >::points = impl_type::points
| static constexpr

## Typedef Documentation

## ◆ sliding_mul_ch_x_ops

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>

Note
  Only supported from AIE-ML/XDNA1.

Similar to sliding_mul_ch_ops, but DataStepY is always 1.

DSX = DataStepX
CS = CoeffStep
P = Points
C = Channels
L = Lanes
c_s = coeff_start
d_s = data_start
for l in 0:L
for p in 0:P
out[l] += coeff[(c_s + (p * CS)) * C + (l % C)] * data[(d_s + ((l / C + p) * DSX)) * C + (l % C)]
More explicitly:
out[0] = coeff[c_s * C ] * data[ d_s * C ] + coeff[(c_s + CS) * C ] * data[(d_s + DSX) * C ] + ... + coeff[(c_s + (P-1) * CS) * C ] * data[(d_s + (P-1) * DSX) * C ]
out[1] = coeff[c_s * C + 1 ] * data[ d_s * C + 1] + coeff[(c_s + CS) * C + 1 ] * data[(d_s + DSX) * C + 1] + ... + coeff[(c_s + (P-1) * CS) * C + 1 ] * data[(d_s + (P-1) * DSX) * C + 1]
...
out[C-1] = coeff[c_s * C + (C-1)] * data[ d_s * C + (C-1)] + coeff[(c_s + CS) * C + (C-1)] * data[(d_s + DSX) * C + (C-1)] + ... + coeff[(c_s + (P-1) * CS) + C + (C-1)] * data[(d_s + (P-1) * DSX) * C + (C-1)]
out[C] = coeff[c_s * C + ] * data[(d_s + DSX) * C ] + coeff[(c_s + CS) * C + ] * data[(d_s + (1 + 1) * DSX) * C ] + ... + coeff[(c_s + (P-1) * CS) + C ] * data[(d_s + (1 + (P-1)) * DSX) * C ]
out[C+1] = coeff[c_s * C + 1 ] * data[(d_s + DSX) * C + 1] + coeff[(c_s + CS) * C + 1 ] * data[(d_s + (1 + 1) * DSX) * C + 1] + ... + coeff[(c_s + (P-1) * CS) + C + 1 ] * data[(d_s + (1 + (P-1)) * DSX) * C + 1]
...
out[L-1] = coeff[c_s * C + (C-1)] * data[(d_s + (L-1)/C * DSX) * C + (C-1)] + coeff[(c_s + CS) * C + (C-1)] * data[(d_s + ((L-1)/C + 1) * DSX) * C + (C-1)] + ... + coeff[(c_s + (P-1) * CS) * C + (C-1)] * data[(d_s + ((L-1)/C + (P-1)) * DSX) * C + (C-1)]

Template Parameters

  Outputs | Number of output samples.
  Channels | Number of channels.
  Points | Number of data elements used to compute each lane.
  CoeffStep | Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
  DataStepX | Step used to select elements from the data buffer. This step is applied to element selection within a lane.
  CoeffType | Type of the coefficient elements.
  DataType | Type of the data elements.
  AccumTag | Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

See also
  sliding_mul_ch_ops, sliding_mul_ch_y_ops, sliding_mul_ch_xy_ops

## ◆ sliding_mul_ch_xy_ops

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>

Note
  Only supported from AIE-ML/XDNA1.

Similar to sliding_mul_ch_ops, but DataStepX is equal to DataStepY.

DS = DataStep
CS = CoeffStep
P = Points
C = Channels
L = Lanes
c_s = coeff_start
d_s = data_start
for l in 0:L
for p in 0:P
out[l] += coeff[(c_s + (p * CS)) * C + (l % C)] * data[(d_s + ((l / C + p) * DS)) * C + (l % C) * DS]
More explicitly:
out[0] = coeff[c_s * C ] * data[ d_s * C ] + coeff[(c_s + CS) * C ] * data[(d_s + DS) * C ] + ... + coeff[(c_s + (P-1) * CS) * C ] * data[(d_s + (P-1) * DS) * C ]
out[1] = coeff[c_s * C + 1 ] * data[ d_s * C + DS] + coeff[(c_s + CS) * C + 1 ] * data[(d_s + DS) * C + DS] + ... + coeff[(c_s + (P-1) * CS) * C + 1 ] * data[(d_s + (P-1) * DS) * C + DS]
...
out[C-1] = coeff[c_s * C + (C-1)] * data[ d_s * C + (C-1) * DS] + coeff[(c_s + CS) * C + (C-1)] * data[(d_s + DS) * C + (C-1) * DS] + ... + coeff[(c_s + (P-1) * CS) + C + (C-1)] * data[(d_s + (P-1) * DS) * C + (C-1) * DS]
out[C] = coeff[c_s * C + ] * data[(d_s + DS) * C ] + coeff[(c_s + CS) * C ] * data[(d_s + (1 + 1) * DS) * C ] + ... + coeff[(c_s + (P-1) * CS) + C ] * data[(d_s + (1 + (P-1)) * DS) * C ]
out[C+1] = coeff[c_s * C + 1 ] * data[(d_s + DS) * C + DS] + coeff[(c_s + CS) * C + 1 ] * data[(d_s + (1 + 1) * DS) * C + DS] + ... + coeff[(c_s + (P-1) * CS) + C + 1 ] * data[(d_s + (1 + (P-1)) * DS) * C + DS]
...
out[L-1] = coeff[c_s * C + (C-1)] * data[(d_s + (L-1)/C * DS) * C + (C-1) * DS] + coeff[(c_s + CS) * C + (C-1)] * data[(d_s + ((L-1)/C + 1) * DS) * C + (C-1) * DS] + ... + coeff[(c_s + (P-1) * CS) * C + (C-1)] * data[(d_s + ((L-1)/C + (P-1)) * DS) * C + (C-1) * DS]

Template Parameters

  Outputs | Number of output samples.
  Channels | Number of channels.
  Points | Number of data elements used to compute each lane.
  CoeffStep | Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
  DataStep | Step used to select elements from the data buffer. This step is applied to element selection within a lane.
  CoeffType | Type of the coefficient elements.
  DataType | Type of the data elements.
  AccumTag | Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

See also
  sliding_mul_ch_ops, sliding_mul_ch_x_ops, sliding_mul_ch_y_ops

## ◆ sliding_mul_ch_y_ops

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>

Note
  Only supported from AIE-ML/XDNA1.

Similar to sliding_mul_ch_ops, but DataStepX is always 1.

DSY = DataStepY
CS = CoeffStep
P = Points
C = Channels
L = Lanes
c_s = coeff_start
d_s = data_start
for l in 0:L
for p in 0:P
out[l] += coeff[(c_s + (p * CS)) * C + (l % C)] * data[(d_s + ((l / C + p))) * C + (l % C) * DSY]
More explicitly:
out[0] = coeff[c_s * C ] * data[ d_s * C ] + coeff[(c_s + CS) * C ] * data[(d_s + 1) * C ] + ... + coeff[(c_s + (P-1) * CS) * C ] * data[(d_s + (P-1)) * C ]
out[1] = coeff[c_s * C + 1 ] * data[ d_s * C + DSY] + coeff[(c_s + CS) * C + 1 ] * data[(d_s + 1) * C + DSY] + ... + coeff[(c_s + (P-1) * CS) * C + 1 ] * data[(d_s + (P-1)) * C + DSY]
...
out[C-1] = coeff[c_s * C + (C-1)] * data[ d_s * C + (C-1) * DSY] + coeff[(c_s + CS) * C + (C-1)] * data[(d_s + 1) * C + (C-1) * DSY] + ... + coeff[(c_s + (P-1) * CS) + C + (C-1)] * data[(d_s + (P-1) ) * C + (C-1) * DSY]
out[C] = coeff[c_s * C + ] * data[(d_s + 1) * C ] + coeff[(c_s + CS) * C ] * data[(d_s + (1 + 1)) * C ] + ... + coeff[(c_s + (P-1) * CS) + C ] * data[(d_s + (1 + (P-1))) * C ]
out[C+1] = coeff[c_s * C + 1 ] * data[(d_s + 1) * C + DSY] + coeff[(c_s + CS) * C + 1 ] * data[(d_s + (1 + 1)) * C + DSY] + ... + coeff[(c_s + (P-1) * CS) + C + 1 ] * data[(d_s + (1 + (P-1))) * C + DSY]
...
out[L-1] = coeff[c_s * C + (C-1)] * data[(d_s + (L-1)/C) * C + (C-1) * DSY] + coeff[(c_s + CS) * C + (C-1)] * data[(d_s + ((L-1)/C + 1)) * C + (C-1) * DSY] + ... + coeff[(c_s + (P-1) * CS) * C + (C-1)] * data[(d_s + ((L-1)/C + (P-1))) * C + (C-1) * DSY]

Template Parameters

  Outputs | Number of output samples.
  Channels | Number of channels.
  Points | Number of data elements used to compute each lane.
  CoeffStep | Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
  DataStepY | Step used to select elements from the data buffer. This step is applied to element selection within a lane.
  CoeffType | Type of the coefficient elements.
  DataType | Type of the data elements.
  AccumTag | Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

See also
  sliding_mul_ch_ops, sliding_mul_ch_x_ops, sliding_mul_ch_xy_ops

## ◆ sliding_mul_sym_x_ops

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>

Note
  Only supported in AIE.

Similar to sliding_mul_sym_ops, but DataStepY is always 1.

L = Lanes
P = Points
CS = CoeffStep
DSX = DataStepX
c_s = coeff_start
d_s = data_start
out[0] = coeff[c_s] * (data[d_s + ] + data[d_s + (P-1) * DSX]) + coeff[c_s + CS] * (data[d_s + DSX] + data[d_s + (P-2) * DSX]) + ...
+ coeff[c_s + (P/2-1 * CS)] * (data[d_s + (P/2-1) * DSX] + data[d_s + P/2 * DSX]);
out[1] = coeff[c_s] * (data[d_s + 1] + data[d_s + 1 + (P-1) * DSX]) + coeff[c_s + CS] * (data[d_s + 1 + DSX] + data[d_s + 1 + (P-2) * DSX]) + ...
+ coeff[c_s + (P/2-1 * CS)] * (data[d_s + 1 + (P/2-1) * DSX] + data[d_s + 1 + P/2 * DSX]);
...
out[L-1] = coeff[c_s] * (data[d_s + (L-1)] + data[d_s + (L-1) + (P-1) * DSX]) + coeff[c_s + CS] * (data[d_s + (L-1) + DSX] + data[d_s + (L-1) + (P-2) * DSX]) + ...
+ coeff[c_s + (P/2-1 * CS)] * (data[d_s + (L-1) + (P/2-1) * DSX] + data[d_s + (L-1) + P/2 * DSX]);

Template Parameters

  Lanes | Number of output elements.
  Points | Number of data elements used to compute each lane.
  CoeffStep | Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
  DataStepX | Step used to select elements from the data buffer. This step is applied to element selection within a lane.
  CoeffType | Type of the coefficient elements.
  DataType | Type of the data elements.
  AccumTag | Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

See also
  sliding_mul_sym_ops

## ◆ sliding_mul_sym_xy_ops

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>

Note
  Only supported in AIE.

Similar to sliding_mul_sym_ops, but DataStepX is equal to DataStepY.

L = Lanes
P = Points
CS = CoeffStep
DS = DataStepXY
c_s = coeff_start
d_s = data_start
out[0] = coeff[c_s] * (data[d_s + ] + data[d_s + (P-1) * DS]) + coeff[c_s + CS] * (data[d_s + DS] + data[d_s + (P-2) * DS]) + ...
+ coeff[c_s + (P/2-1 * CS)] * (data[d_s + (P/2-1) * DS] + data[d_s + P/2 * DS]);
out[1] = coeff[c_s] * (data[d_s + DS] + data[d_s + P * DS]) + coeff[c_s + CS] * (data[d_s + 2 * DS] + data[d_s + (P-1) * DS]) + ...
+ coeff[c_s + (P/2-1 * CS)] * (data[d_s + P/2 * DS] + data[d_s + (P/2+1) * DS]);
...
out[L-1] = coeff[c_s] * (data[d_s + (L-1) * DS] + data[d_s + (P+L-2) * DS]) + coeff[c_s + CS] * (data[d_s + L * DS] + data[d_s + (P+L-3) * DS]) + ...
+ coeff[c_s + (P/2-1 * CS)] * (data[d_s + (P/2+L-2) * DS] + data[d_s + (P/2+L-1) * DS]);

Template Parameters

  Lanes | Number of output elements.
  Points | Number of data elements used to compute each lane.
  CoeffStep | Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
  DataStepXY | Step used to select elements from the data buffer. This step is applied to element selection within a lane and across lanes.
  CoeffType | Type of the coefficient elements.
  DataType | Type of the data elements.
  AccumTag | Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

See also
  sliding_mul_sym_ops

## ◆ sliding_mul_sym_y_ops

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>

Note
  Only supported in AIE.

Similar to sliding_mul_sym_ops, but DataStepX is always 1.

L = Lanes
P = Points
CS = CoeffStep
DSY = DataStepY
c_s = coeff_start
d_s = data_start
out[0] = coeff[c_s] * (data[d_s + ] + data[d_s + (P-1)]) + coeff[c_s + CS] * (data[d_s + 1] + data[d_s + (P-2)]) + ...
+ coeff[c_s + (P/2-1 * CS)] * (data[d_s + (P/2-1)] + data[d_s + P/2]);
out[1] = coeff[c_s] * (data[d_s + DSY] + data[d_s + DSY + (P-1)]) + coeff[c_s + CS] * (data[d_s + DSY + 1] + data[d_s + DSY + (P-2)]) + ...
+ coeff[c_s + (P/2-1 * CS)] * (data[d_s + DSY + (P/2-1)] + data[d_s + DSY + P/2]);
...
out[L-1] = coeff[c_s] * (data[d_s + (L-1) * DSY] + data[d_s + (L-1) * DSY + (P-1)]) + coeff[c_s + CS] * (data[d_s + (L-1) * DSY + 1] + data[d_s + (L-1) * DSY + (P-2)]) + ...
+ coeff[c_s + (P/2-1 * CS)] * (data[d_s + (L-1) * DSY + (P/2-1)] + data[d_s + (L-1) * DSY + P/2]);

Template Parameters

  Lanes | Number of output elements.
  Points | Number of data elements used to compute each lane.
  CoeffStep | Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
  DataStepY | Step used to select elements from the data buffer. This step is applied to element selection across lanes.
  CoeffType | Type of the coefficient elements.
  DataType | Type of the data elements.
  AccumTag | Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

See also
  sliding_mul_sym_ops

## ◆ sliding_mul_x_ops

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.

L = Lanes
P = Points
CS = CoeffStep
DSX = DataStepX
c_s = coeff_start
d_s = data_start
out[0] = coeff[c_s] * data[d_s + 0] + coeff[c_s + CS] * data[d_s + DSX] + ... + coeff[c_s + (P-1) * CS] * data[d_s + (P-1) * DSX]
out[1] = coeff[c_s] * data[d_s + 1] + coeff[c_s + CS] * data[d_s + 1 + DSX] + ... + coeff[c_s + (P-1) * CS] * data[d_s + 1 + (P-1) * DSX]
...
out[L-1] = coeff[c_s] * data[d_s + (L-1)] + coeff[c_s + CS] * data[d_s + (L-1) + DSX] + ... + coeff[c_s + (P-1) * CS] * data[d_s + (L-1) + (P-1) * DSX]

Template Parameters

  Lanes | Number of output elements.
  Points | Number of data elements used to compute each lane.
  CoeffStep | Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
  DataStepX | Step used to select elements from the data buffer. This step is applied to element selection within a lane.
  CoeffType | Type of the coefficient elements.
  DataType | Type of the data elements.
  AccumTag | Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

## ◆ sliding_mul_xy_ops

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.

L = Lanes
P = Points
CS = CoeffStep
DS = DataStepXY
c_s = coeff_start
d_s = data_start
out[0] = coeff[c_s] * data[d_s + ] + coeff[c_s + CS] * data[d_s + DS] + ... + coeff[c_s + (P-1) * CS] * data[d_s + (P-1) * DS]
out[1] = coeff[c_s] * data[d_s + DS] + coeff[c_s + CS] * data[d_s + 2 * DS] + ... + coeff[c_s + (P-1) * CS] * data[d_s + P * DS]
...
out[L-1] = coeff[c_s] * data[d_s + (L-1) * DS] + coeff[c_s + CS] * data[d_s + L * DS] + ... + coeff[c_s + (P-1) * CS] * data[d_s + (P+L-2) * DS]

Template Parameters

  Lanes | Number of output elements.
  Points | Number of data elements used to compute each lane.
  CoeffStep | Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
  DataStepXY | Step used to select elements from the data buffer. This step is applied to element selection within a lane and across lanes.
  CoeffType | Type of the coefficient elements.
  DataType | Type of the data elements.
  AccumTag | Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

## ◆ sliding_mul_y_ops

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.

L = Lanes
P = Points
CS = CoeffStep
DSY = DataStepY
c_s = coeff_start
d_s = data_start
out[0] = coeff[c_s] * data[d_s + ] + coeff[c_s + CS] * data[d_s + 1] + ... + coeff[c_s + (P-1) * CS] * data[d_s + (P-1)]
out[1] = coeff[c_s] * data[d_s + DSY] + coeff[c_s + CS] * data[d_s + DSY + 1] + ... + coeff[c_s + (P-1) * CS] * data[d_s + DSY + (P-1)]
...
out[L-1] = coeff[c_s] * data[d_s + (L-1) * DSY] + coeff[c_s + CS] * data[d_s + (L-1) * DSY + 1] + ... + coeff[c_s + (P-1) * CS] * data[d_s + (L-1) * DSY + (P-1)]

Template Parameters

  Lanes | Number of output elements.
  Points | Number of data elements used to compute each lane.
  CoeffStep | Step used to select elements from the coeff buffer. This step is applied to element selection within a lane.
  DataStepY | Step used to select elements from the data buffer. This step is applied to element selection accross lanes.
  CoeffType | Type of the coefficient elements.
  DataType | Type of the data elements.
  AccumTag | Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex).

## Function Documentation

## ◆ accumulate() [1/5]

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.

Given a finite number of vectors \( d_1, d_2, ..., d_C \) and a weight vector \( coef = ( \alpha_1, \alpha_2, ..., \alpha_n ) \) for \( n \geq (C + start) \) and an accumulator \( acc \), the result is an accumulator of the form \( out = acc + \sum_{i=1}^{C} \alpha_{i + start} * d_i \).

Each of the data vectors is scaled by its corresponding element of coeff vector.

The operation consists on a parametrized multiplication that implements the following compute pattern:

L = Lanes
C = sizeof...(next_data) + 1
c_s = coeff_start
out[0] = acc[0] + coeff[c_s] * data[0] + coeff[c_s + 1] * next_data_0[0] + ... + coeff[c_s + (C-1)] * next_data_C-2[0]
out[1] = acc[1] + coeff[c_s] * data[1] + coeff[c_s + 1] * next_data_0[1] + ... + coeff[c_s + (C-1)] * next_data_C-2[1]
...
out[L-1] = acc[L-1] + coeff[c_s] * data[L-1] + coeff[c_s + 1] * next_data_0[L-1] + ... + coeff[c_s + (C-1)] * next_data_C-2[L-1]

In the following example, accumulate multiplies data0 by 1, data1 by 2 and data2 by 3 respectively:

aie::accum<acc80, 8> acc;
aie::vector<int, 4> coeffs{1, 2, 3};
aie::vector<int, 8> data0{...}, data1{...}, data2{...};
std::array<aie::vector<int, 8>, 3> data{data0, data1, data2};
acc = aie::accumulate(acc, coeffs, 0, data);
aie::accum
Type for vector accumulators.
Definition accum.hpp:49
aie::vector
Type for vector registers.
Definition vector.hpp:75
aie::accumulate
auto accumulate(const Acc &acc, const VecCoeff &coeff, unsigned coeff_start, const VecData &data, const NextVecData &...next_data) -> operand_base_type_t< Acc >
Performs a weighted addition over multiple vectors and accumulates the result into an existing accumu...
Definition aie.hpp:6063

Template Parameters

  Lanes | Number of output elements.

Parameters

  acc | Accumulator to which the result of the accumulation is added (or subtracted). The type must meet aie::AccumOrOp.
  coeff | Vector of coefficients. Size is limited to 256b and 512b on AIE and AIE-ML/XDNA1 respectively.
  coeff_start | First element from the coeff vector to be used.
  data | Array of data vectors

## ◆ accumulate() [2/5]

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.

Given a finite number of vectors \( d_1, d_2, ..., d_C \) and a weight vector \( coef = ( \alpha_1, \alpha_2, ..., \alpha_n ) \) for \( n \geq (C + start) \) and an accumulator \( acc \), the result is an accumulator of the form \( out = acc + \sum_{i=1}^{C} \alpha_{i + start} * d_i \).

Each of the data vectors is scaled by its corresponding element of coeff vector.

The operation consists on a parametrized multiplication that implements the following compute pattern:

L = Lanes
C = sizeof...(next_data) + 1
c_s = coeff_start
out[0] = acc[0] + coeff[c_s] * data[0] + coeff[c_s + 1] * next_data_0[0] + ... + coeff[c_s + (C-1)] * next_data_C-2[0]
out[1] = acc[1] + coeff[c_s] * data[1] + coeff[c_s + 1] * next_data_0[1] + ... + coeff[c_s + (C-1)] * next_data_C-2[1]
...
out[L-1] = acc[L-1] + coeff[c_s] * data[L-1] + coeff[c_s + 1] * next_data_0[L-1] + ... + coeff[c_s + (C-1)] * next_data_C-2[L-1]

In the following example, accumulate multiplies data0 by 1, data1 by 2 and data2 by 3 respectively:

aie::accum<acc80, 8> acc;
aie::vector<int, 4> coeffs{1, 2, 3};
aie::vector<int, 8> data0{...}, data1{...}, data2{...};
acc = aie::accumulate(acc, coeffs, 0, data0, data1, data2);

Template Parameters

  Lanes | Number of output elements.

Parameters

  acc | Accumulator to which the result of the accumulation is added (or subtracted). The type must meet aie::AccumOrOp.
  coeff | Vector of coefficients. Size is limited to 256b and 512b on AIE and AIE-ML/XDNA1 respectively.
  coeff_start | First element from the coeff vector to be used.
  data | First vector of data.
  next_data | Remaining data vectors.

## ◆ accumulate() [3/5]

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 )

Deprecated
  This function is deprecated. Use accumulate(const VecCoeff & coeff, unsigned coeff_start, const VecData & data, const NextVecData &... next_data ) instead.

See also
  accumulate(const VecCoeff & coeff, unsigned coeff_start, const VecData & data, const NextVecData &... next_data )

## ◆ accumulate() [4/5]

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, typenameVecCoeff::value_type, typenameVecData::value_type >, Lanes >

Performs a weighted addition over multiple vectors.

Given a finite number of vectors \( d_1, d_2, ..., d_C \) and a weight vector \( coef = ( \alpha_1, \alpha_2, ..., \alpha_n ) \), for \( n \geq (C + start) \), the result is an accumulator of the form \( out = \sum_{i=1}^{C} \alpha_{i + start} * d_i \).

Each of the data vectors is scaled by its corresponding element of coeff vector.

This function provides a parametrized multiplication that implements the following compute pattern:

L = Lanes
C = sizeof...(next_data) + 1
c_s = coeff_start
out[0] = coeff[c_s] * data_0[0] + coeff[c_s + 1] * next_data_0[0] + ... + coeff[c_s + (C-1)] * next_data_C-2[0]
out[1] = coeff[c_s] * data_0[1] + coeff[c_s + 1] * next_data_0[1] + ... + coeff[c_s + (C-1)] * next_data_C-2[1]
...
out[L-1] = coeff[c_s] * data_0[L-1] + coeff[c_s + 1] * next_data_0[L-1] + ... + coeff[c_s + (C-1)] * next_data_C-2[L-1]

Template Parameters

  Lanes | Number of output elements.
  AccumTag | Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex). Refer to default accumulator tag table for the minimum accumulator element tag required for each combination of input element types.

Parameters

  coeff | Vector of coefficients. Vectors limited to 256b and 512b on AIE and AIE-ML/XDNA1 respectively.
  coeff_start | First element from the coeff vector to be used.
  data | Array of data vectors

## ◆ accumulate() [5/5]

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, typenameVecCoeff::value_type, typenameVecData::value_type >, Lanes >

Performs a weighted addition over multiple vectors.

Given a finite number of vectors \( d_1, d_2, ..., d_C \) and a weight vector \( coef = ( \alpha_1, \alpha_2, ..., \alpha_n ) \), for \( n \geq (C + start) \), the result is an accumulator of the form \( out = \sum_{i=1}^{C} \alpha_{i + start} * d_i \).

Each of the data vectors is scaled by its corresponding element of coeff vector.

This function provides a parametrized multiplication that implements the following compute pattern:

L = Lanes
C = sizeof...(next_data) + 1
c_s = coeff_start
out[0] = coeff[c_s] * data_0[0] + coeff[c_s + 1] * next_data_0[0] + ... + coeff[c_s + (C-1)] * next_data_C-2[0]
out[1] = coeff[c_s] * data_0[1] + coeff[c_s + 1] * next_data_0[1] + ... + coeff[c_s + (C-1)] * next_data_C-2[1]
...
out[L-1] = coeff[c_s] * data_0[L-1] + coeff[c_s + 1] * next_data_0[L-1] + ... + coeff[c_s + (C-1)] * next_data_C-2[L-1]

Template Parameters

  Lanes | Number of output elements.
  AccumTag | Accumulator tag that specifies the required accumulation bits. The class must be compatible with the result of the multiplication of the coefficient and data types (real/complex). Refer to default accumulator tag table for the minimum accumulator element tag required for each combination of input element types.

Parameters

  coeff | Vector of coefficients. Vectors limited to 256b and 512b on AIE and AIE-ML/XDNA1 respectively.
  coeff_start | First element from the coeff vector to be used.
  data | First vector of data.
  next_data | Rest of the data vectors.