Arithmetic

Overview

AIE API provides a set of functions that implement arithmetic operations on vector types. Operands may be vectors, values or vector element references and the supported operand combinations are:

• Vector / Vector: the type and the size of the vectors must match. The operation is performed element-wise between the corresponding elements in each vector.
• Value / Vector: the type of the value and the type of the elements of the vector must match. The operation has the same result as if the value was broadcast to a vector and then operated with the vector argument.
• Vector element reference / Vector. Similar as Value / Vector, but using an element reference, the AIE API may optimize the operation by accessing the element directly from its original location.

The following code snippet shows an example that adds two input arrays into an output array using vectors. For simplicity count must be divisible by 8.

      void
      add(
      int32* __restrict out,
     

      const
      int32* __restrict in1,
      const
      int32* __restrict in2,
      unsignedcount)
     

      {
     

      for(
      unsignedi = 8; i < count; i += 8) {
     

      aie::vectorvec =
      aie::add(aie::load_v<8>(in1 + i),
     

      aie::load_v<8>(in2 + i));
     


      aie::store_v(out, vec);
     

      }
     

      }
     

Operations that include a multiplication return an accumulator. The API defines a default accumulation for each combination of types, but users may specify a larger number of accumulation bits by explicitly passing an accumulator tag.

      // Default accumulation will be used
     

      autoacc =
      aie::mul(v1, v2);
     


      // 64b accumulation, at least, will be used
     

      autoacc = aie::mul(v1, v2);
     


      // For multiply-add operations, the API uses the same accumulation as the given accumulator (cannot be overriden)
     

      autoacc2 =
      aie::mac(acc, v1, v2);
     

Functions
template<ElemE>
constexpr auto	aie::abs(const E &a) ->operand_base_type_t< E >
	More...
