Description

The relational and equality operators (<, <=, >, >=, !=, ==) can be used with scalar and vector built-in types and produce a scalar or vector signed integer result respectively.

The functions described in the Built-in Scalar and Vector Relational Functions table can be used with built-in scalar or vector types as arguments and return a scalar or vector integer result [1]. The argument type gentype refers to the following built-in types: char, charn, uchar, ucharn, short, shortn, ushort, ushortn, int, intn, uint, uintn, long [2], longn, ulong, ulongn, float, floatn, double [3], and doublen. The argument type igentype refers to the built-in signed integer types i.e. char, charn, short, shortn, int, intn, long and longn. The argument type ugentype refers to the built-in unsigned integer types i.e. uchar, ucharn, ushort, ushortn, uint, uintn, ulong and ulongn. n is 2, 3, 4, 8, or 16.

The functions isequal, isnotequal, isgreater, isgreaterequal, isless, islessequal, islessgreater, isfinite, isinf, isnan, isnormal, isordered, isunordered and signbit described in the following table shall return a 0 if the specified relation is false and a 1 if the specified relation is true for scalar argument types. These functions shall return a 0 if the specified relation is false and a -1 (i.e. all bits set) if the specified relation is true for vector argument types.

The relational functions isequal, isgreater, isgreaterequal, isless, islessequal, and islessgreater always return 0 if either argument is not a number (NaN). isnotequal returns 1 if one or both arguments are not a number (NaN) and the argument type is a scalar and returns -1 if one or both arguments are not a number (NaN) and the argument type is a vector.

Table 1. Built-in Scalar and Vector Relational Functions
Function Description

int isequal(float x, float y)
intn isequal(floatn x, floatn y)
int isequal(double x, double y)
longn isequal(doublen x, doublen y)

int isequal(half x, half y)
shortn isequal(halfn x, halfn y)

Returns the component-wise compare of x == y.

int isnotequal(float x, float y)
intn isnotequal(floatn x, floatn y)
int isnotequal(double x, double y)
longn isnotequal(doublen x, doublen y)

int isnotequal(half x, half y)
shortn isnotequal(halfn x, halfn y)

Returns the component-wise compare of x != y.

int isgreater(float x, float y)
intn isgreater(floatn x, floatn y)
int isgreater(double x, double y)
longn isgreater(doublen x, doublen y)

int isgreater(half x, half y)
shortn isgreater(halfn x, halfn y)

Returns the component-wise compare of x > y.

int isgreaterequal(float x, float y)
intn isgreaterequal(floatn x, floatn y)
int isgreaterequal(double x, double y)
longn isgreaterequal(doublen x, doublen y)

int isgreaterequal(half x, half y)
shortn isgreaterequal(halfn x, halfn y)

Returns the component-wise compare of x >= y.

int isless(float x, float y)
intn isless(floatn x, floatn y)
int isless(double x, double y)
longn isless(doublen x, doublen y)

int isless(half x, half y)
shortn isless(halfn x, halfn y)

Returns the component-wise compare of x < y.

int islessequal(float x, float y)
intn islessequal(floatn x, floatn y)
int islessequal(double x, double y)
longn islessequal(doublen x, doublen y)

int islessequal(half x, half y)
shortn islessequal(halfn x, halfn y)

Returns the component-wise compare of x <= y.

int islessgreater(float x, float y)
intn islessgreater(floatn x, floatn y)
int islessgreater(double x, double y)
longn islessgreater(doublen x, doublen y)

int islessgreater(half x, half y)
shortn islessgreater(halfn x, halfn y)

Returns the component-wise compare of (x < y) || (x > y) .

int isfinite(float)
intn isfinite(floatn)
int isfinite(double)
longn isfinite(doublen)

int isfinite(half)
shortn isfinite(halfn)

Test for finite value.

int isinf(float)
intn isinf(floatn)
int isinf(double)
longn isinf(doublen)

int isinf(half)
shortn isinf(halfn)

Test for infinity value (positive or negative).

int isnan(float)
intn isnan(floatn)
int isnan(double)
longn isnan(doublen)

int isnan(half)
shortn isnan(halfn)

Test for a NaN.

int isnormal(float)
intn isnormal(floatn)
int isnormal(double)
longn isnormal(doublen)

int isnormal(half)
shortn isnormal(halfn)

Test for a normal value.

int isordered(float x, float y)
intn isordered(floatn x, floatn y)
int isordered(double x, double y)
longn isordered(doublen x, doublen y)

int isordered(half x, half y)
shortn isordered(halfn x, halfn y)

Test if arguments are ordered. isordered() takes arguments x and y, and returns the result isequal(x, x) && isequal(y, y).

int isunordered(float x, float y)
intn isunordered(floatn x, floatn y)
int isunordered(double x, double y)
longn isunordered(doublen x, doublen y)

int isunordered(half x, half y)
shortn isunordered(halfn x, halfn y)

Test if arguments are unordered. isunordered() takes arguments x and y, returning non-zero if x or y is NaN, and zero otherwise.

int signbit(float x)
intn signbit(floatn x)
int signbit(double x)
longn signbit(doublen x)

int signbit(half x)
shortn signbit(halfn x)

Test for sign bit. The scalar version of the function returns a 1 if the sign bit in x is set else returns 0. The vector version of the function returns the following for each component in x: -1 (i.e all bits set) if the sign bit in the float is set else returns 0.

int any(igentype x)

Scalar inputs to any are deprecated by OpenCL C version 3.0.

Returns 1 if the most significant bit of x (for scalar inputs) or any component of x (for vector inputs) is set; otherwise returns 0.

int all(igentype x)

Scalar inputs to all are deprecated by OpenCL C version 3.0.

Returns 1 if the most significant bit of x (for scalar inputs) or all components of x (for vector inputs) is set; otherwise returns 0.

gentype bitselect(gentype a, gentype b, gentype c)

Each bit of the result is the corresponding bit of a if the corresponding bit of c is 0. Otherwise it is the corresponding bit of b.

gentype select(gentype a, gentype b, igentype c)
gentype select(gentype a, gentype b, ugentype c)

For each component of a vector type,

result[i] = if MSB of c[i] is set ? b[i] : a[i].

For a scalar type, result = c ? b : a.

igentype and ugentype must have the same number of elements and bits as gentype [4].

See Also

integerFunctions

Document Notes

For more information, see the OpenCL C Specification

This page is extracted from the OpenCL C Specification. Fixes and changes should be made to the Specification, not directly.

Copyright

Copyright 2014-2025 The Khronos Group Inc.

SPDX-License-Identifier: CC-BY-4.0

1. If an implementation extends this specification to support IEEE-754 flags or exceptions, then all built-in functions defined in the following table shall proceed without raising the invalid floating-point exception when one or more of the operands are NaNs.
2. Only if 64-bit integers are supported. In OpenCL C 3.0 this will be indicated by the presence of the __opencl_c_int64 feature macro.
3. Only if double precision is supported. In OpenCL C 3.0 this will be indicated by the presence of the __opencl_c_fp64 feature macro.
4. This definition means that the behavior of select and the ternary operator for vector and scalar types is dependent on different interpretations of the bit pattern of c.