NAME¶

std::experimental::simd::operator==,!=,,>= - std::experimental::simd::operator==,!=,,>=

Synopsis¶

friend simd_mask operator==( const simd& lhs, const simd& (1) (parallelism TS v2)
rhs ) noexcept;
friend simd_mask operator!=( const simd& lhs, const simd& (2) (parallelism TS v2)
rhs ) noexcept;
friend simd_mask operator<( const simd& lhs, const simd& rhs (3) (parallelism TS v2)
) noexcept;
friend simd_mask operator<=( const simd& lhs, const simd& (4) (parallelism TS v2)
rhs ) noexcept;
friend simd_mask operator>( const simd& lhs, const simd& rhs (5) (parallelism TS v2)
) noexcept;
friend simd_mask operator>=( const simd& lhs, const simd& (6) (parallelism TS v2)
rhs ) noexcept;

Applies the given comparison element-wise to each corresponding element of the
operands. Returns a simd_mask such that for all i in the range of [0, size()) the
i^th element equals:

1) lhs[i] == rhs[i].
2) lhs[i] != rhs[i].
3) lhs[i] < rhs[i].
4) lhs[i] <= rhs[i].
5) lhs[i] > rhs[i].
6) lhs[i] >= rhs[i].

Parameters¶

lhs - left operands
rhs - right operands

Example¶

// Run this code

#include <cassert>
#include <iostream>
#include <initializer_list>
#include <iterator>

#include <experimental/simd>
namespace stdx = std::experimental;

int main()
{
using V = stdx::fixed_size_simd<int, 4>;
using M = stdx::fixed_size_simd_mask<int, 4>;

auto assert_equivalence = [](M&& x, std::initializer_list<int>&& y)
{
for (decltype(M::size()) i{}; i != M::size(); ++i)
assert(x[i] == std::cbegin(y)[i]);
};

V a{2}, b, c{3};
b[0] = 1, b[1] = 2, b[2] = 3, b[3] = 4;

// a == {2, 2, 2, 2}
// b == {1, 2, 3, 4}
// c == {3, 3, 3, 3}

assert_equivalence(a == a, {1, 1, 1, 1});
assert_equivalence(a == b, {0, 1, 0, 0});
assert_equivalence(b == c, {0, 0, 1, 0});
assert_equivalence(a == c, {0, 0, 0, 0});

assert_equivalence(a != a, {0, 0, 0, 0});
assert_equivalence(a != b, {1, 0, 1, 1});
assert_equivalence(b != c, {1, 1, 0, 1});
assert_equivalence(a != c, {1, 1, 1, 1});

assert_equivalence(a < a, {0, 0, 0, 0});
assert_equivalence(a < b, {0, 0, 1, 1});
assert_equivalence(b < c, {1, 1, 0, 0});
assert_equivalence(a < c, {1, 1, 1, 1});
}

See also¶

all_of
any_of reductions of simd_mask to bool
none_of (function template)
some_of
(parallelism TS v2)
popcount reduction of simd_mask to the number of true values
(parallelism TS v2) (function template)
find_first_set reductions of simd_mask to the index of the first or last true
find_last_set value
(parallelism TS v2) (function template)
simd_mask data-parallel type with the element type bool
(parallelism TS v2) (class template)