SSE_ALL-Compare-XMM#

_mm_cmpeq_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpeq_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point elements in “a” and “b” for equality, store the result in the lower element of “dst”, and copy the upper 3 packed elements from “a” to the upper elements of “dst”.

Intel Implementation Psudeo-Code

dst[31:0] := ( a[31:0] == b[31:0] ) ? 0xFFFFFFFF : 0
dst[127:32] := a[127:32]

_mm_cmpeq_ps#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpeq_ps(__m128 a, __m128 b);

Intel Description

Compare packed single-precision (32-bit) floating-point elements in “a” and “b” for equality, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 3
        i := j*32
        dst[i+31:i] := ( a[i+31:i] == b[i+31:i] ) ? 0xFFFFFFFF : 0
ENDFOR

_mm_cmplt_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmplt_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point elements in “a” and “b” for less-than, store the result in the lower element of “dst”, and copy the upper 3 packed elements from “a” to the upper elements of “dst”.

Intel Implementation Psudeo-Code

dst[31:0] := ( a[31:0] < b[31:0] ) ? 0xFFFFFFFF : 0
dst[127:32] := a[127:32]

_mm_cmplt_ps#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmplt_ps(__m128 a, __m128 b);

Intel Description

Compare packed single-precision (32-bit) floating-point elements in “a” and “b” for less-than, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 3
        i := j*32
        dst[i+31:i] := ( a[i+31:i] < b[i+31:i] ) ? 0xFFFFFFFF : 0
ENDFOR

_mm_cmple_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmple_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point elements in “a” and “b” for less-than-or-equal, store the result in the lower element of “dst”, and copy the upper 3 packed elements from “a” to the upper elements of “dst”.

Intel Implementation Psudeo-Code

dst[31:0] := ( a[31:0] <= b[31:0] ) ? 0xFFFFFFFF : 0
dst[127:32] := a[127:32]

_mm_cmple_ps#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmple_ps(__m128 a, __m128 b);

Intel Description

Compare packed single-precision (32-bit) floating-point elements in “a” and “b” for less-than-or-equal, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 3
        i := j*32
        dst[i+31:i] := ( a[i+31:i] <= b[i+31:i] ) ? 0xFFFFFFFF : 0
ENDFOR

_mm_cmpgt_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpgt_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point elements in “a” and “b” for greater-than, store the result in the lower element of “dst”, and copy the upper 3 packed elements from “a” to the upper elements of “dst”.

Intel Implementation Psudeo-Code

dst[31:0] := ( a[31:0] > b[31:0] ) ? 0xFFFFFFFF : 0
dst[127:32] := a[127:32]

_mm_cmpgt_ps#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpgt_ps(__m128 a, __m128 b);

Intel Description

Compare packed single-precision (32-bit) floating-point elements in “a” and “b” for greater-than, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 3
        i := j*32
        dst[i+31:i] := ( a[i+31:i] > b[i+31:i] ) ? 0xFFFFFFFF : 0
ENDFOR

_mm_cmpge_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpge_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point elements in “a” and “b” for greater-than-or-equal, store the result in the lower element of “dst”, and copy the upper 3 packed elements from “a” to the upper elements of “dst”.

Intel Implementation Psudeo-Code

dst[31:0] := ( a[31:0] >= b[31:0] ) ? 0xFFFFFFFF : 0
dst[127:32] := a[127:32]

_mm_cmpge_ps#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpge_ps(__m128 a, __m128 b);

Intel Description

Compare packed single-precision (32-bit) floating-point elements in “a” and “b” for greater-than-or-equal, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 3
        i := j*32
        dst[i+31:i] := ( a[i+31:i] >= b[i+31:i] ) ? 0xFFFFFFFF : 0
ENDFOR

_mm_cmpneq_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpneq_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point elements in “a” and “b” for not-equal, store the result in the lower element of “dst”, and copy the upper 3 packed elements from “a” to the upper elements of “dst”.

Intel Implementation Psudeo-Code

dst[31:0] := ( a[31:0] != b[31:0] ) ? 0xFFFFFFFF : 0
dst[127:32] := a[127:32]

_mm_cmpneq_ps#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpneq_ps(__m128 a, __m128 b);

Intel Description

