Overview

Vector comparison operations.

Functions
template<Vector Vec, Elem E>
mask< Vec::size()>	aie::eq (const Vec &v, E a)
	More...

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

template<Elem E, Vector Vec>
mask< Vec::size()>	aie::eq (E a, const Vec &v)
	More...

template<Vector Vec1, Vector Vec2>
constexpr bool	aie::equal (const Vec1 &v1, const Vec2 &v2)
	More...

template<RealVector Vec, RealElem E>
mask< Vec::size()>	aie::ge (const Vec &v, E a)
	More...

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

template<RealElem E, RealVector Vec>
mask< Vec::size()>	aie::ge (E a, const Vec &v)
	More...

template<RealVector Vec, RealElem E>
mask< Vec::size()>	aie::gt (const Vec &v, E a)
	More...

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

template<RealElem E, RealVector Vec>
mask< Vec::size()>	aie::gt (E a, const Vec &v)
	More...

template<RealVector Vec, RealElem E>
mask< Vec::size()>	aie::le (const Vec &v, E a)
	More...

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

template<RealElem E, RealVector Vec>
mask< Vec::size()>	aie::le (E a, const Vec &v)
	More...

template<RealVector Vec, RealElem E>
mask< Vec::size()>	aie::lt (const Vec &v, E a)
	More...

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

template<RealElem E, RealVector Vec>
mask< Vec::size()>	aie::lt (E a, const Vec &v)
	More...

template<RealVector Vec, RealElem E>
auto	aie::max (const Vec &v, E a) -> aie_dm_resource_remove_t< Vec >
	More...

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

template<RealElem E, RealVector Vec>
auto	aie::max (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
	More...

template<RealVector Vec, RealElem E>
auto	aie::maxdiff (const Vec &v, E a) -> aie_dm_resource_remove_t< Vec >
	More...

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

template<RealElem E, RealVector Vec>
auto	aie::maxdiff (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
	More...

template<RealVector Vec, RealElem E>
auto	aie::min (const Vec &v, E a) -> aie_dm_resource_remove_t< Vec >
	More...

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

template<RealElem E, RealVector Vec>
auto	aie::min (E a, const Vec &v) -> aie_dm_resource_remove_t< Vec >
	More...

template<Vector Vec, Elem E>
mask< Vec::size()>	aie::neq (const Vec &v, E a)
	More...

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

template<Elem E, Vector Vec>
mask< Vec::size()>	aie::neq (E a, const Vec &v)
	More...

template<Vector Vec1, Vector Vec2>
constexpr bool	aie::not_equal (const Vec1 &v1, const Vec2 &v2)
	More...

Function Documentation

◆ eq() [1/3]

template<Vector Vec, Elem E>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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/3]

template<RealVector Vec, RealElem 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/3]

template<RealVector Vec1, RealVector 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() [3/3]

template<RealElem E, RealVector Vec>

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.

◆ maxdiff() [1/3]

template<RealVector Vec, RealElem 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/3]

template<RealVector Vec1, RealVector 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() [3/3]

template<RealElem E, RealVector Vec>

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.

◆ min() [1/3]

template<RealVector Vec, RealElem 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/3]

template<RealVector Vec1, RealVector 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() [3/3]

template<RealElem E, RealVector Vec>

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.

◆ neq() [1/3]

template<Vector Vec, Elem E>

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>

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>

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>

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.

Overview

Functions

Function Documentation

◆ eq() [1/3]

◆ eq() [2/3]

◆ eq() [3/3]

◆ equal()

◆ ge() [1/3]

◆ ge() [2/3]

◆ ge() [3/3]

◆ gt() [1/3]

◆ gt() [2/3]

◆ gt() [3/3]

◆ le() [1/3]

◆ le() [2/3]

◆ le() [3/3]

◆ lt() [1/3]

◆ lt() [2/3]

◆ lt() [3/3]

◆ max() [1/3]

◆ max() [2/3]

◆ max() [3/3]

◆ maxdiff() [1/3]

◆ maxdiff() [2/3]

◆ maxdiff() [3/3]

◆ min() [1/3]

◆ min() [2/3]

◆ min() [3/3]

◆ neq() [1/3]

◆ neq() [2/3]

◆ neq() [3/3]

◆ not_equal()