The AI Engine API supports basic arithmetic operations on two vectors, or on a scalar and a vector (operation on the scalar and each element of the vector). It also supports addition or subtraction of a scalar or a vector on an accumulator. Additionally, it supports multiply-accumulate (MAC). These operations include:
-
aie::mul
- Returns an accumulator with the element-wise multiplication of two vectors, or the product of a vector and a scalar value.
-
aie::negmul
- Returns an accumulator with the negative of the element-wise multiplication of two vectors, or the negative of the product of a vector and a scalar value.
-
aie::mac
- Multiply-add on vectors (or scalar) and accumulator.
-
aie::msc
- Multiply-sub on vectors (or scalar) and accumulator.
-
aie::add
- Returns a vector with the element-wise addition of two vectors, or add a scalar value to each component of a vector. Or add scalar or vector on accumulator.
-
aie::sub
- Returns a vector with the element-wise subtraction of two vectors, or subtract a scalar value from each component of a vector. Or subtract scalar or vector on accumulator.
The vectors and accumulator must have the same size and their types must be compatible. For example:
aie::vector<int32,8> va,vb;;
auto vm=aie::mul(va,vb);
auto vm2=aie::mul((int32)10,vb);
aie::vector<int32,8> vsub=aie::sub(va,vb);
aie::vector<int32,8> vadd=aie::add(va,vb);
aie::vector<int32,8> vsub2=aie::sub(va,10);//scalar and vector can switch placement
aie::vector<int32,8> vadd2=aie::add(10,va);//scalar and vector can switch placement
auto vsub_acc=aie::sub(vm,10);
auto vsub_acc2=aie::sub(vm,va);
auto vadd_acc=aie::add(vm,10);
auto vadd_acc2=aie::add(vm,vb);
auto vmac=aie::mac(vm,va,vb);
auto vmsc=aie::msc(vm,va,vb);
auto vmac2=aie::mac(vm,va,10);//scalar and vector can switch placement
auto vmsc2=aie::msc(vm,10,vb);//scalar and vector can switch placement
AI Engine API supports arithmetic operations on a vector or accumulation of element-wise square, including:
-
aie::abs
- Computes the absolute value for each element in the given vector.
-
aie::abs_square
- Computes the absolute square of each element in the given complex vector.
-
aie::conj
- Computes the conjugate for each element in the given vector of complex elements.
-
aie::neg
- For vectors with signed types, returns a vector whose elements are the same as in the given vector but with the sign flipped. If the input type is unsigned, the input vector is returned.
-
aie::mul_square
- Returns an accumulator of the requested type with the element-wise square of the input vector.
-
aie::mac_square
- Returns an accumulator with the addition of the given accumulator and the element-wise square of the input vector.
-
aie::msc_square
- Returns an accumulator with the subtraction of the given accumulator and the element-wise square of the input vector.
The vector and the accumulator must have the same size and their types must be compatible. For example:
aie::vector<int16,16> va;
aie::vector<cint16,16> ca;
aie::vector<int16,16> va_abs=aie::abs(va);
aie::vector<int32,16> ca_abs=aie::abs_square(ca);
aie::vector<cint16,16> ca_conj=aie::conj(ca);
aie::vector<int16,16> va_neg=aie::neg(va);
auto va_sq=aie::mul_square(va);
aie::vector<int32,8> vc,vd;
auto vm=aie::mul(vc,vd);
auto vmac3=aie::mac_square(vm,vc);//vmac3[i]=vm[i]+vc[i]*vc[i];
auto vmsc3=aie::msc_square(vm,vd);//vmsc3[i]=vm[i]-vd[i]*vd[i];
Operands can also be supported pre-multiplication operations. On some AI Engine architectures certain operations can be collapsed with the multiplication into a single instruction. For example:
aie::vector<cint16,16> ca,cb;
auto acc=aie::mul(aie::op_conj(ca),aie::op_conj(cb));
For details about pre-multiplication operations, see Pre-Multiplication Operations.