Compare packed single-precision (32-bit) floating-point elements in “a” and “b” for not-equal, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 3
        i := j*32
        dst[i+31:i] := ( a[i+31:i] != b[i+31:i] ) ? 0xFFFFFFFF : 0
ENDFOR

_mm_cmpnlt_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpnlt_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point elements in “a” and “b” for not-less-than, store the result in the lower element of “dst”, and copy the upper 3 packed elements from “a” to the upper elements of “dst”.

Intel Implementation Psudeo-Code

dst[31:0] := (!( a[31:0] < b[31:0] )) ? 0xFFFFFFFF : 0
dst[127:32] := a[127:32]

_mm_cmpnlt_ps#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpnlt_ps(__m128 a, __m128 b);

Intel Description

Compare packed single-precision (32-bit) floating-point elements in “a” and “b” for not-less-than, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 3
        i := j*32
        dst[i+31:i] := !( a[i+31:i] < b[i+31:i] ) ? 0xFFFFFFFF : 0
ENDFOR

_mm_cmpnle_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpnle_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point elements in “a” and “b” for not-less-than-or-equal, store the result in the lower element of “dst”, and copy the upper 3 packed elements from “a” to the upper elements of “dst”.

Intel Implementation Psudeo-Code

dst[31:0] := (!( a[31:0] <= b[31:0] )) ? 0xFFFFFFFF : 0
dst[127:32] := a[127:32]

_mm_cmpnle_ps#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpnle_ps(__m128 a, __m128 b);

Intel Description

Compare packed single-precision (32-bit) floating-point elements in “a” and “b” for not-less-than-or-equal, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 3
        i := j*32
        dst[i+31:i] := (!( a[i+31:i] <= b[i+31:i] )) ? 0xFFFFFFFF : 0
ENDFOR

_mm_cmpngt_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpngt_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point elements in “a” and “b” for not-greater-than, store the result in the lower element of “dst”, and copy the upper 3 packed elements from “a” to the upper elements of “dst”.

Intel Implementation Psudeo-Code

dst[31:0] := (!( a[31:0] > b[31:0] )) ? 0xFFFFFFFF : 0
dst[127:32] := a[127:32]

_mm_cmpngt_ps#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpngt_ps(__m128 a, __m128 b);

Intel Description

Compare packed single-precision (32-bit) floating-point elements in “a” and “b” for not-greater-than, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 3
        i := j*32
        dst[i+31:i] := (!( a[i+31:i] > b[i+31:i] )) ? 0xFFFFFFFF : 0
ENDFOR

_mm_cmpnge_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpnge_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point elements in “a” and “b” for not-greater-than-or-equal, store the result in the lower element of “dst”, and copy the upper 3 packed elements from “a” to the upper elements of “dst”.

Intel Implementation Psudeo-Code

dst[31:0] := (!( a[31:0] >= b[31:0] )) ? 0xFFFFFFFF : 0
dst[127:32] := a[127:32]

_mm_cmpnge_ps#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpnge_ps(__m128 a, __m128 b);

Intel Description

Compare packed single-precision (32-bit) floating-point elements in “a” and “b” for not-greater-than-or-equal, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 3
        i := j*32
        dst[i+31:i] := (!( a[i+31:i] >= b[i+31:i] )) ? 0xFFFFFFFF : 0
ENDFOR

_mm_cmpord_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpord_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point elements in “a” and “b” to see if neither is NaN, store the result in the lower element of “dst”, and copy the upper 3 packed elements from “a” to the upper elements of “dst”.

Intel Implementation Psudeo-Code

dst[31:0] := ( a[31:0] != NaN AND b[31:0] != NaN ) ? 0xFFFFFFFF : 0
dst[127:32] := a[127:32]

_mm_cmpord_ps#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpord_ps(__m128 a, __m128 b);

Intel Description

Compare packed single-precision (32-bit) floating-point elements in “a” and “b” to see if neither is NaN, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 3
        i := j*32
        dst[i+31:i] := ( a[i+31:i] != NaN AND b[i+31:i] != NaN ) ? 0xFFFFFFFF : 0
ENDFOR

_mm_cmpunord_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpunord_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point elements in “a” and “b” to see if either is NaN, store the result in the lower element of “dst”, and copy the upper 3 packed elements from “a” to the upper elements of “dst”.

Intel Implementation Psudeo-Code

