Comparison

Vector comparison operations. More...

Overview

Vector comparison operations.

Functions
template<Vector Vec, Elem E> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	aie::eq (const Vec &v, E a)
	Compares a value with the elements of the input vector and returns a mask that says what elements in the vector are equal to the value.
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
mask< Vec1::size()>	aie::eq (const Vec1 &v1, const Vec2 &v2)
	Compares the elements of the two input vectors and returns a mask that says what elements are equal.
template<Elem E, Vector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	aie::eq (E a, const Vec &v)
	Compares a value with the elements of the input vector and returns a mask that says what elements in the vector are equal to the value.
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
constexpr bool	aie::equal (const Vec1 &v1, const Vec2 &v2)
	Return whether all the elements of the two input vectors are equal.
template<RealVector Vec, RealElem E> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	aie::ge (const Vec &v, E a)
	Compares the elements of the input vector with a value and returns a mask that says if the elements in the vector are greater or equal than the value.
template<RealVector Vec1, RealVector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
mask< Vec1::size()>	aie::ge (const Vec1 &v1, const Vec2 &v2)
	Compares the elements of the two input vectors and returns a mask that says what elements from the first vector are greater or equal than the corresponding elements in the second vector.
template<RealElem E, RealVector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	aie::ge (E a, const Vec &v)
	Compares a value with the elements of the input vector and returns a mask that says if the value is greater or equal than the elements in the vector.
template<RealVector Vec, RealElem E> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	aie::gt (const Vec &v, E a)
	Compares the elements of the input vector with a value and returns a mask that says if the elements in the vector are greater than the value.
template<RealVector Vec1, RealVector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
mask< Vec1::size()>	aie::gt (const Vec1 &v1, const Vec2 &v2)
	Compares the elements of the two input vectors and returns a mask that says what elements from the first vector are greater than the corresponding elements in the second vector.
template<RealElem E, RealVector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	aie::gt (E a, const Vec &v)
	Compares a value with the elements of the input vector and returns a mask that says if the value is greater than the elements in the vector.
template<RealVector Vec, RealElem E> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	aie::le (const Vec &v, E a)
	Compares the elements of the input vector with a value and returns a mask that says if the elements in the vector are smaller or equal than the value.
template<RealVector Vec1, RealVector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
mask< Vec1::size()>	aie::le (const Vec1 &v1, const Vec2 &v2)
	Compares the elements of the two input vectors and returns a mask that says what elements from the first vector are smaller or equal than the corresponding elements in the second vector.
template<RealElem E, RealVector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	aie::le (E a, const Vec &v)
	Compares a value with the elements of the input vector and returns a mask that says if the value is smaller or equal than the elements in the vector.
template<RealVector Vec, RealElem E> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	aie::lt (const Vec &v, E a)
	Compares the elements of the input vector with a value and returns a mask that says if the elements in the vector are smaller than the value.
template<RealVector Vec1, RealVector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
mask< Vec1::size()>	aie::lt (const Vec1 &v1, const Vec2 &v2)
	Compares the elements of the two input vectors and returns a mask that says what elements from the first vector are smaller than the corresponding elements in the second vector.
template<RealElem E, RealVector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	aie::lt (E a, const Vec &v)
	Compares a value with the elements of the input vector and returns a mask that says if the value is smaller than the elements in the vector.
template<RealVector Vec, RealElem E> requires (is_valid_elem_op_v<typename Vec::value_type, E>)
auto	aie::max (const Vec &v, E a) -> aie_dm_resource_remove_t< Vec >
	Compares the elements of the input vector with a value and returns a vector with the maximum values.
template<RealVector Vec, RealElem E> requires (arch::is(arch::AIE_ML) && is_valid_elem_op_v<typename Vec::value_type, E>)
auto	aie::max (const Vec &v, E a, bool sign) -> aie_dm_resource_remove_t< Vec >
	Compares the elements of the input vector with a value and returns a vector with the maximum values.