template<VectorVec>
constexpr auto	aie::abs(const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
templateComplexVectorVec>
constexpr auto	aie::abs_square(const Vec &v, int shift=0)
	More...
template
constexprvector< float, Elems >	aie::abs_square(constvector< cfloat, Elems > &v)
	More...
template<AccumAcc,VectorVec>
Acc	aie::add(const Acc &acc, const Vec &v)
	More...
template<AccumAcc,ElemE>
Acc	aie::add(const Acc &acc, E a)
	More...
template<VectorVec,ElemE>
auto	aie::add(const Vec &v, E a) ->aie_dm_resource_remove_t< Vec >
	More...
template<VectorVec1,VectorVec2>
auto	aie::add(const Vec1 &v1, const Vec2 &v2) ->aie_dm_resource_remove_t< Vec1 >
	More...
template<ElemE,VectorVec>
auto	aie::add(E a, const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
template<ElemE,VectorVec>
auto	aie::bit_and(E a, const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
template<ElemE,VectorVec>
auto	aie::bit_or(E a, const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
template<ElemE,VectorVec>
auto	aie::bit_xor(E a, const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
template<ComplexElemE>
constexpr auto	aie::conj(const E &a) ->operand_base_type_t< E >
	More...
template<ComplexVectorVec>
auto	aie::conj(const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
template<AccumOrOpAcc,VectorOrOpVec,ElemOrOpE>
constexpr auto	aie::mac(const Acc &acc, const Vec &v, E a) ->operand_base_type_t< Acc >
	More...
template<AccumOrOpAcc,VectorOrOpVec1,VectorOrOpVec2>
constexpr auto	aie::mac(const Acc &acc, const Vec1 &v1, const Vec2 &v2) ->operand_base_type_t< Acc >
	More...
template<AccumOrOpAcc,ElemOrOpE,VectorOrOpVec>
constexpr auto	aie::mac(const Acc &acc, E a, const Vec &v) ->operand_base_type_t< Acc >
	More...
template<AccumOrOpAcc,VectorVec>
constexpr auto	aie::mac_square(const Acc &acc, const Vec &v)
	More...
template<AccumAcc,VectorOrOpVec,ElemOrOpE>
constexpr auto	aie::msc(const Acc &acc, const Vec &v, E a) ->aie_dm_resource_remove_t< Acc >
	More...
template<AccumAcc,VectorOrOpVec1,VectorOrOpVec2>
constexpr auto	aie::msc(const Acc &acc, const Vec1 &v1, const Vec2 &v2) ->aie_dm_resource_remove_t< Acc >
	More...
template<AccumAcc,ElemOrOpE,VectorOrOpVec>
constexpr auto	aie::msc(const Acc &acc, E a, const Vec &v) ->aie_dm_resource_remove_t< Acc >
	More...
template<AccumAcc,VectorVec>
constexpr auto	aie::msc_square(const Acc &acc, const Vec &v)
	More...
template<VectorOrOpVec,ElemOrOpE>
constexpr auto	aie::mul(const Vec &v, E a)
	More...
template<AccumElemBaseTypeAccumTag,VectorOrOpVec,ElemOrOpE>
constexpr auto	aie::mul(const Vec &v, E a) ->accum< AccumTag, Vec::size()>
	More...
template<VectorOrOpVec1,VectorOrOpVec2>
constexpr auto	aie::mul(const Vec1 &v1, const Vec2 &v2)
	More...
template<AccumElemBaseTypeAccumTag,VectorOrOpVec1,VectorOrOpVec2>
constexpr auto	aie::mul(const Vec1 &v1, const Vec2 &v2) ->accum< AccumTag, Vec1::size()>
	More...
template<ElemOrOpE,VectorOrOpVec>
constexpr auto	aie::mul(E a, const Vec &v)
	More...
template<AccumElemBaseTypeAccumTag,ElemOrOpE,VectorOrOpVec>
constexpr auto	aie::mul(E a, const Vec &v) ->accum< AccumTag, Vec::size()>
	More...
template<VectorVec>
constexpr auto	aie::mul_square(const Vec &v)
	More...
template<AccumElemBaseTypeAccumTag,VectorVec>
constexpr auto	aie::mul_square(const Vec &v) ->accum< AccumTag, Vec::size()>
	More...
template<ElemE>
constexpr auto	aie::neg(const E &a) ->operand_base_type_t< E >
	More...
template<VectorVec>
constexpr auto	aie::neg(const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...
template<VectorOrOpVec,ElemOrOpE>
constexpr auto	aie::negmul(const Vec &v, E a)
	More...
template<AccumElemBaseTypeAccumTag,VectorOrOpVec,ElemOrOpE>
constexpr auto	aie::negmul(const Vec &v, E a) ->accum< AccumTag, Vec::size()>
	More...
template<VectorOrOpVec1,VectorOrOpVec2>
constexpr auto	aie::negmul(const Vec1 &v1, const Vec2 &v2)
	More...
template<AccumElemBaseTypeAccumTag,VectorOrOpVec1,VectorOrOpVec2>
constexpr auto	aie::negmul(const Vec1 &v1, const Vec2 &v2) ->accum< AccumTag, Vec1::size()>
	More...
template<ElemOrOpE,VectorOrOpVec>
constexpr auto	aie::negmul(E a, const Vec &v)
	More...
template<AccumElemBaseTypeAccumTag,ElemOrOpE,VectorOrOpVec>
constexpr auto	aie::negmul(E a, const Vec &v) ->accum< AccumTag, Vec::size()>
	More...
template<VectorVec, Vector... Others>
auto	aie::reduce_add_v(const Vec &v, const Others &... others) ->aie_dm_resource_remove_t< Vec >
	More...
template<AccumAcc,VectorVec>
constexpr auto	aie::sub(const Acc &acc, const Vec &v) ->aie_dm_resource_remove_t< Acc >
	More...
template<AccumAcc,ElemE>
auto	aie::sub(const Acc &acc, E a) ->aie_dm_resource_remove_t< Acc >
	More...
template<VectorVec,ElemE>
auto	aie::sub(const Vec &v, E a) ->aie_dm_resource_remove_t< Vec >
	More...
template<VectorVec1,VectorVec2>
auto	aie::sub(const Vec1 &v1, const Vec2 &v2) ->aie_dm_resource_remove_t< Vec1 >
	More...
template<ElemE,VectorVec>
auto	aie::sub(E a, const Vec &v) ->aie_dm_resource_remove_t< Vec >
	More...

Function Documentation

abs()[1/2]

template< ElemE>

constexpr auto aie::abs ( const E & a ) ->operand_base_type_t

constexpr

Compute the absolute value of a value.

Parameters

a	Input value

abs()[2/2]

template< VectorVec>

constexpr auto aie::abs ( const Vec & v ) ->aie_dm_resource_remove_t

constexpr

Compute the absolute value for each element in the given vector.

Parameters

v	Input vector

abs_square()[1/2]

templateComplexVectorVec>

constexpr auto aie::abs_square ( const Vec & v, int shift=0 )

constexpr

Compute the absolute square of each element in the given complex vector.

For a vector of N complex elements, returns a vector of N integers

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = v[i].real² + v[i].imag²;
       

Parameters

v	Input complex vector
shift	Optional parameter to control the shift value used in the srs internally

Template Parameters

TR	Type of returned integer vector, default to int32 but can be set to int16

abs_square()[2/2]

template

constexprvector aie::abs_square ( constvector< cfloat, Elems > & v )

constexpr

Compute the absolute square of each element in the given complex vector.

For a vector of N complex elements, returns a vector of N integers

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = v[i].real² + v[i].imag²;
       

Parameters

v	Input complex vector

add()[1/5]

template< AccumAcc, VectorVec>

Acc aie::add	(	const Acc &	acc,
		const Vec &	v
	)

Returns an accumulator with the element-wise addition of the input accumulator and vector.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = acc[i] + v[i];
       

Parameters

acc	Input accumulator
v	Input vector

add()[2/5]

template< AccumAcc, ElemE>

Acc aie::add	(	const Acc &	acc,
		E	a
	)

Returns an accumulator with the addition of a value to all the elements of the input vector.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = acc[i] + a;
       

Parameters

acc	Input accumulator
a	Value. The type must meetElem.

add()[3/5]

template< VectorVec, ElemE>

auto aie::add	(	const Vec &	v,
		E	a
	)		->aie_dm_resource_remove_t

Returns a vector with the addition of a value to all the elements of the input vector. The type of the value and the type of the vector elements must be the same.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = v[i] + a;
       

Parameters

v	Input vector. The type must meetVector.
a	Value. The type must meetElem.

add()[4/5]

template< VectorVec1, VectorVec2>

auto aie::add	(	const Vec1 &	v1,
		const Vec2 &	v2
	)		->aie_dm_resource_remove_t

Returns a vector with the element-wise addition of the two input vectors. The vectors must have the same type and size.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = v1[i] + v2[i];
       

Parameters

v1	First input vector. The type must meetVector.
v2	Second input vector. The type must meetVector.

add()[5/5]

template< ElemE, VectorVec>

auto aie::add	(	E	a,
		const Vec &	v
	)		->aie_dm_resource_remove_t

Returns a vector with the addition of a value to all the elements of the input vector. The type of the value and the type of the vector elements must be the same.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = a + v[i];
       

Parameters

a	Value. The type must meetElem.
v	Input vector. The type must meetVector.

bit_and()

template< ElemE, VectorVec>

auto aie::bit_and	(	E	a,
		const Vec &	v
	)		->aie_dm_resource_remove_t

Returns a vector with the bit-wise AND of a value and all the elements of the input vector. The type of the value and the type of the vector elements must be the same.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = a & v[i];
       

Parameters

a	Value. The type must meetElem.
v	Input vector. The type must meetVector.

bit_or()

template< ElemE, VectorVec>

auto aie::bit_or	(	E	a,
		const Vec &	v
	)		->aie_dm_resource_remove_t

Returns a vector with the bit-wise OR of a value and all the elements of the input vector. The type of the value and the type of the vector elements must be the same.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = a | v[i];
       

Parameters

a	Value. The type must meetElem.
v	Input vector. The type must meetVector.

bit_xor()

template< ElemE, VectorVec>

auto aie::bit_xor	(	E	a,
		const Vec &	v
	)		->aie_dm_resource_remove_t

Returns a vector with the bit-wise XOR of a value and all the elements of the input vector. The type of the value and the type of the vector elements must be the same.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = a ^ v[i];
       

Parameters

a	Value. The type must meetElem.
v	Input vector. The type must meetVector.

conj()[1/2]

template< ComplexElemE>

constexpr auto aie::conj ( const E & a ) ->operand_base_type_t

constexpr

Compute the conjugate in the given complex value.

Parameters

a	Input value

conj()[2/2]

template< ComplexVectorVec>

auto aie::conj

(

const Vec &

v

)

->aie_dm_resource_remove_t

Compute the conjugate for each element in the given vector of complex elements.

Parameters

v	Input vector

mac()[1/3]

template< AccumOrOpAcc, VectorOrOpVec, ElemOrOpE>

constexpr auto aie::mac ( const Acc & acc, const Vec & v, E a ) ->operand_base_type_t

constexpr

Returns an accumulator with the element-wise multiply-add of input vector, value and accumulator. The vector and the accumulator must have the same size and the types of all operands must be compatible. Operands can also be lazy operations (seeLazy Operations). On some AIE architectures certain operations can be collapsed with the multiplication into a single instruction.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = acc[i] + op1(v[i]) * op2(a);
       

Parameters

acc	Accumulator to which the result of the multiplication is added (or subtracted). The type must meetAccumOrOp.
v	Input vector. The type must meetVectorOrOp.
a	Input value. The type must meetElemOrOp.

mac()[2/3]

template< AccumOrOpAcc, VectorOrOpVec1, VectorOrOpVec2>

constexpr auto aie::mac ( const Acc & acc, const Vec1 & v1, const Vec2 & v2 ) ->operand_base_type_t

constexpr

Returns an accumulator with the element-wise multiply-add of the two input vectors and accumulator. The vectors and the accumulator must have the same size and their types must be compatible. Operands can also be lazy operations (seeLazy Operations). On some AIE architectures certain operations can be collapsed with the multiplication into a single instruction.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = acc[i] + op1(v1[i]) * op2(v2[i]);
       

Parameters

acc	Accumulator to which the result of the multiplication is added (or subtracted). The type must meetAccumOrOp.
v1	First input vector. The type must meetVectorOrOp.
v2	Second input vector. The type must meetVectorOrOp.

mac()[3/3]

template< AccumOrOpAcc, ElemOrOpE, VectorOrOpVec>

constexpr auto aie::mac ( const Acc & acc, E a, const Vec & v ) ->operand_base_type_t

constexpr

Returns an accumulator with the element-wise multiply-add of value, input vector and accumulator. The vector and the accumulator must have the same size and the types of all operands must be compatible. Operands can also be lazy operations (seeLazy Operations). On some AIE architectures certain operations can be collapsed with the multiplication into a single instruction.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = acc[i] + op1(a) * op2(v[i]);
       

Parameters

acc	Accumulator to which the result of the multiplication is added (or subtracted). The type must meetAccumOrOp.
a	Input value. The type must meetElemOrOp.
v	Input vector. The type must meetVectorOrOp.

mac_square()

template< AccumOrOpAcc, VectorVec>

constexpr auto aie::mac_square ( const Acc & acc, const Vec & v )

constexpr

Returns an accumulator with the addition or 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(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = acc[i] + v[i] * v[i];
       

Parameters

acc	Input accumulator. The type must meetAccumOrOp.
v	Input vector. The type must meetVector.

msc()[1/3]

template< AccumAcc, VectorOrOpVec, ElemOrOpE>

constexpr auto aie::msc ( const Acc & acc, const Vec & v, E a ) ->aie_dm_resource_remove_t

constexpr

Returns an accumulator with the element-wise multiply-add of input vector, value and accumulator. The vector and the accumulator must have the same size and their types must be compatible. Operands can also be lazy operations (seeLazy Operations). On some AIE architectures certain operations can be collapsed with the multiplication into a single instruction.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = acc[i] - op1(v[i]) * op2(a);
       

Parameters

acc	Accumulator from which the result of the multiplication is subtracted. The type must meetAccum.
v	Input vector. The type must meetVectorOrOp.
a	Input value. The type must meetElemOrOp.

msc()[2/3]

template< AccumAcc, VectorOrOpVec1, VectorOrOpVec2>

constexpr auto aie::msc ( const Acc & acc, const Vec1 & v1, const Vec2 & v2 ) ->aie_dm_resource_remove_t

constexpr

Returns an accumulator with the element-wise multiply-add of the two input vectors and accumulator. The vectors and the accumulator must have the same size and the types of all operands must be compatible. Operands can also be lazy operations (seeLazy Operations). On some AIE architectures certain operations can be collapsed with the multiplication into a single instruction.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = acc[i] - op1(v1[i]) * op2(v2[i]);
       

Parameters

acc	Accumulator from which the result of the multiplication is subtracted. The type must meetAccum.
v1	First input vector. The type must meetVectorOrOp.
v2	Second input vector. The type must meetVectorOrOp.

msc()[3/3]

template< AccumAcc, ElemOrOpE, VectorOrOpVec>

constexpr auto aie::msc ( const Acc & acc, E a, const Vec & v ) ->aie_dm_resource_remove_t

constexpr

Returns an accumulator with the element-wise multiply-add of value, input vector and accumulator. The vector and the accumulator must have the same size and their types must be compatible. Operands can also be lazy operations (seeLazy Operations). On some AIE architectures certain operations can be collapsed with the multiplication into a single instruction.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = acc[i] - op1(a) * op2(v[i]);
       

Parameters

acc	Accumulator from which the result of the multiplication is subtracted. The type must meetAccum.
a	Input value. The type must meetElemOrOp.
v	Input vector. The type must meetVectorOrOp.

msc_square()

template< AccumAcc, VectorVec>

constexpr auto aie::msc_square ( const Acc & acc, const Vec & v )

constexpr

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(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = acc[i] - v[i] * v[i];
       

Parameters

acc	Input accumulator. The type must meetAccum.
v	Input vector. The type must meetVector.

mul()[1/6]

template< VectorOrOpVec, ElemOrOpE>

constexpr auto aie::mul ( const Vec & v, E a )

constexpr

Returns an accumulator with the element-wise multiplication of a value and all the elements of a vector. The default accumulator accuracy is used of the input vector. The type of the value and the type of the vector elements must be compatible. Operands can also be lazy operations (seeLazy Operations). On some AIE architectures certain operations can be collapsed with the multiplication into a single instruction.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = op1(v[i]) * op2(a);
       

Parameters

a	Value. The type must meetElemOrOp.
v	Input vector. The type must meetVectorOrOp.

mul()[2/6]

template< AccumElemBaseTypeAccumTag, VectorOrOpVec, ElemOrOpE>

constexpr auto aie::mul ( const Vec & v, E a ) ->accum

constexpr

Returns an accumulator of the requested type with the element-wise multiplication of a value and all the elements of the input vector. The type of the value and the type of the vector elements must be compatible. Operands can also be lazy operations (seeLazy Operations). On some AIE architectures certain operations can be collapsed with the multiplication into a single instruction.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = op1(v[i]) * op2(a);
       

Template Parameters

AccumTag

Accumulator tag that specifies the required accumulation bits. The class must be compatible with the vector types (real/complex).

Parameters

v	Input vector. The type must meetVectorOrOp.
a	Value. The type must meetElemOrOp.

mul()[3/6]

template< VectorOrOpVec1, VectorOrOpVec2>

constexpr auto aie::mul ( const Vec1 & v1, const Vec2 & v2 )

constexpr

Returns an accumulator with the element-wise multiplication of the two input vectors. The default accumulator accuracy is used. The vectors must have the same size and compatible types. Operands can also be lazy operations (seeLazy Operations). On some AIE architectures certain operations can be collapsed with the multiplication into a single instruction.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = op1(v1[i]) * op2(v2[i]);
       

Parameters

v1	First input vector. The type must meetVectorOrOp.
v2	Second input vector. The type must meetVectorOrOp.

mul()[4/6]

template< AccumElemBaseTypeAccumTag, VectorOrOpVec1, VectorOrOpVec2>

constexpr auto aie::mul ( const Vec1 & v1, const Vec2 & v2 ) ->accum

constexpr

Returns an accumulator of the requested type with the element-wise multiplication of the two input vectors. The vectors must have the same size and compatible types. Vectors can also be lazy operations (seeLazy Operations). On some AIE architectures certain operations can be collapsed with the multiplication into a single instruction.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = op1(v1[i]) * op2(v2[i]);
       

Template Parameters

AccumTag

Accumulator tag that specifies the required accumulation bits. The class must be compatible with the vector types (real/complex).

Parameters

v1	First input vector. The type must meetVectorOrOp.
v2	Second input vector. The type must meetVectorOrOp.

mul()[5/6]

template< ElemOrOpE, VectorOrOpVec>

constexpr auto aie::mul ( E a, const Vec & v )

constexpr

Returns an accumulator with the element-wise multiplication of a value and all the elements of a vector. The default accumulator accuracy is used of the input vector. The type of the value and the type of the vector elements must be compatible. Operands can also be lazy operations (seeLazy Operations). On some AIE architectures certain operations can be collapsed with the multiplication into a single instruction.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = op1(a) * op2(v[i]);
       

Parameters

a	Value. The type must meetElemOrOp.
v	Input vector. The type must meetVectorOrOp.

mul()[6/6]

template< AccumElemBaseTypeAccumTag, ElemOrOpE, VectorOrOpVec>

constexpr auto aie::mul ( E a, const Vec & v ) ->accum

constexpr

Returns an accumulator of the requested type with the element-wise multiplication of a value and all the elements of the input vector. The type of the value and the type of the vector elements must be compatible. Operands can also be lazy operations (seeLazy Operations). On some AIE architectures certain operations can be collapsed with the multiplication into a single instruction.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = op1(a) * op2(v[i]);
       

Template Parameters

AccumTag

Accumulator tag that specifies the required accumulation bits. The class must be compatible with the vector types (real/complex).

Parameters

a	Value. The type must meetElemOrOp.
v	Input vector. The type must meetVectorOrOp.

mul_square()[1/2]

template< VectorVec>

constexpr auto aie::mul_square ( const Vec & v )

constexpr

Returns an accumulator with the element-wise square of the input vector. The default accumulator accuracy is used.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = v[i] * v[i];
       

Parameters

v	Input vector. The type must meetVector.

mul_square()[2/2]

template< AccumElemBaseTypeAccumTag, VectorVec>

constexpr auto aie::mul_square ( const Vec & v ) ->accum

constexpr

Returns an accumulator of the requested type with the element-wise square of the input vector.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = v[i] * v[i];
       

Template Parameters

AccumTag

Accumulator tag that specifies the required accumulation bits. The class must be compatible with the vector types (real/complex).

Parameters

v	Input vector. The type must meetVector.

neg()[1/2]

template< ElemE>

constexpr auto aie::neg ( const E & a ) ->operand_base_type_t

constexpr

For values with signed types, return the input value with the sign flipped. If the input type is unsigned, the input value is returned.

Parameters

a	Input value

neg()[2/2]

template< VectorVec>

constexpr auto aie::neg ( const Vec & v ) ->aie_dm_resource_remove_t

constexpr

For vectors with signed types, return 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.

Parameters

v	Input vector

negmul()[1/6]

template< VectorOrOpVec, ElemOrOpE>

constexpr auto aie::negmul ( const Vec & v, E a )

constexpr

Returns an accumulator with the negate of the element-wise multiplication of all the elements of the input vector and a value. The default accumulator accuracy is used. The vectors must have the same size and compatible types. Operands can also be lazy operations (seeLazy Operations). On some AIE architectures certain operations can be collapsed with the multiplication into a single instruction.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = -(op1(v[i]) * op2(a)));
       

Parameters

v	Input vector. The type must meetVectorOrOp.
a	Value. The type must meetElemOrOp.

negmul()[2/6]

template< AccumElemBaseTypeAccumTag, VectorOrOpVec, ElemOrOpE>

constexpr auto aie::negmul ( const Vec & v, E a ) ->accum

constexpr

Returns an accumulator of the requested type with the negate of the element-wise multiplication of all the elements of the input vector and a value. The type of the value and the type of the vector elements must be compatible. The input arguments can also be lazy operations (seeLazy Operations). On some AIE architectures certain operations can be collapsed with the multiplication into a single instruction.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = -(op1(v[i]) * op2(a));
       

Template Parameters

AccumTag

Accumulator tag that specifies the required accumulation bits. The class must be compatible with the vector types (real/complex).

Parameters

v	Input vector. The type must meetVectorOrOp.
a	Value. The type must meetElemOrOp.

negmul()[3/6]

template< VectorOrOpVec1, VectorOrOpVec2>

constexpr auto aie::negmul ( const Vec1 & v1, const Vec2 & v2 )

constexpr

Returns an accumulator with the negate of the element-wise multiplication of the two input vectors. The default accumulator accuracy is used. The vectors must have the same size and compatible types. Operands can also be lazy operations (seeLazy Operations). On some AIE architectures certain operations can be collapsed with the multiplication into a single instruction.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = -(op1(v1[i]) * op2(v2[i]));
       

Parameters

v1	First input vector. The type must meetVectorOrOp.
v2	Second input vector. The type must meetVectorOrOp.

negmul()[4/6]

template< AccumElemBaseTypeAccumTag, VectorOrOpVec1, VectorOrOpVec2>

constexpr auto aie::negmul ( const Vec1 & v1, const Vec2 & v2 ) ->accum

constexpr

Returns an accumulator of the requested type with the negate of the element-wise multiplication of the two input vectors. The vectors must have the same size and compatible types. Vectors can also be lazy operations (seeLazy Operations). On some AIE architectures certain operations can be collapsed with the multiplication into a single instruction.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = -(op1(v1[i]) * op1(v2[i]));
       

Template Parameters

AccumTag

Accumulator tag that specifies the required accumulation bits. The class must be compatible with the vector types (real/complex).

Parameters

v1	First input vector. The type must meetVectorOrOp.
v2	Second input vector. The type must meetVectorOrOp.

negmul()[5/6]

template< ElemOrOpE, VectorOrOpVec>

constexpr auto aie::negmul ( E a, const Vec & v )

constexpr

Returns an accumulator with the negate of the element-wise multiplication of a value and all the elements of the input vector. The default accumulator accuracy is used. The vectors must have the same size and compatible types. Operands can also be lazy operations (seeLazy Operations). On some AIE architectures certain operations can be collapsed with the multiplication into a single instruction.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = -(op1(a) * op2(v[i]));
       

Parameters

a	Value. The type must meetElemOrOp.
v	Input vector. The type must meetVectorOrOp.

negmul()[6/6]

template< AccumElemBaseTypeAccumTag, ElemOrOpE, VectorOrOpVec>

constexpr auto aie::negmul ( E a, const Vec & v ) ->accum

constexpr

Returns an accumulator of the requested type with the negate of the element-wise multiplication of a value and all the elements of the input vector. The type of the value and the type of the vector elements must be compatible. The input arguments can also be lazy operations (seeLazy Operations). On some AIE architectures certain operations can be collapsed with the multiplication into a single instruction.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = -(op1(a) * op2(v[i]));
       

Template Parameters

AccumTag

Accumulator tag that specifies the required accumulation bits. The class must be compatible with the vector types (real/complex).

Parameters

a	Value. The type must meetElemOrOp.
v	Input vector. The type must meetVectorOrOp.

reduce_add_v()

template< VectorVec, Vector... Others>

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

Returns the sums of the elements in the input vectors. The sum of each input vector is stored in an element of the output vector.

Parameters

v	First input vector. The type must meetVector.
others	Remaining input vectors. The type must meetVector.

sub()[1/5]

template< AccumAcc, VectorVec>

constexpr auto aie::sub ( const Acc & acc, const Vec & v ) ->aie_dm_resource_remove_t

constexpr

Returns an accumulator with the element-wise subtraction of the input accumulator and vector.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = acc[i] - v[i];
       

Parameters

acc	Input accumulator (minuend)
v	Input vector (subtrahend)

sub()[2/5]

template< AccumAcc, ElemE>

auto aie::sub	(	const Acc &	acc,
		E	a
	)		->aie_dm_resource_remove_t

Returns an accumulator with the subtraction of all the elements of the input accumulator and a value.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = acc[i] - a;
       

Parameters

acc	Input accumulator (minuend)
a	Value (subtrahend). The type must meetElem.

sub()[3/5]

template< VectorVec, ElemE>

auto aie::sub	(	const Vec &	v,
		E	a
	)		->aie_dm_resource_remove_t

Returns a vector with the subtraction of the elements of the input vector and a value. The type of the value and the type of the vector elements must be the same.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = v[i] - a;
       

Parameters

v	Input vector (minuend)
a	Value (subtrahend)

sub()[4/5]

template< VectorVec1, VectorVec2>

auto aie::sub	(	const Vec1 &	v1,
		const Vec2 &	v2
	)		->aie_dm_resource_remove_t

Returns a vector with the element-wise subtraction of the two input vectors. The vectors must have the same type and size.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = v1[i] - v2[i];
       

Parameters

v1	First input vector (minuend). The type must meetVector.
v2	Second input vector (subtrahend). The type must meetVector.

sub()[5/5]

template< ElemE, VectorVec>

auto aie::sub	(	E	a,
		const Vec &	v
	)		->aie_dm_resource_remove_t

Returns a vector with the subtraction of a value and all the elements of the input vector. The type of the value and the type of the vector elements must be the same.

        for(
        unsignedi = 0; i < Elems; ++i)
       

        out[i] = a - v[i];
       

Parameters

a	Value (minuend). The type must meetElem.
v	Input vector (subtrahend). The type must meetVector.