dst[31:0] := ( a[31:0] == NaN OR b[31:0] == NaN ) ? 0xFFFFFFFF : 0
dst[127:32] := a[127:32]

_mm_cmpunord_ps#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

__m128 _mm_cmpunord_ps(__m128 a, __m128 b);

Intel Description

Compare packed single-precision (32-bit) floating-point elements in “a” and “b” to see if either is NaN, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 3
        i := j*32
        dst[i+31:i] := ( a[i+31:i] == NaN OR b[i+31:i] == NaN ) ? 0xFFFFFFFF : 0
ENDFOR

_mm_comieq_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

int _mm_comieq_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point element in “a” and “b” for equality, and return the boolean result (0 or 1).

Intel Implementation Psudeo-Code

RETURN ( a[31:0] != NaN AND b[31:0] != NaN AND a[31:0] == b[31:0] ) ? 1 : 0

_mm_comilt_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

int _mm_comilt_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point element in “a” and “b” for less-than, and return the boolean result (0 or 1).

Intel Implementation Psudeo-Code

RETURN ( a[31:0] != NaN AND b[31:0] != NaN AND a[31:0] < b[31:0] ) ? 1 : 0

_mm_comile_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

int _mm_comile_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point element in “a” and “b” for less-than-or-equal, and return the boolean result (0 or 1).

Intel Implementation Psudeo-Code

RETURN ( a[31:0] != NaN AND b[31:0] != NaN AND a[31:0] <= b[31:0] ) ? 1 : 0

_mm_comigt_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

int _mm_comigt_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point element in “a” and “b” for greater-than, and return the boolean result (0 or 1).

Intel Implementation Psudeo-Code

RETURN ( a[31:0] != NaN AND b[31:0] != NaN AND a[31:0] > b[31:0] ) ? 1 : 0

_mm_comige_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

int _mm_comige_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point element in “a” and “b” for greater-than-or-equal, and return the boolean result (0 or 1).

Intel Implementation Psudeo-Code

RETURN ( a[31:0] != NaN AND b[31:0] != NaN AND a[31:0] >= b[31:0] ) ? 1 : 0

_mm_comineq_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

int _mm_comineq_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point element in “a” and “b” for not-equal, and return the boolean result (0 or 1).

Intel Implementation Psudeo-Code

RETURN ( a[31:0] == NaN OR b[31:0] == NaN OR a[31:0] != b[31:0] ) ? 1 : 0

_mm_ucomieq_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

int _mm_ucomieq_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point element in “a” and “b” for equality, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.

Intel Implementation Psudeo-Code

RETURN ( a[31:0] != NaN AND b[31:0] != NaN AND a[31:0] == b[31:0] ) ? 1 : 0

_mm_ucomilt_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

int _mm_ucomilt_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point element in “a” and “b” for less-than, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.

Intel Implementation Psudeo-Code

RETURN ( a[31:0] != NaN AND b[31:0] != NaN AND a[31:0] < b[31:0] ) ? 1 : 0

_mm_ucomile_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

int _mm_ucomile_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point element in “a” and “b” for less-than-or-equal, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.

Intel Implementation Psudeo-Code

RETURN ( a[31:0] != NaN AND b[31:0] != NaN AND a[31:0] <= b[31:0] ) ? 1 : 0

_mm_ucomigt_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

int _mm_ucomigt_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point element in “a” and “b” for greater-than, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.

Intel Implementation Psudeo-Code

RETURN ( a[31:0] != NaN AND b[31:0] != NaN AND a[31:0] > b[31:0] ) ? 1 : 0

_mm_ucomige_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

int _mm_ucomige_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point element in “a” and “b” for greater-than-or-equal, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.

Intel Implementation Psudeo-Code

RETURN ( a[31:0] != NaN AND b[31:0] != NaN AND a[31:0] >= b[31:0] ) ? 1 : 0

_mm_ucomineq_ss#

Tech:: SSE_ALL
Category:: Compare
Header:: xmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128 a, __m128 b
Param ETypes:: FP32 a, FP32 b

int _mm_ucomineq_ss(__m128 a, __m128 b);

Intel Description

Compare the lower single-precision (32-bit) floating-point element in “a” and “b” for not-equal, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.

Intel Implementation Psudeo-Code

RETURN ( a[31:0] == NaN OR b[31:0] == NaN OR a[31:0] != b[31:0] ) ? 1 : 0