template<RealVector Vec1, RealVector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
auto	aie::max (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
	Compares the elements of the two input vectors and returns a vector with the maximum values.
template<RealVector Vec1, RealVector Vec2> requires (arch::is(arch::AIE_ML) && is_same_vector_v<Vec1, Vec2>)
auto	aie::max (const Vec1 &v1, const Vec2 &v2, bool sign) -> aie_dm_resource_remove_t< Vec1 >
	Compares the elements of the two input vectors and returns a vector with the maximum values.
template<RealElem E, RealVector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
auto	aie::max (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
	Compares a value with the elements of the input vector and returns a vector with the maximum values.
template<RealElem E, RealVector Vec> requires (arch::is(arch::AIE_ML) && is_valid_elem_op_v<E, typename Vec::value_type>)
auto	aie::max (E a, const Vec &v, bool sign) -> aie_dm_resource_remove_t< Vec >
	Compares a value with the elements of the input vector and returns a vector with the maximum values.
template<RealVector Vec, RealElem E> requires (is_valid_elem_op_v<typename Vec::value_type, E>)
auto	aie::maxdiff (const Vec &v, E a) -> aie_dm_resource_remove_t< Vec >
	Compares the elements of the input vector with a value and returns a vector whose values are their difference if it is positive, or zero otherwise.
template<RealVector Vec, RealElem E> requires (arch::is(arch::AIE_ML) && is_valid_elem_op_v<typename Vec::value_type, E>)
auto	aie::maxdiff (const Vec &v, E a, bool sign) -> aie_dm_resource_remove_t< Vec >
	Compares the elements of the input vector with a value and returns a vector whose values are their difference if it is positive, or zero otherwise.
template<RealVector Vec1, RealVector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
auto	aie::maxdiff (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
	Compares the elements of the two input vectors and returns a vector whose values are their difference if it is positive, or zero otherwise.
template<RealVector Vec1, RealVector Vec2> requires (arch::is(arch::AIE_ML) && is_same_vector_v<Vec1, Vec2>)
auto	aie::maxdiff (const Vec1 &v1, const Vec2 &v2, bool sign) -> aie_dm_resource_remove_t< Vec1 >
	Compares the elements of the two input vectors and returns a vector whose values are their difference if it is positive, or zero otherwise.
template<RealElem E, RealVector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
auto	aie::maxdiff (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
	Compares a value with the elements of the input vector and returns a vector whose values are their difference if it is positive, or zero otherwise.
template<RealElem E, RealVector Vec> requires (arch::is(arch::AIE_ML) && is_valid_elem_op_v<E, typename Vec::value_type>)
auto	aie::maxdiff (E a, const Vec &v, bool sign) -> aie_dm_resource_remove_t< Vec >
	Compares a value with the elements of the input vector and returns a vector whose values are their difference if it is positive, or zero otherwise.
template<RealVector Vec, RealElem E> requires (is_valid_elem_op_v<typename Vec::value_type, E>)
auto	aie::min (const Vec &v, E a) -> aie_dm_resource_remove_t< Vec >
	Compares the elements of the input vector with a value and returns a vector with the minimum values.
template<RealVector Vec, RealElem E> requires (arch::is(arch::AIE_ML) && is_valid_elem_op_v<typename Vec::value_type, E>)
auto	aie::min (const Vec &v, E a, bool sign) -> aie_dm_resource_remove_t< Vec >
	Compares the elements of the input vector with a value and returns a vector with the minimum values.
template<RealVector Vec1, RealVector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
auto	aie::min (const Vec1 &v1, const Vec2 &v2) -> aie_dm_resource_remove_t< Vec1 >
	Compares the elements of the two input vectors and returns a vector with the minimum values.
template<RealVector Vec1, RealVector Vec2> requires (arch::is(arch::AIE_ML) && is_same_vector_v<Vec1, Vec2>)
auto	aie::min (const Vec1 &v1, const Vec2 &v2, bool sign) -> aie_dm_resource_remove_t< Vec1 >
	Compares the elements of the two input vectors and returns a vector with the minimum values.
template<RealElem E, RealVector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
auto	aie::min (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
	Compares a value with the elements of the input vector and returns a vector with the minimum values.
template<RealElem E, RealVector Vec> requires (arch::is(arch::AIE_ML) && is_valid_elem_op_v<E, typename Vec::value_type>)
auto	aie::min (E a, const Vec &v, bool sign) -> aie_dm_resource_remove_t< Vec >
	Compares a value with the elements of the input vector and returns a vector with the minimum values.
template<Vector Vec, Elem E> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	aie::neq (const Vec &v, E a)
	Compares a value with the elements of the input vector and returns a mask that says what elements in the vector are different than the value.
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
mask< Vec1::size()>	aie::neq (const Vec1 &v1, const Vec2 &v2)
	Compares the elements of the two input vectors and returns a mask that says what elements are different.
template<Elem E, Vector Vec> requires (is_valid_elem_op_v<E, typename Vec::value_type>)
mask< Vec::size()>	aie::neq (E a, const Vec &v)
	Compares a value with the elements of the input vector and returns a mask that says what elements in the vector are different than the value.
template<Vector Vec1, Vector Vec2> requires (is_same_vector_v<Vec1, Vec2>)
constexpr bool	aie::not_equal (const Vec1 &v1, const Vec2 &v2)
	Return whether some elements in the two input vectors are not equal.

Function Documentation

eq() [1/3]

template<Vector Vec, Elem E>
requires (is_valid_elem_op_v<E, typename Vec::value_type>)

mask< Vec::size()> aie::eq	(	const Vec &	v,
		E	a
	)

Compares a value with the elements of the input vector and returns a mask that says what elements in the vector are equal to the value.

The type of the value and the type of the vector elements must be the same.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = v[i] == a;

Parameters

v	Input vector. The type must meet Vector.
a	Value. The type must meet Elem.

eq() [2/3]

template<Vector Vec1, Vector Vec2>
requires (is_same_vector_v<Vec1, Vec2>)

mask< Vec1::size()> aie::eq	(	const Vec1 &	v1,
		const Vec2 &	v2
	)

Compares the elements of the two input vectors and returns a mask that says what elements are equal.

The vectors must have the same type and size.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = v1[i] == v2[i];

Parameters

v1	First input vector. The type must meet Vector.
v2	Second input vector. The type must meet Vector.

eq() [3/3]

template<Elem E, Vector Vec>
requires (is_valid_elem_op_v<E, typename Vec::value_type>)

mask< Vec::size()> aie::eq	(	E	a,
		const Vec &	v
	)

Compares a value with the elements of the input vector and returns a mask that says what elements in the vector are equal to the value.

The type of the value and the type of the vector elements must be the same.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = a == v[i];

Parameters

a	Value. The type must meet Elem.
v	Input vector. The type must meet Vector.

equal()

template<Vector Vec1, Vector Vec2>
requires (is_same_vector_v<Vec1, Vec2>)

constexpr bool aie::equal ( const Vec1 &  v1, const Vec2 &  v2  )

constexpr

Return whether all the elements of the two input vectors are equal.

The vectors must have the same type and size.

bool out = true;
for (unsigned i = 0; i < Elems; ++i)
    out = out && (v1[i] == v2[i]);

Parameters

v1	First input vector. The type must meet Vector.
v2	Second input vector. The type must meet Vector.

ge() [1/3]

template<RealVector Vec, RealElem E>
requires (is_valid_elem_op_v<E, typename Vec::value_type>)

mask< Vec::size()> aie::ge	(	const Vec &	v,
		E	a
	)

Compares the elements of the input vector with a value and returns a mask that says if the elements in the vector are greater or equal than the value.

The type of the value and the type of the vector elements must be the same.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = v[i] >= a;

Parameters

v	Input vector. The type must meet RealVector.
a	Value. The type must meet RealElem.

ge() [2/3]

template<RealVector Vec1, RealVector Vec2>
requires (is_same_vector_v<Vec1, Vec2>)

mask< Vec1::size()> aie::ge	(	const Vec1 &	v1,
		const Vec2 &	v2
	)

Compares the elements of the two input vectors and returns a mask that says what elements from the first vector are greater or equal than the corresponding elements in the second vector.

The vectors must have the same type and size.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = v1[i] >= v2[i];

Parameters

v1	First input vector. The type must meet RealVector.
v2	Second input vector. The type must meet RealVector.

ge() [3/3]

template<RealElem E, RealVector Vec>
requires (is_valid_elem_op_v<E, typename Vec::value_type>)

mask< Vec::size()> aie::ge	(	E	a,
		const Vec &	v
	)

Compares a value with the elements of the input vector and returns a mask that says if the value is greater or equal than the elements in the vector.

The type of the value and the type of the vector elements must be the same.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = a >= v[i];

Parameters

a	Value. The type must meet RealElem.
v	Input vector. The type must meet RealVector.

gt() [1/3]

template<RealVector Vec, RealElem E>
requires (is_valid_elem_op_v<E, typename Vec::value_type>)

mask< Vec::size()> aie::gt	(	const Vec &	v,
		E	a
	)

Compares the elements of the input vector with a value and returns a mask that says if the elements in the vector are greater than the value.

The type of the value and the type of the vector elements must be the same.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = v[i] > a;

Parameters

v	Input vector. The type must meet RealVector.
a	Value. The type must meet RealElem.

gt() [2/3]

template<RealVector Vec1, RealVector Vec2>
requires (is_same_vector_v<Vec1, Vec2>)

mask< Vec1::size()> aie::gt	(	const Vec1 &	v1,
		const Vec2 &	v2
	)

Compares the elements of the two input vectors and returns a mask that says what elements from the first vector are greater than the corresponding elements in the second vector.

The vectors must have the same type and size.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = v1[i] > v2[i];

Parameters

v1	First input vector. The type must meet RealVector.
v2	Second input vector. The type must meet RealVector.

gt() [3/3]

template<RealElem E, RealVector Vec>
requires (is_valid_elem_op_v<E, typename Vec::value_type>)

mask< Vec::size()> aie::gt	(	E	a,
		const Vec &	v
	)

Compares a value with the elements of the input vector and returns a mask that says if the value is greater than the elements in the vector.

The type of the value and the type of the vector elements must be the same.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = a > v[i];

Parameters

a	Value. The type must meet RealElem.
v	Input vector. The type must meet RealVector.

le() [1/3]

template<RealVector Vec, RealElem E>
requires (is_valid_elem_op_v<E, typename Vec::value_type>)

mask< Vec::size()> aie::le	(	const Vec &	v,
		E	a
	)

Compares the elements of the input vector with a value and returns a mask that says if the elements in the vector are smaller or equal than the value.

The type of the value and the type of the vector elements must be the same.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = v[i] <= a;

Parameters

v	Input vector. The type must meet RealVector.
a	Value. The type must meet RealElem.

le() [2/3]

template<RealVector Vec1, RealVector Vec2>
requires (is_same_vector_v<Vec1, Vec2>)

mask< Vec1::size()> aie::le	(	const Vec1 &	v1,
		const Vec2 &	v2
	)

Compares the elements of the two input vectors and returns a mask that says what elements from the first vector are smaller or equal than the corresponding elements in the second vector.

The vectors must have the same type and size.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = v1[i] <= v2[i];

Parameters

v1	First input vector. The type must meet RealVector.
v2	Second input vector. The type must meet RealVector.

le() [3/3]

template<RealElem E, RealVector Vec>
requires (is_valid_elem_op_v<E, typename Vec::value_type>)

mask< Vec::size()> aie::le	(	E	a,
		const Vec &	v
	)

Compares a value with the elements of the input vector and returns a mask that says if the value is smaller or equal than the elements in the vector.

The type of the value and the type of the vector elements must be the same.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = a <= v[i];

Parameters

a	Value. The type must meet RealElem.
v	Input vector. The type must meet RealVector.

lt() [1/3]

template<RealVector Vec, RealElem E>
requires (is_valid_elem_op_v<E, typename Vec::value_type>)

mask< Vec::size()> aie::lt	(	const Vec &	v,
		E	a
	)

Compares the elements of the input vector with a value and returns a mask that says if the elements in the vector are smaller than the value.

The type of the value and the type of the vector elements must be the same.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = v[i] < a;

Parameters

v	Input vector. The type must meet RealVector.
a	Value. The type must meet RealElem.

lt() [2/3]

template<RealVector Vec1, RealVector Vec2>
requires (is_same_vector_v<Vec1, Vec2>)

mask< Vec1::size()> aie::lt	(	const Vec1 &	v1,
		const Vec2 &	v2
	)

Compares the elements of the two input vectors and returns a mask that says what elements from the first vector are smaller than the corresponding elements in the second vector.

The vectors must have the same type and size.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = v1[i] < v2[i];

Parameters

v1	First input vector. The type must meet RealVector.
v2	Second input vector. The type must meet RealVector.

lt() [3/3]

template<RealElem E, RealVector Vec>
requires (is_valid_elem_op_v<E, typename Vec::value_type>)

mask< Vec::size()> aie::lt	(	E	a,
		const Vec &	v
	)

Compares a value with the elements of the input vector and returns a mask that says if the value is smaller than the elements in the vector.

The type of the value and the type of the vector elements must be the same.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = a < v[i];

Parameters

a	Value. The type must meet RealElem.
v	Input vector. The type must meet RealVector.

max() [1/6]

template<RealVector Vec, RealElem E>
requires (is_valid_elem_op_v<typename Vec::value_type, E>)

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

Compares the elements of the input vector with a value and returns a vector with the maximum values.

The type of the value and the type of the vector elements must be the same.

Parameters

v	Input vector. The type must meet RealVector.
a	Value. The type must meet RealElem.

max() [2/6]

template<RealVector Vec, RealElem E>
requires (arch::is(arch::AIE_ML) && is_valid_elem_op_v<typename Vec::value_type, E>)

auto aie::max	(	const Vec &	v,
		E	a,
		bool	sign
	)		-> aie_dm_resource_remove_t<Vec>

Compares the elements of the input vector with a value and returns a vector with the maximum values.

The type of the value and the type of the vector elements must be the same.

Parameters

v	Input vector. The type must meet RealVector.
a	Value. The type must meet RealElem.
sign	Whether the inputs need to be interpreted as signed values.

max() [3/6]

template<RealVector Vec1, RealVector Vec2>
requires (is_same_vector_v<Vec1, Vec2>)

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

Compares the elements of the two input vectors and returns a vector with the maximum values.

The vectors must have the same type and size.

Parameters

v1	First input vector. The type must meet RealVector.
v2	Second input vector. The type must meet RealVector.

max() [4/6]

template<RealVector Vec1, RealVector Vec2>
requires (arch::is(arch::AIE_ML) && is_same_vector_v<Vec1, Vec2>)

auto aie::max	(	const Vec1 &	v1,
		const Vec2 &	v2,
		bool	sign
	)		-> aie_dm_resource_remove_t<Vec1>

Compares the elements of the two input vectors and returns a vector with the maximum values.

The vectors must have the same type and size.

Parameters

v1	First input vector. The type must meet RealVector.
v2	Second input vector. The type must meet RealVector.
sign	Whether the inputs need to be interpreted as signed values.

max() [5/6]

template<RealElem E, RealVector Vec>
requires (is_valid_elem_op_v<E, typename Vec::value_type>)

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

Compares a value with the elements of the input vector and returns a vector with the maximum values.

The type of the value and the type of the vector elements must be the same.

Parameters

a	Value. The type must meet RealElem.
v	Input vector. The type must meet RealVector.

max() [6/6]

template<RealElem E, RealVector Vec>
requires (arch::is(arch::AIE_ML) && is_valid_elem_op_v<E, typename Vec::value_type>)

auto aie::max	(	E	a,
		const Vec &	v,
		bool	sign
	)		-> aie_dm_resource_remove_t<Vec>

Compares a value with the elements of the input vector and returns a vector with the maximum values.

The type of the value and the type of the vector elements must be the same.

Parameters

a	Value. The type must meet RealElem.
v	Input vector. The type must meet RealVector.
sign	Whether the inputs need to be interpreted as signed values.

maxdiff() [1/6]

template<RealVector Vec, RealElem E>
requires (is_valid_elem_op_v<typename Vec::value_type, E>)

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

Compares the elements of the input vector with a value and returns a vector whose values are their difference if it is positive, or zero otherwise.

The type of the value and the type of the vector elements must be the same.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = v[i] > a? v[i] - a : 0;

Parameters

v	Input vector. The type must meet Vector.
a	Value. The type must meet Elem.

maxdiff() [2/6]

template<RealVector Vec, RealElem E>
requires (arch::is(arch::AIE_ML) && is_valid_elem_op_v<typename Vec::value_type, E>)

auto aie::maxdiff	(	const Vec &	v,
		E	a,
		bool	sign
	)		-> aie_dm_resource_remove_t<Vec>

Compares the elements of the input vector with a value and returns a vector whose values are their difference if it is positive, or zero otherwise.

The type of the value and the type of the vector elements must be the same.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = v[i] > a? v[i] - a : 0;

Parameters

v	Input vector. The type must meet Vector.
a	Value. The type must meet Elem.
sign	Whether the inputs need to be interpreted as signed values.

maxdiff() [3/6]

template<RealVector Vec1, RealVector Vec2>
requires (is_same_vector_v<Vec1, Vec2>)

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

Compares the elements of the two input vectors and returns a vector whose values are their difference if it is positive, or zero otherwise.

The vectors must have the same type and size.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = v1[i] > v2[i]? v1[i] - v2[i] : 0;

Parameters

v1	First input vector. The type must meet RealVector.
v2	Second input vector. The type must meet RealVector.

maxdiff() [4/6]

template<RealVector Vec1, RealVector Vec2>
requires (arch::is(arch::AIE_ML) && is_same_vector_v<Vec1, Vec2>)

auto aie::maxdiff	(	const Vec1 &	v1,
		const Vec2 &	v2,
		bool	sign
	)		-> aie_dm_resource_remove_t<Vec1>

Compares the elements of the two input vectors and returns a vector whose values are their difference if it is positive, or zero otherwise.

The vectors must have the same type and size.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = v1[i] > v2[i]? v1[i] - v2[i] : 0;

Parameters

v1	First input vector. The type must meet RealVector.
v2	Second input vector. The type must meet RealVector.
sign	Whether the inputs need to be interpreted as signed values.

maxdiff() [5/6]

template<RealElem E, RealVector Vec>
requires (is_valid_elem_op_v<E, typename Vec::value_type>)

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

Compares a value with the elements of the input vector and returns a vector whose values are their difference if it is positive, or zero otherwise.

The type of the value and the type of the vector elements must be the same.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = a > v[i]? a - v[i] : 0;

Parameters

a	Value. The type must meet Elem.
v	Input vector. The type must meet Vector.

maxdiff() [6/6]

template<RealElem E, RealVector Vec>
requires (arch::is(arch::AIE_ML) && is_valid_elem_op_v<E, typename Vec::value_type>)

auto aie::maxdiff	(	E	a,
		const Vec &	v,
		bool	sign
	)		-> aie_dm_resource_remove_t<Vec>

Compares a value with the elements of the input vector and returns a vector whose values are their difference if it is positive, or zero otherwise.

The type of the value and the type of the vector elements must be the same.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = a > v[i]? a - v[i] : 0;

Parameters

a	Value. The type must meet Elem.
v	Input vector. The type must meet Vector.
sign	Whether the inputs need to be interpreted as signed values.

min() [1/6]

template<RealVector Vec, RealElem E>
requires (is_valid_elem_op_v<typename Vec::value_type, E>)

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

Compares the elements of the input vector with a value and returns a vector with the minimum values.

The type of the value and the type of the vector elements must be the same.

Parameters

v	Input vector. The type must meet RealVector.
a	Value. The type must meet RealElem.

min() [2/6]

template<RealVector Vec, RealElem E>
requires (arch::is(arch::AIE_ML) && is_valid_elem_op_v<typename Vec::value_type, E>)

auto aie::min	(	const Vec &	v,
		E	a,
		bool	sign
	)		-> aie_dm_resource_remove_t<Vec>

Compares the elements of the input vector with a value and returns a vector with the minimum values.

The type of the value and the type of the vector elements must be the same.

Parameters

v	Input vector. The type must meet RealVector.
a	Value. The type must meet RealElem.
sign	Whether the inputs need to be interpreted as signed values.

min() [3/6]

template<RealVector Vec1, RealVector Vec2>
requires (is_same_vector_v<Vec1, Vec2>)

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

Compares the elements of the two input vectors and returns a vector with the minimum values.

The vectors must have the same type and size.

Parameters

v1	First input vector. The type must meet RealVector.
v2	Second input vector. The type must meet RealVector.

min() [4/6]

template<RealVector Vec1, RealVector Vec2>
requires (arch::is(arch::AIE_ML) && is_same_vector_v<Vec1, Vec2>)

auto aie::min	(	const Vec1 &	v1,
		const Vec2 &	v2,
		bool	sign
	)		-> aie_dm_resource_remove_t<Vec1>

Compares the elements of the two input vectors and returns a vector with the minimum values.

The vectors must have the same type and size.

Parameters

v1	First input vector. The type must meet RealVector.
v2	Second input vector. The type must meet RealVector.
sign	Whether the inputs need to be interpreted as signed values.

min() [5/6]

template<RealElem E, RealVector Vec>
requires (is_valid_elem_op_v<E, typename Vec::value_type>)

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

Compares a value with the elements of the input vector and returns a vector with the minimum values.

The type of the value and the type of the vector elements must be the same.

Parameters

a	Value. The type must meet RealElem.
v	Input vector. The type must meet RealVector.

min() [6/6]

template<RealElem E, RealVector Vec>
requires (arch::is(arch::AIE_ML) && is_valid_elem_op_v<E, typename Vec::value_type>)

auto aie::min	(	E	a,
		const Vec &	v,
		bool	sign
	)		-> aie_dm_resource_remove_t<Vec>

Compares a value with the elements of the input vector and returns a vector with the minimum values.

The type of the value and the type of the vector elements must be the same.

Parameters

a	Value. The type must meet RealElem.
v	Input vector. The type must meet RealVector.
sign	Whether the inputs need to be interpreted as signed values.

neq() [1/3]

template<Vector Vec, Elem E>
requires (is_valid_elem_op_v<E, typename Vec::value_type>)

mask< Vec::size()> aie::neq	(	const Vec &	v,
		E	a
	)

Compares a value with the elements of the input vector and returns a mask that says what elements in the vector are different than the value.

The type of the value and the type of the vector elements must be the same.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = v[i] != a;

Parameters

v	Input vector. The type must meet Vector.
a	Value. The type must meet Elem.

neq() [2/3]

template<Vector Vec1, Vector Vec2>
requires (is_same_vector_v<Vec1, Vec2>)

mask< Vec1::size()> aie::neq	(	const Vec1 &	v1,
		const Vec2 &	v2
	)

Compares the elements of the two input vectors and returns a mask that says what elements are different.

The vectors must have the same type and size.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = v1[i] != v2[i];

Parameters

v1	First input vector. The type must meet Vector.
v2	Second input vector. The type must meet Vector.

neq() [3/3]

template<Elem E, Vector Vec>
requires (is_valid_elem_op_v<E, typename Vec::value_type>)

mask< Vec::size()> aie::neq	(	E	a,
		const Vec &	v
	)

Compares a value with the elements of the input vector and returns a mask that says what elements in the vector are different than the value.

The type of the value and the type of the vector elements must be the same.

for (unsigned i = 0; i < Elems; ++i)
    out[i] = a != v[i];

Parameters

a	Value. The type must meet Elem.
v	Input vector. The type must meet Vector.

not_equal()

template<Vector Vec1, Vector Vec2>
requires (is_same_vector_v<Vec1, Vec2>)

constexpr bool aie::not_equal ( const Vec1 &  v1, const Vec2 &  v2  )

constexpr

Return whether some elements in the two input vectors are not equal.

The vectors must have the same type and size.

bool out = true;
for (unsigned i = 0; i < Elems; ++i)
    out = out && (v1[i] != v2[i]);

Parameters

v1	First input vector. The type must meet Vector.
v2	Second input vector. The type must meet Vector.