_mm_cmpeq_epi8#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128i
Param Types:: __m128i a, __m128i b
Param ETypes:: UI8 a, UI8 b

__m128i _mm_cmpeq_epi8(__m128i a, __m128i b);

Intel Description

Compare packed 8-bit integers in “a” and “b” for equality, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*8
        dst[i+7:i] := ( a[i+7:i] == b[i+7:i] ) ? 0xFF : 0
ENDFOR

_mm_cmpeq_epi16#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128i
Param Types:: __m128i a, __m128i b
Param ETypes:: UI16 a, UI16 b

__m128i _mm_cmpeq_epi16(__m128i a, __m128i b);

Intel Description

Compare packed 16-bit integers in “a” and “b” for equality, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*16
        dst[i+15:i] := ( a[i+15:i] == b[i+15:i] ) ? 0xFFFF : 0
ENDFOR

_mm_cmpeq_epi32#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128i
Param Types:: __m128i a, __m128i b
Param ETypes:: UI32 a, UI32 b

__m128i _mm_cmpeq_epi32(__m128i a, __m128i b);

Intel Description

Compare packed 32-bit integers in “a” and “b” for equality, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 3
        i := j*32
        dst[i+31:i] := ( a[i+31:i] == b[i+31:i] ) ? 0xFFFFFFFF : 0
ENDFOR

_mm_cmpgt_epi8#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128i
Param Types:: __m128i a, __m128i b
Param ETypes:: SI8 a, SI8 b

__m128i _mm_cmpgt_epi8(__m128i a, __m128i b);

Intel Description

Compare packed signed 8-bit integers in “a” and “b” for greater-than, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*8
        dst[i+7:i] := ( a[i+7:i] > b[i+7:i] ) ? 0xFF : 0
ENDFOR

_mm_cmpgt_epi16#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128i
Param Types:: __m128i a, __m128i b
Param ETypes:: SI16 a, SI16 b

__m128i _mm_cmpgt_epi16(__m128i a, __m128i b);

Intel Description

Compare packed signed 16-bit integers in “a” and “b” for greater-than, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*16
        dst[i+15:i] := ( a[i+15:i] > b[i+15:i] ) ? 0xFFFF : 0
ENDFOR

_mm_cmpgt_epi32#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128i
Param Types:: __m128i a, __m128i b
Param ETypes:: SI32 a, SI32 b

__m128i _mm_cmpgt_epi32(__m128i a, __m128i b);

Intel Description

Compare packed signed 32-bit integers in “a” and “b” for greater-than, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 3
        i := j*32
        dst[i+31:i] := ( a[i+31:i] > b[i+31:i] ) ? 0xFFFFFFFF : 0
ENDFOR

_mm_cmplt_epi8#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128i
Param Types:: __m128i a, __m128i b
Param ETypes:: SI8 a, SI8 b

__m128i _mm_cmplt_epi8(__m128i a, __m128i b);

Intel Description

Compare packed signed 8-bit integers in “a” and “b” for less-than, and store the results in “dst”. Note: This intrinsic emits the pcmpgtb instruction with the order of the operands switched.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*8
        dst[i+7:i] := ( a[i+7:i] < b[i+7:i] ) ? 0xFF : 0
ENDFOR

_mm_cmplt_epi16#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128i
Param Types:: __m128i a, __m128i b
Param ETypes:: SI16 a, SI16 b

__m128i _mm_cmplt_epi16(__m128i a, __m128i b);

Intel Description

Compare packed signed 16-bit integers in “a” and “b” for less-than, and store the results in “dst”. Note: This intrinsic emits the pcmpgtw instruction with the order of the operands switched.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*16
        dst[i+15:i] := ( a[i+15:i] < b[i+15:i] ) ? 0xFFFF : 0
ENDFOR

_mm_cmplt_epi32#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128i
Param Types:: __m128i a, __m128i b
Param ETypes:: SI32 a, SI32 b

__m128i _mm_cmplt_epi32(__m128i a, __m128i b);

Intel Description

Compare packed signed 32-bit integers in “a” and “b” for less-than, and store the results in “dst”. Note: This intrinsic emits the pcmpgtd instruction with the order of the operands switched.

Intel Implementation Psudeo-Code

FOR j := 0 to 3
        i := j*32
        dst[i+31:i] := ( a[i+31:i] < b[i+31:i] ) ? 0xFFFFFFFF : 0
ENDFOR

_mm_cmpeq_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpeq_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point elements in “a” and “b” for equality, store the result in the lower element of “dst”, and copy the upper element from “a” to the upper element of “dst”.

Intel Implementation Psudeo-Code

dst[63:0] := (a[63:0] == b[63:0]) ? 0xFFFFFFFFFFFFFFFF : 0
dst[127:64] := a[127:64]

_mm_cmplt_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmplt_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point elements in “a” and “b” for less-than, store the result in the lower element of “dst”, and copy the upper element from “a” to the upper element of “dst”.

Intel Implementation Psudeo-Code

dst[63:0] := (a[63:0] < b[63:0]) ? 0xFFFFFFFFFFFFFFFF : 0
dst[127:64] := a[127:64]

_mm_cmple_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmple_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point elements in “a” and “b” for less-than-or-equal, store the result in the lower element of “dst”, and copy the upper element from “a” to the upper element of “dst”.

Intel Implementation Psudeo-Code

dst[63:0] := (a[63:0] <= b[63:0]) ? 0xFFFFFFFFFFFFFFFF : 0
dst[127:64] := a[127:64]

_mm_cmpgt_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpgt_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point elements in “a” and “b” for greater-than, store the result in the lower element of “dst”, and copy the upper element from “a” to the upper element of “dst”.

Intel Implementation Psudeo-Code

dst[63:0] := (a[63:0] > b[63:0]) ? 0xFFFFFFFFFFFFFFFF : 0
dst[127:64] := a[127:64]

_mm_cmpge_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpge_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point elements in “a” and “b” for greater-than-or-equal, store the result in the lower element of “dst”, and copy the upper element from “a” to the upper element of “dst”.

Intel Implementation Psudeo-Code

dst[63:0] := (a[63:0] >= b[63:0]) ? 0xFFFFFFFFFFFFFFFF : 0
dst[127:64] := a[127:64]

_mm_cmpord_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpord_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point elements in “a” and “b” to see if neither is NaN, store the result in the lower element of “dst”, and copy the upper element from “a” to the upper element of “dst”.

Intel Implementation Psudeo-Code

dst[63:0] := (a[63:0] != NaN AND b[63:0] != NaN) ? 0xFFFFFFFFFFFFFFFF : 0
dst[127:64] := a[127:64]

_mm_cmpunord_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpunord_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point elements in “a” and “b” to see if either is NaN, store the result in the lower element of “dst”, and copy the upper element from “a” to the upper element of “dst”.

Intel Implementation Psudeo-Code

dst[63:0] := (a[63:0] == NaN OR b[63:0] == NaN) ? 0xFFFFFFFFFFFFFFFF : 0
dst[127:64] := a[127:64]

_mm_cmpneq_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpneq_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point elements in “a” and “b” for not-equal, store the result in the lower element of “dst”, and copy the upper element from “a” to the upper element of “dst”.

Intel Implementation Psudeo-Code

dst[63:0] := (a[63:0] != b[63:0]) ? 0xFFFFFFFFFFFFFFFF : 0
dst[127:64] := a[127:64]

_mm_cmpnlt_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpnlt_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point elements in “a” and “b” for not-less-than, store the result in the lower element of “dst”, and copy the upper element from “a” to the upper element of “dst”.

Intel Implementation Psudeo-Code

dst[63:0] := (!(a[63:0] < b[63:0])) ? 0xFFFFFFFFFFFFFFFF : 0
dst[127:64] := a[127:64]

_mm_cmpnle_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpnle_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point elements in “a” and “b” for not-less-than-or-equal, store the result in the lower element of “dst”, and copy the upper element from “a” to the upper element of “dst”.

Intel Implementation Psudeo-Code

dst[63:0] := (!(a[63:0] <= b[63:0])) ? 0xFFFFFFFFFFFFFFFF : 0
dst[127:64] := a[127:64]

_mm_cmpngt_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpngt_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point elements in “a” and “b” for not-greater-than, store the result in the lower element of “dst”, and copy the upper element from “a” to the upper element of “dst”.

Intel Implementation Psudeo-Code

dst[63:0] := (!(a[63:0] > b[63:0])) ? 0xFFFFFFFFFFFFFFFF : 0
dst[127:64] := a[127:64]

_mm_cmpnge_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpnge_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point elements in “a” and “b” for not-greater-than-or-equal, store the result in the lower element of “dst”, and copy the upper element from “a” to the upper element of “dst”.

Intel Implementation Psudeo-Code

dst[63:0] := (!(a[63:0] >= b[63:0])) ? 0xFFFFFFFFFFFFFFFF : 0
dst[127:64] := a[127:64]

_mm_cmpeq_pd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpeq_pd(__m128d a, __m128d b);

Intel Description

Compare packed double-precision (64-bit) floating-point elements in “a” and “b” for equality, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 1
        i := j*64
        dst[i+63:i] := (a[i+63:i] == b[i+63:i]) ? 0xFFFFFFFFFFFFFFFF : 0
ENDFOR

_mm_cmplt_pd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmplt_pd(__m128d a, __m128d b);

Intel Description

Compare packed double-precision (64-bit) floating-point elements in “a” and “b” for less-than, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 1
        i := j*64
        dst[i+63:i] := (a[i+63:i] < b[i+63:i]) ? 0xFFFFFFFFFFFFFFFF : 0
ENDFOR

_mm_cmple_pd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmple_pd(__m128d a, __m128d b);

Intel Description

Compare packed double-precision (64-bit) floating-point elements in “a” and “b” for less-than-or-equal, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 1
        i := j*64
        dst[i+63:i] := (a[i+63:i] <= b[i+63:i]) ? 0xFFFFFFFFFFFFFFFF : 0
ENDFOR

_mm_cmpgt_pd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpgt_pd(__m128d a, __m128d b);

Intel Description

Compare packed double-precision (64-bit) floating-point elements in “a” and “b” for greater-than, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 1
        i := j*64
        dst[i+63:i] := (a[i+63:i] > b[i+63:i]) ? 0xFFFFFFFFFFFFFFFF : 0
ENDFOR

_mm_cmpge_pd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpge_pd(__m128d a, __m128d b);

Intel Description

Compare packed double-precision (64-bit) floating-point elements in “a” and “b” for greater-than-or-equal, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 1
        i := j*64
        dst[i+63:i] := (a[i+63:i] >= b[i+63:i]) ? 0xFFFFFFFFFFFFFFFF : 0
ENDFOR

_mm_cmpord_pd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpord_pd(__m128d a, __m128d b);

Intel Description

Compare packed double-precision (64-bit) floating-point elements in “a” and “b” to see if neither is NaN, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 1
        i := j*64
        dst[i+63:i] := (a[i+63:i] != NaN AND b[i+63:i] != NaN) ? 0xFFFFFFFFFFFFFFFF : 0
ENDFOR

_mm_cmpunord_pd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpunord_pd(__m128d a, __m128d b);

Intel Description

Compare packed double-precision (64-bit) floating-point elements in “a” and “b” to see if either is NaN, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 1
        i := j*64
        dst[i+63:i] := (a[i+63:i] == NaN OR b[i+63:i] == NaN) ? 0xFFFFFFFFFFFFFFFF : 0
ENDFOR

_mm_cmpneq_pd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpneq_pd(__m128d a, __m128d b);

Intel Description

Compare packed double-precision (64-bit) floating-point elements in “a” and “b” for not-equal, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 1
        i := j*64
        dst[i+63:i] := (a[i+63:i] != b[i+63:i]) ? 0xFFFFFFFFFFFFFFFF : 0
ENDFOR

_mm_cmpnlt_pd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpnlt_pd(__m128d a, __m128d b);

Intel Description

Compare packed double-precision (64-bit) floating-point elements in “a” and “b” for not-less-than, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 1
        i := j*64
        dst[i+63:i] := (!(a[i+63:i] < b[i+63:i])) ? 0xFFFFFFFFFFFFFFFF : 0
ENDFOR

_mm_cmpnle_pd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpnle_pd(__m128d a, __m128d b);

Intel Description

Compare packed double-precision (64-bit) floating-point elements in “a” and “b” for not-less-than-or-equal, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 1
        i := j*64
        dst[i+63:i] := (!(a[i+63:i] <= b[i+63:i])) ? 0xFFFFFFFFFFFFFFFF : 0
ENDFOR

_mm_cmpngt_pd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpngt_pd(__m128d a, __m128d b);

Intel Description

Compare packed double-precision (64-bit) floating-point elements in “a” and “b” for not-greater-than, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 1
        i := j*64
        dst[i+63:i] := (!(a[i+63:i] > b[i+63:i])) ? 0xFFFFFFFFFFFFFFFF : 0
ENDFOR

_mm_cmpnge_pd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128d
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

__m128d _mm_cmpnge_pd(__m128d a, __m128d b);

Intel Description

Compare packed double-precision (64-bit) floating-point elements in “a” and “b” for not-greater-than-or-equal, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 1
        i := j*64
        dst[i+63:i] := (!(a[i+63:i] >= b[i+63:i])) ? 0xFFFFFFFFFFFFFFFF : 0
ENDFOR

_mm_comieq_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

int _mm_comieq_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point element in “a” and “b” for equality, and return the boolean result (0 or 1).

Intel Implementation Psudeo-Code

RETURN ( a[63:0] != NaN AND b[63:0] != NaN AND a[63:0] == b[63:0] ) ? 1 : 0

_mm_comilt_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

int _mm_comilt_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point element in “a” and “b” for less-than, and return the boolean result (0 or 1).

Intel Implementation Psudeo-Code

RETURN ( a[63:0] != NaN AND b[63:0] != NaN AND a[63:0] < b[63:0] ) ? 1 : 0

_mm_comile_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

int _mm_comile_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point element in “a” and “b” for less-than-or-equal, and return the boolean result (0 or 1).

Intel Implementation Psudeo-Code

RETURN ( a[63:0] != NaN AND b[63:0] != NaN AND a[63:0] <= b[63:0] ) ? 1 : 0

_mm_comigt_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

int _mm_comigt_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point element in “a” and “b” for greater-than, and return the boolean result (0 or 1).

Intel Implementation Psudeo-Code

RETURN ( a[63:0] != NaN AND b[63:0] != NaN AND a[63:0] > b[63:0] ) ? 1 : 0

_mm_comige_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

int _mm_comige_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point element in “a” and “b” for greater-than-or-equal, and return the boolean result (0 or 1).

Intel Implementation Psudeo-Code

RETURN ( a[63:0] != NaN AND b[63:0] != NaN AND a[63:0] >= b[63:0] ) ? 1 : 0

_mm_comineq_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

int _mm_comineq_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point element in “a” and “b” for not-equal, and return the boolean result (0 or 1).

Intel Implementation Psudeo-Code

RETURN ( a[63:0] == NaN OR b[63:0] == NaN OR a[63:0] != b[63:0] ) ? 1 : 0

_mm_ucomieq_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

int _mm_ucomieq_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point element in “a” and “b” for equality, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.

Intel Implementation Psudeo-Code

RETURN ( a[63:0] != NaN AND b[63:0] != NaN AND a[63:0] == b[63:0] ) ? 1 : 0

_mm_ucomilt_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

int _mm_ucomilt_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point element in “a” and “b” for less-than, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.

Intel Implementation Psudeo-Code

RETURN ( a[63:0] != NaN AND b[63:0] != NaN AND a[63:0] < b[63:0] ) ? 1 : 0

_mm_ucomile_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

int _mm_ucomile_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point element in “a” and “b” for less-than-or-equal, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.

Intel Implementation Psudeo-Code

RETURN ( a[63:0] != NaN AND b[63:0] != NaN AND a[63:0] <= b[63:0] ) ? 1 : 0

_mm_ucomigt_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

int _mm_ucomigt_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point element in “a” and “b” for greater-than, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.

Intel Implementation Psudeo-Code

RETURN ( a[63:0] != NaN AND b[63:0] != NaN AND a[63:0] > b[63:0] ) ? 1 : 0

_mm_ucomige_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

int _mm_ucomige_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point element in “a” and “b” for greater-than-or-equal, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.

Intel Implementation Psudeo-Code

RETURN ( a[63:0] != NaN AND b[63:0] != NaN AND a[63:0] >= b[63:0] ) ? 1 : 0

_mm_ucomineq_sd#

Tech:: SSE_ALL
Category:: Compare
Header:: emmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: int
Param Types:: __m128d a, __m128d b
Param ETypes:: FP64 a, FP64 b

int _mm_ucomineq_sd(__m128d a, __m128d b);

Intel Description

Compare the lower double-precision (64-bit) floating-point element in “a” and “b” for not-equal, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.

Intel Implementation Psudeo-Code

RETURN ( a[63:0] == NaN OR b[63:0] == NaN OR a[63:0] != b[63:0] ) ? 1 : 0

_mm_cmpeq_epi64#

Tech:: SSE_ALL
Category:: Compare
Header:: smmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128i
Param Types:: __m128i a, __m128i b
Param ETypes:: UI64 a, UI64 b

__m128i _mm_cmpeq_epi64(__m128i a, __m128i b);

Intel Description

Compare packed 64-bit integers in “a” and “b” for equality, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 1
        i := j*64
        dst[i+63:i] := ( a[i+63:i] == b[i+63:i] ) ? 0xFFFFFFFFFFFFFFFF : 0
ENDFOR

_mm_cmpgt_epi64#

Tech:: SSE_ALL
Category:: Compare
Header:: nmmintrin.h
Searchable:: SSE_ALL-Compare-XMM
Register:: XMM 128 bit
Return Type:: __m128i
Param Types:: __m128i a, __m128i b
Param ETypes:: SI64 a, SI64 b

__m128i _mm_cmpgt_epi64(__m128i a, __m128i b);

Intel Description

Compare packed signed 64-bit integers in “a” and “b” for greater-than, and store the results in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 1
        i := j*64
        dst[i+63:i] := ( a[i+63:i] > b[i+63:i] ) ? 0xFFFFFFFFFFFFFFFF : 0
ENDFOR

SSE_ALL-Compare-XMM

Contents

SSE_ALL-Compare-XMM#

_mm_cmpeq_ss#

_mm_cmpeq_ps#

_mm_cmplt_ss#

_mm_cmplt_ps#

_mm_cmple_ss#

_mm_cmple_ps#

_mm_cmpgt_ss#

_mm_cmpgt_ps#

_mm_cmpge_ss#

_mm_cmpge_ps#

_mm_cmpneq_ss#

_mm_cmpneq_ps#

_mm_cmpnlt_ss#

_mm_cmpnlt_ps#

_mm_cmpnle_ss#

_mm_cmpnle_ps#

_mm_cmpngt_ss#

_mm_cmpngt_ps#

_mm_cmpnge_ss#

_mm_cmpnge_ps#

_mm_cmpord_ss#

_mm_cmpord_ps#

_mm_cmpunord_ss#

_mm_cmpunord_ps#

_mm_comieq_ss#

_mm_comilt_ss#

_mm_comile_ss#

_mm_comigt_ss#

_mm_comige_ss#

_mm_comineq_ss#

_mm_ucomieq_ss#

_mm_ucomilt_ss#

_mm_ucomile_ss#

_mm_ucomigt_ss#

_mm_ucomige_ss#

_mm_ucomineq_ss#

_mm_cmpeq_epi8#

_mm_cmpeq_epi16#

_mm_cmpeq_epi32#

_mm_cmpgt_epi8#

_mm_cmpgt_epi16#

_mm_cmpgt_epi32#

_mm_cmplt_epi8#

_mm_cmplt_epi16#

_mm_cmplt_epi32#

_mm_cmpeq_sd#

_mm_cmplt_sd#

_mm_cmple_sd#

_mm_cmpgt_sd#

_mm_cmpge_sd#

_mm_cmpord_sd#

_mm_cmpunord_sd#

_mm_cmpneq_sd#

_mm_cmpnlt_sd#

_mm_cmpnle_sd#

_mm_cmpngt_sd#

_mm_cmpnge_sd#

_mm_cmpeq_pd#

_mm_cmplt_pd#

_mm_cmple_pd#

_mm_cmpgt_pd#

_mm_cmpge_pd#

_mm_cmpord_pd#

_mm_cmpunord_pd#

_mm_cmpneq_pd#

_mm_cmpnlt_pd#

_mm_cmpnle_pd#

_mm_cmpngt_pd#

_mm_cmpnge_pd#

_mm_comieq_sd#

_mm_comilt_sd#

_mm_comile_sd#

_mm_comigt_sd#

_mm_comige_sd#

_mm_comineq_sd#

_mm_ucomieq_sd#

_mm_ucomilt_sd#