AVX-512-Compare-ZMM

AVX-512-Compare-ZMM#

_mm512_cmp_epi8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __m512i a, __m512i b, const int imm8
Param ETypes:: SI8 a, SI8 b, IMM imm8

__mmask64 _mm512_cmp_epi8_mask(__m512i a, __m512i b,
                               const int imm8)

Intel Description

Compare packed signed 8-bit integers in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

CASE (imm8[2:0]) OF
0: OP := _MM_CMPINT_EQ
1: OP := _MM_CMPINT_LT
2: OP := _MM_CMPINT_LE
3: OP := _MM_CMPINT_FALSE
4: OP := _MM_CMPINT_NE
5: OP := _MM_CMPINT_NLT
6: OP := _MM_CMPINT_NLE
7: OP := _MM_CMPINT_TRUE
ESAC
FOR j := 0 to 63
        i := j*8
        k[j] := ( a[i+7:i] OP b[i+7:i] ) ? 1 : 0
ENDFOR
k[MAX:64] := 0

_mm512_cmpeq_epi8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __m512i a, __m512i b
Param ETypes:: SI8 a, SI8 b

__mmask64 _mm512_cmpeq_epi8_mask(__m512i a, __m512i b);

Intel Description

Compare packed signed 8-bit integers in “a” and “b” for equality, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        k[j] := ( a[i+7:i] == b[i+7:i] ) ? 1 : 0
ENDFOR
k[MAX:64] := 0

_mm512_cmpge_epi8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __m512i a, __m512i b
Param ETypes:: SI8 a, SI8 b

__mmask64 _mm512_cmpge_epi8_mask(__m512i a, __m512i b);

Intel Description

Compare packed signed 8-bit integers in “a” and “b” for greater-than-or-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        k[j] := ( a[i+7:i] >= b[i+7:i] ) ? 1 : 0
ENDFOR
k[MAX:64] := 0

_mm512_cmpgt_epi8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __m512i a, __m512i b
Param ETypes:: SI8 a, SI8 b

__mmask64 _mm512_cmpgt_epi8_mask(__m512i a, __m512i b);

Intel Description

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

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        k[j] := ( a[i+7:i] > b[i+7:i] ) ? 1 : 0
ENDFOR
k[MAX:64] := 0

_mm512_cmple_epi8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __m512i a, __m512i b
Param ETypes:: SI8 a, SI8 b

__mmask64 _mm512_cmple_epi8_mask(__m512i a, __m512i b);

Intel Description

Compare packed signed 8-bit integers in “a” and “b” for less-than-or-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        k[j] := ( a[i+7:i] <= b[i+7:i] ) ? 1 : 0
ENDFOR
k[MAX:64] := 0

_mm512_cmplt_epi8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __m512i a, __m512i b
Param ETypes:: SI8 a, SI8 b

__mmask64 _mm512_cmplt_epi8_mask(__m512i a, __m512i b);

Intel Description

Compare packed signed 8-bit integers in “a” and “b” for less-than, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        k[j] := ( a[i+7:i] < b[i+7:i] ) ? 1 : 0
ENDFOR
k[MAX:64] := 0

_mm512_cmpneq_epi8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __m512i a, __m512i b
Param ETypes:: SI8 a, SI8 b

__mmask64 _mm512_cmpneq_epi8_mask(__m512i a, __m512i b);

Intel Description

Compare packed signed 8-bit integers in “a” and “b” for not-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        k[j] := ( a[i+7:i] != b[i+7:i] ) ? 1 : 0
ENDFOR
k[MAX:64] := 0

_mm512_mask_cmp_epi8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __mmask64 k1, __m512i a, __m512i b, const int imm8
Param ETypes:: MASK k1, SI8 a, SI8 b, IMM imm8

__mmask64 _mm512_mask_cmp_epi8_mask(__mmask64 k1, __m512i a,
                                    __m512i b,
                                    const int imm8)

Intel Description

Compare packed signed 8-bit integers in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

CASE (imm8[2:0]) OF
0: OP := _MM_CMPINT_EQ
1: OP := _MM_CMPINT_LT
2: OP := _MM_CMPINT_LE
3: OP := _MM_CMPINT_FALSE
4: OP := _MM_CMPINT_NE
5: OP := _MM_CMPINT_NLT
6: OP := _MM_CMPINT_NLE
7: OP := _MM_CMPINT_TRUE
ESAC
FOR j := 0 to 63
        i := j*8
        IF k1[j]
                k[j] := ( a[i+7:i] OP b[i+7:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:64] := 0

_mm512_mask_cmpeq_epi8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __mmask64 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI8 a, SI8 b

__mmask64 _mm512_mask_cmpeq_epi8_mask(__mmask64 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed signed 8-bit integers in “a” and “b” for equality, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        IF k1[j]
                k[j] := ( a[i+7:i] == b[i+7:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:64] := 0

_mm512_mask_cmpge_epi8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __mmask64 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI8 a, SI8 b

__mmask64 _mm512_mask_cmpge_epi8_mask(__mmask64 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed signed 8-bit integers in “a” and “b” for greater-than-or-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        IF k1[j]
                k[j] := ( a[i+7:i] >= b[i+7:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:64] := 0

_mm512_mask_cmpgt_epi8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __mmask64 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI8 a, SI8 b

__mmask64 _mm512_mask_cmpgt_epi8_mask(__mmask64 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed signed 8-bit integers in “a” and “b” for greater-than, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        IF k1[j]
                k[j] := ( a[i+7:i] > b[i+7:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:64] := 0

_mm512_mask_cmple_epi8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __mmask64 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI8 a, SI8 b

__mmask64 _mm512_mask_cmple_epi8_mask(__mmask64 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed signed 8-bit integers in “a” and “b” for less-than-or-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        IF k1[j]
                k[j] := ( a[i+7:i] <= b[i+7:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:64] := 0

_mm512_mask_cmplt_epi8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __mmask64 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI8 a, SI8 b

__mmask64 _mm512_mask_cmplt_epi8_mask(__mmask64 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed signed 8-bit integers in “a” and “b” for less-than, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        IF k1[j]
                k[j] := ( a[i+7:i] < b[i+7:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:64] := 0

_mm512_mask_cmpneq_epi8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __mmask64 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI8 a, SI8 b

__mmask64 _mm512_mask_cmpneq_epi8_mask(__mmask64 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed signed 8-bit integers in “a” and “b” for not-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        IF k1[j]
                k[j] := ( a[i+7:i] != b[i+7:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:64] := 0

_mm512_cmp_epu8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __m512i a, __m512i b, const int imm8
Param ETypes:: UI8 a, UI8 b, IMM imm8

__mmask64 _mm512_cmp_epu8_mask(__m512i a, __m512i b,
                               const int imm8)

Intel Description

Compare packed unsigned 8-bit integers in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

CASE (imm8[2:0]) OF
0: OP := _MM_CMPINT_EQ
1: OP := _MM_CMPINT_LT
2: OP := _MM_CMPINT_LE
3: OP := _MM_CMPINT_FALSE
4: OP := _MM_CMPINT_NE
5: OP := _MM_CMPINT_NLT
6: OP := _MM_CMPINT_NLE
7: OP := _MM_CMPINT_TRUE
ESAC
FOR j := 0 to 63
        i := j*8
        k[j] := ( a[i+7:i] OP b[i+7:i] ) ? 1 : 0
ENDFOR
k[MAX:64] := 0

_mm512_cmpeq_epu8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __m512i a, __m512i b
Param ETypes:: UI8 a, UI8 b

__mmask64 _mm512_cmpeq_epu8_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 8-bit integers in “a” and “b” for equality, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        k[j] := ( a[i+7:i] == b[i+7:i] ) ? 1 : 0
ENDFOR
k[MAX:64] := 0

_mm512_cmpge_epu8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __m512i a, __m512i b
Param ETypes:: UI8 a, UI8 b

__mmask64 _mm512_cmpge_epu8_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 8-bit integers in “a” and “b” for greater-than-or-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        k[j] := ( a[i+7:i] >= b[i+7:i] ) ? 1 : 0
ENDFOR
k[MAX:64] := 0

_mm512_cmpgt_epu8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __m512i a, __m512i b
Param ETypes:: UI8 a, UI8 b

__mmask64 _mm512_cmpgt_epu8_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 8-bit integers in “a” and “b” for greater-than, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        k[j] := ( a[i+7:i] > b[i+7:i] ) ? 1 : 0
ENDFOR
k[MAX:64] := 0

_mm512_cmple_epu8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __m512i a, __m512i b
Param ETypes:: UI8 a, UI8 b

__mmask64 _mm512_cmple_epu8_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 8-bit integers in “a” and “b” for less-than-or-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        k[j] := ( a[i+7:i] <= b[i+7:i] ) ? 1 : 0
ENDFOR
k[MAX:64] := 0

_mm512_cmplt_epu8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __m512i a, __m512i b
Param ETypes:: UI8 a, UI8 b

__mmask64 _mm512_cmplt_epu8_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 8-bit integers in “a” and “b” for less-than, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        k[j] := ( a[i+7:i] < b[i+7:i] ) ? 1 : 0
ENDFOR
k[MAX:64] := 0

_mm512_cmpneq_epu8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __m512i a, __m512i b
Param ETypes:: UI8 a, UI8 b

__mmask64 _mm512_cmpneq_epu8_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 8-bit integers in “a” and “b” for not-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        k[j] := ( a[i+7:i] != b[i+7:i] ) ? 1 : 0
ENDFOR
k[MAX:64] := 0

_mm512_mask_cmp_epu8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __mmask64 k1, __m512i a, __m512i b, const int imm8
Param ETypes:: MASK k1, UI8 a, UI8 b, IMM imm8

__mmask64 _mm512_mask_cmp_epu8_mask(__mmask64 k1, __m512i a,
                                    __m512i b,
                                    const int imm8)

Intel Description

Compare packed unsigned 8-bit integers in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

CASE (imm8[2:0]) OF
0: OP := _MM_CMPINT_EQ
1: OP := _MM_CMPINT_LT
2: OP := _MM_CMPINT_LE
3: OP := _MM_CMPINT_FALSE
4: OP := _MM_CMPINT_NE
5: OP := _MM_CMPINT_NLT
6: OP := _MM_CMPINT_NLE
7: OP := _MM_CMPINT_TRUE
ESAC
FOR j := 0 to 63
        i := j*8
        IF k1[j]
                k[j] := ( a[i+7:i] OP b[i+7:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:64] := 0

_mm512_mask_cmpeq_epu8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __mmask64 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI8 a, UI8 b

__mmask64 _mm512_mask_cmpeq_epu8_mask(__mmask64 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed unsigned 8-bit integers in “a” and “b” for equality, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        IF k1[j]
                k[j] := ( a[i+7:i] == b[i+7:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:64] := 0

_mm512_mask_cmpge_epu8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __mmask64 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI8 a, UI8 b

__mmask64 _mm512_mask_cmpge_epu8_mask(__mmask64 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed unsigned 8-bit integers in “a” and “b” for greater-than-or-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        IF k1[j]
                k[j] := ( a[i+7:i] >= b[i+7:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:64] := 0

_mm512_mask_cmpgt_epu8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __mmask64 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI8 a, UI8 b

__mmask64 _mm512_mask_cmpgt_epu8_mask(__mmask64 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed unsigned 8-bit integers in “a” and “b” for greater-than, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        IF k1[j]
                k[j] := ( a[i+7:i] > b[i+7:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:64] := 0

_mm512_mask_cmple_epu8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __mmask64 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI8 a, UI8 b

__mmask64 _mm512_mask_cmple_epu8_mask(__mmask64 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed unsigned 8-bit integers in “a” and “b” for less-than-or-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        IF k1[j]
                k[j] := ( a[i+7:i] <= b[i+7:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:64] := 0

_mm512_mask_cmplt_epu8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __mmask64 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI8 a, UI8 b

__mmask64 _mm512_mask_cmplt_epu8_mask(__mmask64 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed unsigned 8-bit integers in “a” and “b” for less-than, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        IF k1[j]
                k[j] := ( a[i+7:i] < b[i+7:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:64] := 0

_mm512_mask_cmpneq_epu8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __mmask64 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI8 a, UI8 b

__mmask64 _mm512_mask_cmpneq_epu8_mask(__mmask64 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed unsigned 8-bit integers in “a” and “b” for not-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        IF k1[j]
                k[j] := ( a[i+7:i] != b[i+7:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:64] := 0

_mm512_cmp_epu16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __m512i a, __m512i b, const int imm8
Param ETypes:: UI16 a, UI16 b, IMM imm8

__mmask32 _mm512_cmp_epu16_mask(__m512i a, __m512i b,
                                const int imm8)

Intel Description

Compare packed unsigned 16-bit integers in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

CASE (imm8[2:0]) OF
0: OP := _MM_CMPINT_EQ
1: OP := _MM_CMPINT_LT
2: OP := _MM_CMPINT_LE
3: OP := _MM_CMPINT_FALSE
4: OP := _MM_CMPINT_NE
5: OP := _MM_CMPINT_NLT
6: OP := _MM_CMPINT_NLE
7: OP := _MM_CMPINT_TRUE
ESAC
FOR j := 0 to 31
        i := j*16
        k[j] := ( a[i+15:i] OP b[i+15:i] ) ? 1 : 0
ENDFOR
k[MAX:32] := 0

_mm512_cmpeq_epu16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __m512i a, __m512i b
Param ETypes:: UI16 a, UI16 b

__mmask32 _mm512_cmpeq_epu16_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 16-bit integers in “a” and “b” for equality, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        k[j] := ( a[i+15:i] == b[i+15:i] ) ? 1 : 0
ENDFOR
k[MAX:32] := 0

_mm512_cmpge_epu16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __m512i a, __m512i b
Param ETypes:: UI16 a, UI16 b

__mmask32 _mm512_cmpge_epu16_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 16-bit integers in “a” and “b” for greater-than-or-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        k[j] := ( a[i+15:i] >= b[i+15:i] ) ? 1 : 0
ENDFOR
k[MAX:32] := 0

_mm512_cmpgt_epu16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __m512i a, __m512i b
Param ETypes:: UI16 a, UI16 b

__mmask32 _mm512_cmpgt_epu16_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 16-bit integers in “a” and “b” for greater-than, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        k[j] := ( a[i+15:i] > b[i+15:i] ) ? 1 : 0
ENDFOR
k[MAX:32] := 0

_mm512_cmple_epu16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __m512i a, __m512i b
Param ETypes:: UI16 a, UI16 b

__mmask32 _mm512_cmple_epu16_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 16-bit integers in “a” and “b” for less-than-or-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        k[j] := ( a[i+15:i] <= b[i+15:i] ) ? 1 : 0
ENDFOR
k[MAX:32] := 0

_mm512_cmplt_epu16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __m512i a, __m512i b
Param ETypes:: UI16 a, UI16 b

__mmask32 _mm512_cmplt_epu16_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 16-bit integers in “a” and “b” for less-than, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        k[j] := ( a[i+15:i] < b[i+15:i] ) ? 1 : 0
ENDFOR
k[MAX:32] := 0

_mm512_cmpneq_epu16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __m512i a, __m512i b
Param ETypes:: UI16 a, UI16 b

__mmask32 _mm512_cmpneq_epu16_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 16-bit integers in “a” and “b” for not-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        k[j] := ( a[i+15:i] != b[i+15:i] ) ? 1 : 0
ENDFOR
k[MAX:32] := 0

_mm512_mask_cmp_epu16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __mmask32 k1, __m512i a, __m512i b, const int imm8
Param ETypes:: MASK k1, UI16 a, UI16 b, IMM imm8

__mmask32 _mm512_mask_cmp_epu16_mask(__mmask32 k1,
                                     __m512i a, __m512i b,
                                     const int imm8)

Intel Description

Compare packed unsigned 16-bit integers in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

CASE (imm8[2:0]) OF
0: OP := _MM_CMPINT_EQ
1: OP := _MM_CMPINT_LT
2: OP := _MM_CMPINT_LE
3: OP := _MM_CMPINT_FALSE
4: OP := _MM_CMPINT_NE
5: OP := _MM_CMPINT_NLT
6: OP := _MM_CMPINT_NLE
7: OP := _MM_CMPINT_TRUE
ESAC
FOR j := 0 to 31
        i := j*16
        IF k1[j]
                k[j] := ( a[i+15:i] OP b[i+15:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:32] := 0

_mm512_mask_cmpeq_epu16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __mmask32 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI16 a, UI16 b

__mmask32 _mm512_mask_cmpeq_epu16_mask(__mmask32 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed unsigned 16-bit integers in “a” and “b” for equality, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        IF k1[j]
                k[j] := ( a[i+15:i] == b[i+15:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:32] := 0

_mm512_mask_cmpge_epu16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __mmask32 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI16 a, UI16 b

__mmask32 _mm512_mask_cmpge_epu16_mask(__mmask32 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed unsigned 16-bit integers in “a” and “b” for greater-than-or-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        IF k1[j]
                k[j] := ( a[i+15:i] >= b[i+15:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:32] := 0

_mm512_mask_cmpgt_epu16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __mmask32 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI16 a, UI16 b

__mmask32 _mm512_mask_cmpgt_epu16_mask(__mmask32 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed unsigned 16-bit integers in “a” and “b” for greater-than, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        IF k1[j]
                k[j] := ( a[i+15:i] > b[i+15:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:32] := 0

_mm512_mask_cmple_epu16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __mmask32 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI16 a, UI16 b

__mmask32 _mm512_mask_cmple_epu16_mask(__mmask32 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed unsigned 16-bit integers in “a” and “b” for less-than-or-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        IF k1[j]
                k[j] := ( a[i+15:i] <= b[i+15:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:32] := 0

_mm512_mask_cmplt_epu16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __mmask32 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI16 a, UI16 b

__mmask32 _mm512_mask_cmplt_epu16_mask(__mmask32 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed unsigned 16-bit integers in “a” and “b” for less-than, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        IF k1[j]
                k[j] := ( a[i+15:i] < b[i+15:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:32] := 0

_mm512_mask_cmpneq_epu16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __mmask32 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI16 a, UI16 b

__mmask32 _mm512_mask_cmpneq_epu16_mask(__mmask32 k1,
                                        __m512i a,
                                        __m512i b)

Intel Description

Compare packed unsigned 16-bit integers in “a” and “b” for not-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        IF k1[j]
                k[j] := ( a[i+15:i] != b[i+15:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:32] := 0

_mm512_cmp_epi16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __m512i a, __m512i b, const int imm8
Param ETypes:: SI16 a, SI16 b, IMM imm8

__mmask32 _mm512_cmp_epi16_mask(__m512i a, __m512i b,
                                const int imm8)

Intel Description

Compare packed signed 16-bit integers in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

CASE (imm8[2:0]) OF
0: OP := _MM_CMPINT_EQ
1: OP := _MM_CMPINT_LT
2: OP := _MM_CMPINT_LE
3: OP := _MM_CMPINT_FALSE
4: OP := _MM_CMPINT_NE
5: OP := _MM_CMPINT_NLT
6: OP := _MM_CMPINT_NLE
7: OP := _MM_CMPINT_TRUE
ESAC
FOR j := 0 to 31
        i := j*16
        k[j] := ( a[i+15:i] OP b[i+15:i] ) ? 1 : 0
ENDFOR
k[MAX:32] := 0

_mm512_cmpeq_epi16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __m512i a, __m512i b
Param ETypes:: SI16 a, SI16 b

__mmask32 _mm512_cmpeq_epi16_mask(__m512i a, __m512i b);

Intel Description

Compare packed signed 16-bit integers in “a” and “b” for equality, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        k[j] := ( a[i+15:i] == b[i+15:i] ) ? 1 : 0
ENDFOR
k[MAX:32] := 0

_mm512_cmpge_epi16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __m512i a, __m512i b
Param ETypes:: SI16 a, SI16 b

__mmask32 _mm512_cmpge_epi16_mask(__m512i a, __m512i b);

Intel Description

Compare packed signed 16-bit integers in “a” and “b” for greater-than-or-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        k[j] := ( a[i+15:i] >= b[i+15:i] ) ? 1 : 0
ENDFOR
k[MAX:32] := 0

_mm512_cmpgt_epi16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __m512i a, __m512i b
Param ETypes:: SI16 a, SI16 b

__mmask32 _mm512_cmpgt_epi16_mask(__m512i a, __m512i b);

Intel Description

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

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        k[j] := ( a[i+15:i] > b[i+15:i] ) ? 1 : 0
ENDFOR
k[MAX:32] := 0

_mm512_cmple_epi16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __m512i a, __m512i b
Param ETypes:: SI16 a, SI16 b

__mmask32 _mm512_cmple_epi16_mask(__m512i a, __m512i b);

Intel Description

Compare packed signed 16-bit integers in “a” and “b” for less-than-or-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        k[j] := ( a[i+15:i] <= b[i+15:i] ) ? 1 : 0
ENDFOR
k[MAX:32] := 0

_mm512_cmplt_epi16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __m512i a, __m512i b
Param ETypes:: SI16 a, SI16 b

__mmask32 _mm512_cmplt_epi16_mask(__m512i a, __m512i b);

Intel Description

Compare packed signed 16-bit integers in “a” and “b” for less-than, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        k[j] := ( a[i+15:i] < b[i+15:i] ) ? 1 : 0
ENDFOR
k[MAX:32] := 0

_mm512_cmpneq_epi16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __m512i a, __m512i b
Param ETypes:: SI16 a, SI16 b

__mmask32 _mm512_cmpneq_epi16_mask(__m512i a, __m512i b);

Intel Description

Compare packed signed 16-bit integers in “a” and “b” for not-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        k[j] := ( a[i+15:i] != b[i+15:i] ) ? 1 : 0
ENDFOR
k[MAX:32] := 0

_mm512_mask_cmp_epi16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __mmask32 k1, __m512i a, __m512i b, const int imm8
Param ETypes:: MASK k1, SI16 a, SI16 b, IMM imm8

__mmask32 _mm512_mask_cmp_epi16_mask(__mmask32 k1,
                                     __m512i a, __m512i b,
                                     const int imm8)

Intel Description

Compare packed signed 16-bit integers in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

CASE (imm8[2:0]) OF
0: OP := _MM_CMPINT_EQ
1: OP := _MM_CMPINT_LT
2: OP := _MM_CMPINT_LE
3: OP := _MM_CMPINT_FALSE
4: OP := _MM_CMPINT_NE
5: OP := _MM_CMPINT_NLT
6: OP := _MM_CMPINT_NLE
7: OP := _MM_CMPINT_TRUE
ESAC
FOR j := 0 to 31
        i := j*16
        IF k1[j]
                k[j] := ( a[i+15:i] OP b[i+15:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:32] := 0

_mm512_mask_cmpeq_epi16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __mmask32 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI16 a, SI16 b

__mmask32 _mm512_mask_cmpeq_epi16_mask(__mmask32 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed signed 16-bit integers in “a” and “b” for equality, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        IF k1[j]
                k[j] := ( a[i+15:i] == b[i+15:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:32] := 0

_mm512_mask_cmpge_epi16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __mmask32 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI16 a, SI16 b

__mmask32 _mm512_mask_cmpge_epi16_mask(__mmask32 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed signed 16-bit integers in “a” and “b” for greater-than-or-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        IF k1[j]
                k[j] := ( a[i+15:i] >= b[i+15:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:32] := 0

_mm512_mask_cmpgt_epi16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __mmask32 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI16 a, SI16 b

__mmask32 _mm512_mask_cmpgt_epi16_mask(__mmask32 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed signed 16-bit integers in “a” and “b” for greater-than, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        IF k1[j]
                k[j] := ( a[i+15:i] > b[i+15:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:32] := 0

_mm512_mask_cmple_epi16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __mmask32 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI16 a, SI16 b

__mmask32 _mm512_mask_cmple_epi16_mask(__mmask32 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed signed 16-bit integers in “a” and “b” for less-than-or-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        IF k1[j]
                k[j] := ( a[i+15:i] <= b[i+15:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:32] := 0

_mm512_mask_cmplt_epi16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __mmask32 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI16 a, SI16 b

__mmask32 _mm512_mask_cmplt_epi16_mask(__mmask32 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed signed 16-bit integers in “a” and “b” for less-than, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        IF k1[j]
                k[j] := ( a[i+15:i] < b[i+15:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:32] := 0

_mm512_mask_cmpneq_epi16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __mmask32 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI16 a, SI16 b

__mmask32 _mm512_mask_cmpneq_epi16_mask(__mmask32 k1,
                                        __m512i a,
                                        __m512i b)

Intel Description

Compare packed signed 16-bit integers in “a” and “b” for not-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        IF k1[j]
                k[j] := ( a[i+15:i] != b[i+15:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:32] := 0

_mm512_mask_test_epi8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __mmask64 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI8 a, UI8 b

__mmask64 _mm512_mask_test_epi8_mask(__mmask64 k1,
                                     __m512i a, __m512i b)

Intel Description

Compute the bitwise AND of packed 8-bit integers in “a” and “b”, producing intermediate 8-bit values, and set the corresponding bit in result mask “k” (subject to writemask “k”) if the intermediate value is non-zero.

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        IF k1[j]
                k[j] := ((a[i+7:i] AND b[i+7:i]) != 0) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:64] := 0

_mm512_test_epi8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __m512i a, __m512i b
Param ETypes:: UI8 a, UI8 b

__mmask64 _mm512_test_epi8_mask(__m512i a, __m512i b);

Intel Description

Compute the bitwise AND of packed 8-bit integers in “a” and “b”, producing intermediate 8-bit values, and set the corresponding bit in result mask “k” if the intermediate value is non-zero.

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        k[j] := ((a[i+7:i] AND b[i+7:i]) != 0) ? 1 : 0
ENDFOR
k[MAX:64] := 0

_mm512_mask_test_epi16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __mmask32 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI16 a, UI16 b

__mmask32 _mm512_mask_test_epi16_mask(__mmask32 k1,
                                      __m512i a, __m512i b)

Intel Description

Compute the bitwise AND of packed 16-bit integers in “a” and “b”, producing intermediate 16-bit values, and set the corresponding bit in result mask “k” (subject to writemask “k”) if the intermediate value is non-zero.

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        IF k1[j]
                k[j] := ((a[i+15:i] AND b[i+15:i]) != 0) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:32] := 0

_mm512_test_epi16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __m512i a, __m512i b
Param ETypes:: UI16 a, UI16 b

__mmask32 _mm512_test_epi16_mask(__m512i a, __m512i b);

Intel Description

Compute the bitwise AND of packed 16-bit integers in “a” and “b”, producing intermediate 16-bit values, and set the corresponding bit in result mask “k” if the intermediate value is non-zero.

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        k[j] := ((a[i+15:i] AND b[i+15:i]) != 0) ? 1 : 0
ENDFOR
k[MAX:32] := 0

_mm512_mask_testn_epi8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __mmask64 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI8 a, UI8 b

__mmask64 _mm512_mask_testn_epi8_mask(__mmask64 k1,
                                      __m512i a, __m512i b)

Intel Description

Compute the bitwise NAND of packed 8-bit integers in “a” and “b”, producing intermediate 8-bit values, and set the corresponding bit in result mask “k” (subject to writemask “k”) if the intermediate value is zero.

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        IF k1[j]
                k[j] := ((a[i+7:i] AND b[i+7:i]) == 0) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:64] := 0

_mm512_testn_epi8_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask64
Param Types:: __m512i a, __m512i b
Param ETypes:: UI8 a, UI8 b

__mmask64 _mm512_testn_epi8_mask(__m512i a, __m512i b);

Intel Description

Compute the bitwise NAND of packed 8-bit integers in “a” and “b”, producing intermediate 8-bit values, and set the corresponding bit in result mask “k” if the intermediate value is zero.

Intel Implementation Psudeo-Code

FOR j := 0 to 63
        i := j*8
        k[j] := ((a[i+7:i] AND b[i+7:i]) == 0) ? 1 : 0
ENDFOR
k[MAX:64] := 0

_mm512_mask_testn_epi16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __mmask32 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI16 a, UI16 b

__mmask32 _mm512_mask_testn_epi16_mask(__mmask32 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compute the bitwise NAND of packed 16-bit integers in “a” and “b”, producing intermediate 16-bit values, and set the corresponding bit in result mask “k” (subject to writemask “k”) if the intermediate value is zero.

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        IF k1[j]
                k[j] := ((a[i+15:i] AND b[i+15:i]) == 0) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:32] := 0

_mm512_testn_epi16_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __m512i a, __m512i b
Param ETypes:: UI16 a, UI16 b

__mmask32 _mm512_testn_epi16_mask(__m512i a, __m512i b);

Intel Description

Compute the bitwise NAND of packed 16-bit integers in “a” and “b”, producing intermediate 16-bit values, and set the corresponding bit in result mask “k” if the intermediate value is zero.

Intel Implementation Psudeo-Code

FOR j := 0 to 31
        i := j*16
        k[j] := ((a[i+15:i] AND b[i+15:i]) == 0) ? 1 : 0
ENDFOR
k[MAX:32] := 0

_mm512_conflict_epi32#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __m512i
Param Types:: __m512i a
Param ETypes:: UI32 a

__m512i _mm512_conflict_epi32(__m512i a);

Intel Description

Test each 32-bit element of “a” for equality with all other elements in “a” closer to the least significant bit. Each element’s comparison forms a zero extended bit vector in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        FOR k := 0 to j-1
                m := k*32
                dst[i+k] := (a[i+31:i] == a[m+31:m]) ? 1 : 0
        ENDFOR
        dst[i+31:i+j] := 0
ENDFOR
dst[MAX:512] := 0

_mm512_mask_conflict_epi32#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __m512i
Param Types:: __m512i src, __mmask16 k, __m512i a
Param ETypes:: UI32 src, MASK k, UI32 a

__m512i _mm512_mask_conflict_epi32(__m512i src, __mmask16 k,
                                   __m512i a)

Intel Description

Test each 32-bit element of “a” for equality with all other elements in “a” closer to the least significant bit using writemask “k” (elements are copied from “src” when the corresponding mask bit is not set). Each element’s comparison forms a zero extended bit vector in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k[j]
                FOR l := 0 to j-1
                        m := l*32
                        dst[i+l] := (a[i+31:i] == a[m+31:m]) ? 1 : 0
                ENDFOR
                dst[i+31:i+j] := 0
        ELSE
                dst[i+31:i] := src[i+31:i]
        FI
ENDFOR
dst[MAX:512] := 0

_mm512_maskz_conflict_epi32#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __m512i
Param Types:: __mmask16 k, __m512i a
Param ETypes:: MASK k, UI32 a

__m512i _mm512_maskz_conflict_epi32(__mmask16 k, __m512i a);

Intel Description

Test each 32-bit element of “a” for equality with all other elements in “a” closer to the least significant bit using zeromask “k” (elements are zeroed out when the corresponding mask bit is not set). Each element’s comparison forms a zero extended bit vector in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k[j]
                FOR l := 0 to j-1
                        m := l*32
                        dst[i+l] := (a[i+31:i] == a[m+31:m]) ? 1 : 0
                ENDFOR
                dst[i+31:i+j] := 0
        ELSE
                dst[i+31:i] := 0
        FI
ENDFOR
dst[MAX:512] := 0

_mm512_conflict_epi64#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __m512i
Param Types:: __m512i a
Param ETypes:: UI64 a

__m512i _mm512_conflict_epi64(__m512i a);

Intel Description

Test each 64-bit element of “a” for equality with all other elements in “a” closer to the least significant bit. Each element’s comparison forms a zero extended bit vector in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        FOR k := 0 to j-1
                m := k*64
                dst[i+k] := (a[i+63:i] == a[m+63:m]) ? 1 : 0
        ENDFOR
        dst[i+63:i+j] := 0
ENDFOR
dst[MAX:512] := 0

_mm512_mask_conflict_epi64#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __m512i
Param Types:: __m512i src, __mmask8 k, __m512i a
Param ETypes:: UI64 src, MASK k, UI64 a

__m512i _mm512_mask_conflict_epi64(__m512i src, __mmask8 k,
                                   __m512i a)

Intel Description

Test each 64-bit element of “a” for equality with all other elements in “a” closer to the least significant bit using writemask “k” (elements are copied from “src” when the corresponding mask bit is not set). Each element’s comparison forms a zero extended bit vector in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k[j]
                FOR l := 0 to j-1
                        m := l*64
                        dst[i+l] := (a[i+63:i] == a[m+63:m]) ? 1 : 0
                ENDFOR
                dst[i+63:i+j] := 0
        ELSE
                dst[i+63:i] := src[i+63:i]
        FI
ENDFOR
dst[MAX:512] := 0

_mm512_maskz_conflict_epi64#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __m512i
Param Types:: __mmask8 k, __m512i a
Param ETypes:: MASK k, UI64 a

__m512i _mm512_maskz_conflict_epi64(__mmask8 k, __m512i a);

Intel Description

Test each 64-bit element of “a” for equality with all other elements in “a” closer to the least significant bit using zeromask “k” (elements are zeroed out when the corresponding mask bit is not set). Each element’s comparison forms a zero extended bit vector in “dst”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k[j]
                FOR l := 0 to j-1
                        m := l*64
                        dst[i+l] := (a[i+63:i] == a[m+63:m]) ? 1 : 0
                ENDFOR
                dst[i+63:i+j] := 0
        ELSE
                dst[i+63:i] := 0
        FI
ENDFOR
dst[MAX:512] := 0

_mm512_cmplt_epi32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512i a, __m512i b
Param ETypes:: SI32 a, SI32 b

__mmask16 _mm512_cmplt_epi32_mask(__m512i a, __m512i b);

Intel Description

Compare packed signed 32-bit integers in “a” and “b” for less-than, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := ( a[i+31:i] < b[i+31:i] ) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmplt_epi32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI32 a, SI32 b

__mmask16 _mm512_mask_cmplt_epi32_mask(__mmask16 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed signed 32-bit integers in “a” and “b” for less-than-or-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := ( a[i+31:i] < b[i+31:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_cmp_epi64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512i a, __m512i b, _MM_CMPINT_ENUM imm8
Param ETypes:: SI64 a, SI64 b, IMM imm8

__mmask8 _mm512_cmp_epi64_mask(__m512i a, __m512i b,
                               _MM_CMPINT_ENUM imm8)

Intel Description

Compare packed signed 64-bit integers in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

CASE (imm8[2:0]) OF
0: OP := _MM_CMPINT_EQ
1: OP := _MM_CMPINT_LT
2: OP := _MM_CMPINT_LE
3: OP := _MM_CMPINT_FALSE
4: OP := _MM_CMPINT_NE
5: OP := _MM_CMPINT_NLT
6: OP := _MM_CMPINT_NLE
7: OP := _MM_CMPINT_TRUE
ESAC
FOR j := 0 to 7
        i := j*64
        k[j] := ( a[i+63:i] OP b[i+63:i] ) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmpeq_epi64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512i a, __m512i b
Param ETypes:: UI64 a, UI64 b

__mmask8 _mm512_cmpeq_epi64_mask(__m512i a, __m512i b);

Intel Description

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

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := ( a[i+63:i] == b[i+63:i] ) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmpge_epi64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512i a, __m512i b
Param ETypes:: SI64 a, SI64 b

__mmask8 _mm512_cmpge_epi64_mask(__m512i a, __m512i b);

Intel Description

Compare packed signed 64-bit integers in “a” and “b” for greater-than-or-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := ( a[i+63:i] >= b[i+63:i] ) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmpgt_epi64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512i a, __m512i b
Param ETypes:: SI64 a, SI64 b

__mmask8 _mm512_cmpgt_epi64_mask(__m512i a, __m512i b);

Intel Description

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

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := ( a[i+63:i] > b[i+63:i] ) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmple_epi64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512i a, __m512i b
Param ETypes:: SI64 a, SI64 b

__mmask8 _mm512_cmple_epi64_mask(__m512i a, __m512i b);

Intel Description

Compare packed signed 64-bit integers in “a” and “b” for less-than-or-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := ( a[i+63:i] <= b[i+63:i] ) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmplt_epi64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512i a, __m512i b
Param ETypes:: SI64 a, SI64 b

__mmask8 _mm512_cmplt_epi64_mask(__m512i a, __m512i b);

Intel Description

Compare packed signed 64-bit integers in “a” and “b” for less-than, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := ( a[i+63:i] < b[i+63:i] ) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmpneq_epi64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512i a, __m512i b
Param ETypes:: SI64 a, SI64 b

__mmask8 _mm512_cmpneq_epi64_mask(__m512i a, __m512i b);

Intel Description

Compare packed signed 64-bit integers in “a” and “b” for not-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := ( a[i+63:i] != b[i+63:i] ) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmp_epi64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512i a, __m512i b, _MM_CMPINT_ENUM imm8
Param ETypes:: MASK k1, SI64 a, SI64 b, IMM imm8

__mmask8 _mm512_mask_cmp_epi64_mask(__mmask8 k1, __m512i a,
                                    __m512i b,
                                    _MM_CMPINT_ENUM imm8)

Intel Description

Compare packed signed 64-bit integers in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

CASE (imm8[2:0]) OF
0: OP := _MM_CMPINT_EQ
1: OP := _MM_CMPINT_LT
2: OP := _MM_CMPINT_LE
3: OP := _MM_CMPINT_FALSE
4: OP := _MM_CMPINT_NE
5: OP := _MM_CMPINT_NLT
6: OP := _MM_CMPINT_NLE
7: OP := _MM_CMPINT_TRUE
ESAC
FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := ( a[i+63:i] OP b[i+63:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmpeq_epi64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI64 a, UI64 b

__mmask8 _mm512_mask_cmpeq_epi64_mask(__mmask8 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed 64-bit integers in “a” and “b” for equality, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := ( a[i+63:i] == b[i+63:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmpge_epi64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI64 a, SI64 b

__mmask8 _mm512_mask_cmpge_epi64_mask(__mmask8 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed signed 64-bit integers in “a” and “b” for greater-than-or-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := ( a[i+63:i] >= b[i+63:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmpgt_epi64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI64 a, SI64 b

__mmask8 _mm512_mask_cmpgt_epi64_mask(__mmask8 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed signed 64-bit integers in “a” and “b” for greater-than, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := ( a[i+63:i] > b[i+63:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmple_epi64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI64 a, SI64 b

__mmask8 _mm512_mask_cmple_epi64_mask(__mmask8 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed signed 64-bit integers in “a” and “b” for less-than-or-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := ( a[i+63:i] <= b[i+63:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmplt_epi64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI64 a, SI64 b

__mmask8 _mm512_mask_cmplt_epi64_mask(__mmask8 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed signed 64-bit integers in “a” and “b” for less-than, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := ( a[i+63:i] < b[i+63:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmpneq_epi64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI64 a, SI64 b

__mmask8 _mm512_mask_cmpneq_epi64_mask(__mmask8 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed signed 64-bit integers in “a” and “b” for not-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := ( a[i+63:i] != b[i+63:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_cmp_epu64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512i a, __m512i b, _MM_CMPINT_ENUM imm8
Param ETypes:: UI64 a, UI64 b, IMM imm8

__mmask8 _mm512_cmp_epu64_mask(__m512i a, __m512i b,
                               _MM_CMPINT_ENUM imm8)

Intel Description

Compare packed unsigned 64-bit integers in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

CASE (imm8[2:0]) OF
0: OP := _MM_CMPINT_EQ
1: OP := _MM_CMPINT_LT
2: OP := _MM_CMPINT_LE
3: OP := _MM_CMPINT_FALSE
4: OP := _MM_CMPINT_NE
5: OP := _MM_CMPINT_NLT
6: OP := _MM_CMPINT_NLE
7: OP := _MM_CMPINT_TRUE
ESAC
FOR j := 0 to 7
        i := j*64
        k[j] := ( a[i+63:i] OP b[i+63:i] ) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmpeq_epu64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512i a, __m512i b
Param ETypes:: UI64 a, UI64 b

__mmask8 _mm512_cmpeq_epu64_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 64-bit integers in “a” and “b” for equality, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := ( a[i+63:i] == b[i+63:i] ) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmpge_epu64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512i a, __m512i b
Param ETypes:: UI64 a, UI64 b

__mmask8 _mm512_cmpge_epu64_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 64-bit integers in “a” and “b” for greater-than-or-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := ( a[i+63:i] >= b[i+63:i] ) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmpgt_epu64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512i a, __m512i b
Param ETypes:: UI64 a, UI64 b

__mmask8 _mm512_cmpgt_epu64_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 64-bit integers in “a” and “b” for greater-than, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := ( a[i+63:i] > b[i+63:i] ) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmple_epu64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512i a, __m512i b
Param ETypes:: UI64 a, UI64 b

__mmask8 _mm512_cmple_epu64_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 64-bit integers in “a” and “b” for less-than-or-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := ( a[i+63:i] <= b[i+63:i] ) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmplt_epu64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512i a, __m512i b
Param ETypes:: UI64 a, UI64 b

__mmask8 _mm512_cmplt_epu64_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 64-bit integers in “a” and “b” for less-than, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := ( a[i+63:i] < b[i+63:i] ) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmpneq_epu64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512i a, __m512i b
Param ETypes:: UI64 a, UI64 b

__mmask8 _mm512_cmpneq_epu64_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 64-bit integers in “a” and “b” for not-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := ( a[i+63:i] != b[i+63:i] ) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmp_epu64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512i a, __m512i b, _MM_CMPINT_ENUM imm8
Param ETypes:: MASK k1, UI64 a, UI64 b, IMM imm8

__mmask8 _mm512_mask_cmp_epu64_mask(__mmask8 k1, __m512i a,
                                    __m512i b,
                                    _MM_CMPINT_ENUM imm8)

Intel Description

Compare packed unsigned 64-bit integers in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

CASE (imm8[2:0]) OF
0: OP := _MM_CMPINT_EQ
1: OP := _MM_CMPINT_LT
2: OP := _MM_CMPINT_LE
3: OP := _MM_CMPINT_FALSE
4: OP := _MM_CMPINT_NE
5: OP := _MM_CMPINT_NLT
6: OP := _MM_CMPINT_NLE
7: OP := _MM_CMPINT_TRUE
ESAC
FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := ( a[i+63:i] OP b[i+63:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmpeq_epu64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI64 a, UI64 b

__mmask8 _mm512_mask_cmpeq_epu64_mask(__mmask8 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed unsigned 64-bit integers in “a” and “b” for equality, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := ( a[i+63:i] == b[i+63:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmpge_epu64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI64 a, UI64 b

__mmask8 _mm512_mask_cmpge_epu64_mask(__mmask8 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed unsigned 64-bit integers in “a” and “b” for greater-than-or-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := ( a[i+63:i] >= b[i+63:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmpgt_epu64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI64 a, UI64 b

__mmask8 _mm512_mask_cmpgt_epu64_mask(__mmask8 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed unsigned 64-bit integers in “a” and “b” for greater-than, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := ( a[i+63:i] > b[i+63:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmple_epu64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI64 a, UI64 b

__mmask8 _mm512_mask_cmple_epu64_mask(__mmask8 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed unsigned 64-bit integers in “a” and “b” for less-than-or-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := ( a[i+63:i] <= b[i+63:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmplt_epu64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI64 a, UI64 b

__mmask8 _mm512_mask_cmplt_epu64_mask(__mmask8 k1,
                                      __m512i a, __m512i b)

Intel Description

Compare packed unsigned 64-bit integers in “a” and “b” for less-than, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := ( a[i+63:i] < b[i+63:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmpneq_epu64_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI64 a, UI64 b

__mmask8 _mm512_mask_cmpneq_epu64_mask(__mmask8 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed unsigned 64-bit integers in “a” and “b” for not-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := ( a[i+63:i] != b[i+63:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_cmp_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512d a, __m512d b, const int imm8
Param ETypes:: FP64 a, FP64 b, IMM imm8

__mmask8 _mm512_cmp_pd_mask(__m512d a, __m512d b,
                            const int imm8)

Intel Description

Compare packed double-precision (64-bit) floating-point elements in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

CASE (imm8[4:0]) OF
OP := _CMP_EQ_OQ
OP := _CMP_LT_OS
OP := _CMP_LE_OS
OP := _CMP_UNORD_Q
OP := _CMP_NEQ_UQ
OP := _CMP_NLT_US
OP := _CMP_NLE_US
OP := _CMP_ORD_Q
OP := _CMP_EQ_UQ
OP := _CMP_NGE_US
OP := _CMP_NGT_US
OP := _CMP_FALSE_OQ
OP := _CMP_NEQ_OQ
OP := _CMP_GE_OS
OP := _CMP_GT_OS
OP := _CMP_TRUE_UQ
OP := _CMP_EQ_OS
OP := _CMP_LT_OQ
OP := _CMP_LE_OQ
OP := _CMP_UNORD_S
OP := _CMP_NEQ_US
OP := _CMP_NLT_UQ
OP := _CMP_NLE_UQ
OP := _CMP_ORD_S
OP := _CMP_EQ_US
OP := _CMP_NGE_UQ
OP := _CMP_NGT_UQ
OP := _CMP_FALSE_OS
OP := _CMP_NEQ_OS
OP := _CMP_GE_OQ
OP := _CMP_GT_OQ
OP := _CMP_TRUE_US
ESAC
FOR j := 0 to 7
        i := j*64
        k[j] := (a[i+63:i] OP b[i+63:i]) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmp_round_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512d a, __m512d b, const int imm8, const int sae
Param ETypes:: FP64 a, FP64 b, IMM imm8, IMM sae

__mmask8 _mm512_cmp_round_pd_mask(__m512d a, __m512d b,
                                  const int imm8,
                                  const int sae)

Intel Description

Compare packed double-precision (64-bit) floating-point elements in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k”. [sae_note]

Intel Implementation Psudeo-Code

CASE (imm8[4:0]) OF
OP := _CMP_EQ_OQ
OP := _CMP_LT_OS
OP := _CMP_LE_OS
OP := _CMP_UNORD_Q
OP := _CMP_NEQ_UQ
OP := _CMP_NLT_US
OP := _CMP_NLE_US
OP := _CMP_ORD_Q
OP := _CMP_EQ_UQ
OP := _CMP_NGE_US
OP := _CMP_NGT_US
OP := _CMP_FALSE_OQ
OP := _CMP_NEQ_OQ
OP := _CMP_GE_OS
OP := _CMP_GT_OS
OP := _CMP_TRUE_UQ
OP := _CMP_EQ_OS
OP := _CMP_LT_OQ
OP := _CMP_LE_OQ
OP := _CMP_UNORD_S
OP := _CMP_NEQ_US
OP := _CMP_NLT_UQ
OP := _CMP_NLE_UQ
OP := _CMP_ORD_S
OP := _CMP_EQ_US
OP := _CMP_NGE_UQ
OP := _CMP_NGT_UQ
OP := _CMP_FALSE_OS
OP := _CMP_NEQ_OS
OP := _CMP_GE_OQ
OP := _CMP_GT_OQ
OP := _CMP_TRUE_US
ESAC
FOR j := 0 to 7
        i := j*64
        k[j] := (a[i+63:i] OP b[i+63:i]) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmpeq_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512d a, __m512d b
Param ETypes:: FP64 a, FP64 b

__mmask8 _mm512_cmpeq_pd_mask(__m512d a, __m512d b);

Intel Description

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

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := (a[i+63:i] == b[i+63:i]) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmple_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512d a, __m512d b
Param ETypes:: FP64 a, FP64 b

__mmask8 _mm512_cmple_pd_mask(__m512d a, __m512d 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 mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := (a[i+63:i] <= b[i+63:i]) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmplt_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512d a, __m512d b
Param ETypes:: FP64 a, FP64 b

__mmask8 _mm512_cmplt_pd_mask(__m512d a, __m512d b);

Intel Description

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

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := (a[i+63:i] < b[i+63:i]) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmpneq_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512d a, __m512d b
Param ETypes:: FP64 a, FP64 b

__mmask8 _mm512_cmpneq_pd_mask(__m512d a, __m512d b);

Intel Description

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

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := (a[i+63:i] != b[i+63:i]) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmpnle_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512d a, __m512d b
Param ETypes:: FP64 a, FP64 b

__mmask8 _mm512_cmpnle_pd_mask(__m512d a, __m512d 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 mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := (!(a[i+63:i] <= b[i+63:i])) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmpnlt_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512d a, __m512d b
Param ETypes:: FP64 a, FP64 b

__mmask8 _mm512_cmpnlt_pd_mask(__m512d a, __m512d 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 mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := (!(a[i+63:i] < b[i+63:i])) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmpord_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512d a, __m512d b
Param ETypes:: FP64 a, FP64 b

__mmask8 _mm512_cmpord_pd_mask(__m512d a, __m512d 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 mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := (a[i+63:i] != NaN AND b[i+63:i] != NaN) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_cmpunord_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __m512d a, __m512d b
Param ETypes:: FP64 a, FP64 b

__mmask8 _mm512_cmpunord_pd_mask(__m512d a, __m512d 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 mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        k[j] := (a[i+63:i] == NaN OR b[i+63:i] == NaN) ? 1 : 0
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmp_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512d a, __m512d b, const int imm8
Param ETypes:: MASK k1, FP64 a, FP64 b, IMM imm8

__mmask8 _mm512_mask_cmp_pd_mask(__mmask8 k1, __m512d a,
                                 __m512d b, const int imm8)

Intel Description

Compare packed double-precision (64-bit) floating-point elements in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

CASE (imm8[4:0]) OF
OP := _CMP_EQ_OQ
OP := _CMP_LT_OS
OP := _CMP_LE_OS
OP := _CMP_UNORD_Q
OP := _CMP_NEQ_UQ
OP := _CMP_NLT_US
OP := _CMP_NLE_US
OP := _CMP_ORD_Q
OP := _CMP_EQ_UQ
OP := _CMP_NGE_US
OP := _CMP_NGT_US
OP := _CMP_FALSE_OQ
OP := _CMP_NEQ_OQ
OP := _CMP_GE_OS
OP := _CMP_GT_OS
OP := _CMP_TRUE_UQ
OP := _CMP_EQ_OS
OP := _CMP_LT_OQ
OP := _CMP_LE_OQ
OP := _CMP_UNORD_S
OP := _CMP_NEQ_US
OP := _CMP_NLT_UQ
OP := _CMP_NLE_UQ
OP := _CMP_ORD_S
OP := _CMP_EQ_US
OP := _CMP_NGE_UQ
OP := _CMP_NGT_UQ
OP := _CMP_FALSE_OS
OP := _CMP_NEQ_OS
OP := _CMP_GE_OQ
OP := _CMP_GT_OQ
OP := _CMP_TRUE_US
ESAC
FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := ( a[i+63:i] OP b[i+63:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmp_round_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512d a, __m512d b, const int imm8, const int sae
Param ETypes:: MASK k1, FP64 a, FP64 b, IMM imm8, IMM sae

__mmask8 _mm512_mask_cmp_round_pd_mask(__mmask8 k1,
                                       __m512d a, __m512d b,
                                       const int imm8,
                                       const int sae)

Intel Description

Intel Implementation Psudeo-Code

CASE (imm8[4:0]) OF
OP := _CMP_EQ_OQ
OP := _CMP_LT_OS
OP := _CMP_LE_OS
OP := _CMP_UNORD_Q
OP := _CMP_NEQ_UQ
OP := _CMP_NLT_US
OP := _CMP_NLE_US
OP := _CMP_ORD_Q
OP := _CMP_EQ_UQ
OP := _CMP_NGE_US
OP := _CMP_NGT_US
OP := _CMP_FALSE_OQ
OP := _CMP_NEQ_OQ
OP := _CMP_GE_OS
OP := _CMP_GT_OS
OP := _CMP_TRUE_UQ
OP := _CMP_EQ_OS
OP := _CMP_LT_OQ
OP := _CMP_LE_OQ
OP := _CMP_UNORD_S
OP := _CMP_NEQ_US
OP := _CMP_NLT_UQ
OP := _CMP_NLE_UQ
OP := _CMP_ORD_S
OP := _CMP_EQ_US
OP := _CMP_NGE_UQ
OP := _CMP_NGT_UQ
OP := _CMP_FALSE_OS
OP := _CMP_NEQ_OS
OP := _CMP_GE_OQ
OP := _CMP_GT_OQ
OP := _CMP_TRUE_US
ESAC
FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := ( a[i+63:i] OP b[i+63:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmpeq_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512d a, __m512d b
Param ETypes:: MASK k1, FP64 a, FP64 b

__mmask8 _mm512_mask_cmpeq_pd_mask(__mmask8 k1, __m512d a,
                                   __m512d b)

Intel Description

Compare packed double-precision (64-bit) floating-point elements in “a” and “b” for equality, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := (a[i+63:i] == b[i+63:i]) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmple_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512d a, __m512d b
Param ETypes:: MASK k1, FP64 a, FP64 b

__mmask8 _mm512_mask_cmple_pd_mask(__mmask8 k1, __m512d a,
                                   __m512d 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 mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := (a[i+63:i] <= b[i+63:i]) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmplt_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512d a, __m512d b
Param ETypes:: MASK k1, FP64 a, FP64 b

__mmask8 _mm512_mask_cmplt_pd_mask(__mmask8 k1, __m512d a,
                                   __m512d b)

Intel Description

Compare packed double-precision (64-bit) floating-point elements in “a” and “b” for less-than, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := (a[i+63:i] < b[i+63:i]) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmpneq_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512d a, __m512d b
Param ETypes:: MASK k1, FP64 a, FP64 b

__mmask8 _mm512_mask_cmpneq_pd_mask(__mmask8 k1, __m512d a,
                                    __m512d b)

Intel Description

Compare packed double-precision (64-bit) floating-point elements in “a” and “b” for not-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := (a[i+63:i] != b[i+63:i]) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmpnle_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512d a, __m512d b
Param ETypes:: MASK k1, FP64 a, FP64 b

__mmask8 _mm512_mask_cmpnle_pd_mask(__mmask8 k1, __m512d a,
                                    __m512d 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 mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := (!(a[i+63:i] <= b[i+63:i])) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmpnlt_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512d a, __m512d b
Param ETypes:: MASK k1, FP64 a, FP64 b

__mmask8 _mm512_mask_cmpnlt_pd_mask(__mmask8 k1, __m512d a,
                                    __m512d 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 mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := (!(a[i+63:i] < b[i+63:i])) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmpord_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512d a, __m512d b
Param ETypes:: MASK k1, FP64 a, FP64 b

__mmask8 _mm512_mask_cmpord_pd_mask(__mmask8 k1, __m512d a,
                                    __m512d 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 mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := (a[i+63:i] != NaN AND b[i+63:i] != NaN) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_mask_cmpunord_pd_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask8
Param Types:: __mmask8 k1, __m512d a, __m512d b
Param ETypes:: MASK k1, FP64 a, FP64 b

__mmask8 _mm512_mask_cmpunord_pd_mask(__mmask8 k1,
                                      __m512d a, __m512d 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 mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 7
        i := j*64
        IF k1[j]
                k[j] := (a[i+63:i] == NaN OR b[i+63:i] == NaN) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:8] := 0

_mm512_cmp_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512 a, __m512 b, const int imm8
Param ETypes:: FP32 a, FP32 b, IMM imm8

__mmask16 _mm512_cmp_ps_mask(__m512 a, __m512 b,
                             const int imm8)

Intel Description

Compare packed single-precision (32-bit) floating-point elements in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

CASE (imm8[4:0]) OF
OP := _CMP_EQ_OQ
OP := _CMP_LT_OS
OP := _CMP_LE_OS
OP := _CMP_UNORD_Q
OP := _CMP_NEQ_UQ
OP := _CMP_NLT_US
OP := _CMP_NLE_US
OP := _CMP_ORD_Q
OP := _CMP_EQ_UQ
OP := _CMP_NGE_US
OP := _CMP_NGT_US
OP := _CMP_FALSE_OQ
OP := _CMP_NEQ_OQ
OP := _CMP_GE_OS
OP := _CMP_GT_OS
OP := _CMP_TRUE_UQ
OP := _CMP_EQ_OS
OP := _CMP_LT_OQ
OP := _CMP_LE_OQ
OP := _CMP_UNORD_S
OP := _CMP_NEQ_US
OP := _CMP_NLT_UQ
OP := _CMP_NLE_UQ
OP := _CMP_ORD_S
OP := _CMP_EQ_US
OP := _CMP_NGE_UQ
OP := _CMP_NGT_UQ
OP := _CMP_FALSE_OS
OP := _CMP_NEQ_OS
OP := _CMP_GE_OQ
OP := _CMP_GT_OQ
OP := _CMP_TRUE_US
ESAC
FOR j := 0 to 15
        i := j*32
        k[j] := (a[i+31:i] OP b[i+31:i]) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmp_round_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512 a, __m512 b, const int imm8, const int sae
Param ETypes:: FP32 a, FP32 b, IMM imm8, IMM sae

__mmask16 _mm512_cmp_round_ps_mask(__m512 a, __m512 b,
                                   const int imm8,
                                   const int sae)

Intel Description

Compare packed single-precision (32-bit) floating-point elements in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k”. [sae_note]

Intel Implementation Psudeo-Code

CASE (imm8[4:0]) OF
OP := _CMP_EQ_OQ
OP := _CMP_LT_OS
OP := _CMP_LE_OS
OP := _CMP_UNORD_Q
OP := _CMP_NEQ_UQ
OP := _CMP_NLT_US
OP := _CMP_NLE_US
OP := _CMP_ORD_Q
OP := _CMP_EQ_UQ
OP := _CMP_NGE_US
OP := _CMP_NGT_US
OP := _CMP_FALSE_OQ
OP := _CMP_NEQ_OQ
OP := _CMP_GE_OS
OP := _CMP_GT_OS
OP := _CMP_TRUE_UQ
OP := _CMP_EQ_OS
OP := _CMP_LT_OQ
OP := _CMP_LE_OQ
OP := _CMP_UNORD_S
OP := _CMP_NEQ_US
OP := _CMP_NLT_UQ
OP := _CMP_NLE_UQ
OP := _CMP_ORD_S
OP := _CMP_EQ_US
OP := _CMP_NGE_UQ
OP := _CMP_NGT_UQ
OP := _CMP_FALSE_OS
OP := _CMP_NEQ_OS
OP := _CMP_GE_OQ
OP := _CMP_GT_OQ
OP := _CMP_TRUE_US
ESAC
FOR j := 0 to 15
        i := j*32
        k[j] := (a[i+31:i] OP b[i+31:i]) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmpeq_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512 a, __m512 b
Param ETypes:: FP32 a, FP32 b

__mmask16 _mm512_cmpeq_ps_mask(__m512 a, __m512 b);

Intel Description

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

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := (a[i+31:i] == b[i+31:i]) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmple_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512 a, __m512 b
Param ETypes:: FP32 a, FP32 b

__mmask16 _mm512_cmple_ps_mask(__m512 a, __m512 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 mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := (a[i+31:i] <= b[i+31:i]) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmplt_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512 a, __m512 b
Param ETypes:: FP32 a, FP32 b

__mmask16 _mm512_cmplt_ps_mask(__m512 a, __m512 b);

Intel Description

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

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := (a[i+31:i] < b[i+31:i]) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmpneq_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512 a, __m512 b
Param ETypes:: FP32 a, FP32 b

__mmask16 _mm512_cmpneq_ps_mask(__m512 a, __m512 b);

Intel Description

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

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := (a[i+31:i] != b[i+31:i]) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmpnle_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512 a, __m512 b
Param ETypes:: FP32 a, FP32 b

__mmask16 _mm512_cmpnle_ps_mask(__m512 a, __m512 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 mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := (!(a[i+31:i] <= b[i+31:i])) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmpnlt_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512 a, __m512 b
Param ETypes:: FP32 a, FP32 b

__mmask16 _mm512_cmpnlt_ps_mask(__m512 a, __m512 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 mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := (!(a[i+31:i] < b[i+31:i])) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmpord_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512 a, __m512 b
Param ETypes:: FP32 a, FP32 b

__mmask16 _mm512_cmpord_ps_mask(__m512 a, __m512 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 mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := ((a[i+31:i] != NaN) AND (b[i+31:i] != NaN)) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmpunord_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512 a, __m512 b
Param ETypes:: FP32 a, FP32 b

__mmask16 _mm512_cmpunord_ps_mask(__m512 a, __m512 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 mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := ((a[i+31:i] == NaN) OR (b[i+31:i] == NaN)) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmp_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512 a, __m512 b, const int imm8
Param ETypes:: MASK k1, FP32 a, FP32 b, IMM imm8

__mmask16 _mm512_mask_cmp_ps_mask(__mmask16 k1, __m512 a,
                                  __m512 b, const int imm8)

Intel Description

Compare packed single-precision (32-bit) floating-point elements in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

CASE (imm8[4:0]) OF
OP := _CMP_EQ_OQ
OP := _CMP_LT_OS
OP := _CMP_LE_OS
OP := _CMP_UNORD_Q
OP := _CMP_NEQ_UQ
OP := _CMP_NLT_US
OP := _CMP_NLE_US
OP := _CMP_ORD_Q
OP := _CMP_EQ_UQ
OP := _CMP_NGE_US
OP := _CMP_NGT_US
OP := _CMP_FALSE_OQ
OP := _CMP_NEQ_OQ
OP := _CMP_GE_OS
OP := _CMP_GT_OS
OP := _CMP_TRUE_UQ
OP := _CMP_EQ_OS
OP := _CMP_LT_OQ
OP := _CMP_LE_OQ
OP := _CMP_UNORD_S
OP := _CMP_NEQ_US
OP := _CMP_NLT_UQ
OP := _CMP_NLE_UQ
OP := _CMP_ORD_S
OP := _CMP_EQ_US
OP := _CMP_NGE_UQ
OP := _CMP_NGT_UQ
OP := _CMP_FALSE_OS
OP := _CMP_NEQ_OS
OP := _CMP_GE_OQ
OP := _CMP_GT_OQ
OP := _CMP_TRUE_US
ESAC
FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := ( a[i+31:i] OP b[i+31:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmp_round_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512 a, __m512 b, const int imm8, const int sae
Param ETypes:: MASK k1, FP32 a, FP32 b, IMM imm8, IMM sae

__mmask16 _mm512_mask_cmp_round_ps_mask(__mmask16 k1,
                                        __m512 a, __m512 b,
                                        const int imm8,
                                        const int sae)

Intel Description

Intel Implementation Psudeo-Code

CASE (imm8[4:0]) OF
OP := _CMP_EQ_OQ
OP := _CMP_LT_OS
OP := _CMP_LE_OS
OP := _CMP_UNORD_Q
OP := _CMP_NEQ_UQ
OP := _CMP_NLT_US
OP := _CMP_NLE_US
OP := _CMP_ORD_Q
OP := _CMP_EQ_UQ
OP := _CMP_NGE_US
OP := _CMP_NGT_US
OP := _CMP_FALSE_OQ
OP := _CMP_NEQ_OQ
OP := _CMP_GE_OS
OP := _CMP_GT_OS
OP := _CMP_TRUE_UQ
OP := _CMP_EQ_OS
OP := _CMP_LT_OQ
OP := _CMP_LE_OQ
OP := _CMP_UNORD_S
OP := _CMP_NEQ_US
OP := _CMP_NLT_UQ
OP := _CMP_NLE_UQ
OP := _CMP_ORD_S
OP := _CMP_EQ_US
OP := _CMP_NGE_UQ
OP := _CMP_NGT_UQ
OP := _CMP_FALSE_OS
OP := _CMP_NEQ_OS
OP := _CMP_GE_OQ
OP := _CMP_GT_OQ
OP := _CMP_TRUE_US
ESAC
FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := ( a[i+31:i] OP b[i+31:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmpeq_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512 a, __m512 b
Param ETypes:: MASK k1, FP32 a, FP32 b

__mmask16 _mm512_mask_cmpeq_ps_mask(__mmask16 k1, __m512 a,
                                    __m512 b)

Intel Description

Compare packed single-precision (32-bit) floating-point elements in “a” and “b” for equality, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := (a[i+31:i] == b[i+31:i]) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmple_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512 a, __m512 b
Param ETypes:: MASK k1, FP32 a, FP32 b

__mmask16 _mm512_mask_cmple_ps_mask(__mmask16 k1, __m512 a,
                                    __m512 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 mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := (a[i+31:i] <= b[i+31:i]) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmplt_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512 a, __m512 b
Param ETypes:: MASK k1, FP32 a, FP32 b

__mmask16 _mm512_mask_cmplt_ps_mask(__mmask16 k1, __m512 a,
                                    __m512 b)

Intel Description

Compare packed single-precision (32-bit) floating-point elements in “a” and “b” for less-than, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := (a[i+31:i] < b[i+31:i]) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmpneq_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512 a, __m512 b
Param ETypes:: MASK k1, FP32 a, FP32 b

__mmask16 _mm512_mask_cmpneq_ps_mask(__mmask16 k1, __m512 a,
                                     __m512 b)

Intel Description

Compare packed single-precision (32-bit) floating-point elements in “a” and “b” for not-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := (a[i+31:i] != b[i+31:i]) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmpnle_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512 a, __m512 b
Param ETypes:: MASK k1, FP32 a, FP32 b

__mmask16 _mm512_mask_cmpnle_ps_mask(__mmask16 k1, __m512 a,
                                     __m512 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 mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := (!(a[i+31:i] <= b[i+31:i])) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmpnlt_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512 a, __m512 b
Param ETypes:: MASK k1, FP32 a, FP32 b

__mmask16 _mm512_mask_cmpnlt_ps_mask(__mmask16 k1, __m512 a,
                                     __m512 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 mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := (!(a[i+31:i] < b[i+31:i])) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmpord_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512 a, __m512 b
Param ETypes:: MASK k1, FP32 a, FP32 b

__mmask16 _mm512_mask_cmpord_ps_mask(__mmask16 k1, __m512 a,
                                     __m512 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 mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := ((a[i+31:i] != NaN) AND (b[i+31:i] != NaN)) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmpunord_ps_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512 a, __m512 b
Param ETypes:: MASK k1, FP32 a, FP32 b

__mmask16 _mm512_mask_cmpunord_ps_mask(__mmask16 k1,
                                       __m512 a, __m512 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 mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := ((a[i+31:i] == NaN) OR (b[i+31:i] == NaN)) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_cmp_epi32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512i a, __m512i b, _MM_CMPINT_ENUM imm8
Param ETypes:: SI32 a, SI32 b, IMM imm8

__mmask16 _mm512_cmp_epi32_mask(__m512i a, __m512i b,
                                _MM_CMPINT_ENUM imm8)

Intel Description

Compare packed signed 32-bit integers in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

CASE (imm8[2:0]) OF
0: OP := _MM_CMPINT_EQ
1: OP := _MM_CMPINT_LT
2: OP := _MM_CMPINT_LE
3: OP := _MM_CMPINT_FALSE
4: OP := _MM_CMPINT_NE
5: OP := _MM_CMPINT_NLT
6: OP := _MM_CMPINT_NLE
7: OP := _MM_CMPINT_TRUE
ESAC
FOR j := 0 to 15
        i := j*32
        k[j] := ( a[i+31:i] OP b[i+31:i] ) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmpeq_epi32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512i a, __m512i b
Param ETypes:: UI32 a, UI32 b

__mmask16 _mm512_cmpeq_epi32_mask(__m512i a, __m512i b);

Intel Description

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

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := ( a[i+31:i] == b[i+31:i] ) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmpge_epi32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512i a, __m512i b
Param ETypes:: SI32 a, SI32 b

__mmask16 _mm512_cmpge_epi32_mask(__m512i a, __m512i b);

Intel Description

Compare packed signed 32-bit integers in “a” and “b” for greater-than-or-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := ( a[i+31:i] >= b[i+31:i] ) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmpgt_epi32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512i a, __m512i b
Param ETypes:: SI32 a, SI32 b

__mmask16 _mm512_cmpgt_epi32_mask(__m512i a, __m512i b);

Intel Description

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

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := ( a[i+31:i] > b[i+31:i] ) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmple_epi32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512i a, __m512i b
Param ETypes:: SI32 a, SI32 b

__mmask16 _mm512_cmple_epi32_mask(__m512i a, __m512i b);

Intel Description

Compare packed signed 32-bit integers in “a” and “b” for less-than-or-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := ( a[i+31:i] <= b[i+31:i] ) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmpneq_epi32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512i a, __m512i b
Param ETypes:: UI32 a, UI32 b

__mmask16 _mm512_cmpneq_epi32_mask(__m512i a, __m512i b);

Intel Description

Compare packed 32-bit integers in “a” and “b” for not-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := ( a[i+31:i] != b[i+31:i] ) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmp_epi32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512i a, __m512i b, _MM_CMPINT_ENUM imm8
Param ETypes:: MASK k1, SI32 a, SI32 b, IMM imm8

__mmask16 _mm512_mask_cmp_epi32_mask(__mmask16 k1,
                                     __m512i a, __m512i b,
                                     _MM_CMPINT_ENUM imm8)

Intel Description

Compare packed signed 32-bit integers in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

CASE (imm8[2:0]) OF
0: OP := _MM_CMPINT_EQ
1: OP := _MM_CMPINT_LT
2: OP := _MM_CMPINT_LE
3: OP := _MM_CMPINT_FALSE
4: OP := _MM_CMPINT_NE
5: OP := _MM_CMPINT_NLT
6: OP := _MM_CMPINT_NLE
7: OP := _MM_CMPINT_TRUE
ESAC
FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := ( a[i+31:i] OP b[i+31:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmpeq_epi32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI32 a, UI32 b

__mmask16 _mm512_mask_cmpeq_epi32_mask(__mmask16 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed 32-bit integers in “a” and “b” for equality, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := ( a[i+31:i] == b[i+31:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmpge_epi32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI32 a, SI32 b

__mmask16 _mm512_mask_cmpge_epi32_mask(__mmask16 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed signed 32-bit integers in “a” and “b” for greater-than-or-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := ( a[i+31:i] >= b[i+31:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmpgt_epi32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI32 a, SI32 b

__mmask16 _mm512_mask_cmpgt_epi32_mask(__mmask16 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed signed 32-bit integers in “a” and “b” for greater-than, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := ( a[i+31:i] > b[i+31:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmple_epi32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, SI32 a, SI32 b

__mmask16 _mm512_mask_cmple_epi32_mask(__mmask16 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed signed 32-bit integers in “a” and “b” for less-than, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := ( a[i+31:i] <= b[i+31:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmpneq_epi32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI32 a, UI32 b

__mmask16 _mm512_mask_cmpneq_epi32_mask(__mmask16 k1,
                                        __m512i a,
                                        __m512i b)

Intel Description

Compare packed 32-bit integers in “a” and “b” for not-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := ( a[i+31:i] != b[i+31:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_cmp_epu32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512i a, __m512i b, _MM_CMPINT_ENUM imm8
Param ETypes:: UI32 a, UI32 b, IMM imm8

__mmask16 _mm512_cmp_epu32_mask(__m512i a, __m512i b,
                                _MM_CMPINT_ENUM imm8)

Intel Description

Compare packed unsigned 32-bit integers in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

CASE (imm8[2:0]) OF
0: OP := _MM_CMPINT_EQ
1: OP := _MM_CMPINT_LT
2: OP := _MM_CMPINT_LE
3: OP := _MM_CMPINT_FALSE
4: OP := _MM_CMPINT_NE
5: OP := _MM_CMPINT_NLT
6: OP := _MM_CMPINT_NLE
7: OP := _MM_CMPINT_TRUE
ESAC
FOR j := 0 to 15
        i := j*32
        k[j] := ( a[i+31:i] OP b[i+31:i] ) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmpeq_epu32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512i a, __m512i b
Param ETypes:: UI32 a, UI32 b

__mmask16 _mm512_cmpeq_epu32_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 32-bit integers in “a” and “b” for equality, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := ( a[i+31:i] == b[i+31:i] ) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmpge_epu32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512i a, __m512i b
Param ETypes:: UI32 a, UI32 b

__mmask16 _mm512_cmpge_epu32_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 32-bit integers in “a” and “b” for greater-than-or-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := ( a[i+31:i] >= b[i+31:i] ) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmpgt_epu32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512i a, __m512i b
Param ETypes:: UI32 a, UI32 b

__mmask16 _mm512_cmpgt_epu32_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 32-bit integers in “a” and “b” for greater-than, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := ( a[i+31:i] > b[i+31:i] ) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmple_epu32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512i a, __m512i b
Param ETypes:: UI32 a, UI32 b

__mmask16 _mm512_cmple_epu32_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 32-bit integers in “a” and “b” for less-than-or-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := ( a[i+31:i] <= b[i+31:i] ) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmplt_epu32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512i a, __m512i b
Param ETypes:: UI32 a, UI32 b

__mmask16 _mm512_cmplt_epu32_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 32-bit integers in “a” and “b” for less-than, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := ( a[i+31:i] < b[i+31:i] ) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_cmpneq_epu32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __m512i a, __m512i b
Param ETypes:: UI32 a, UI32 b

__mmask16 _mm512_cmpneq_epu32_mask(__m512i a, __m512i b);

Intel Description

Compare packed unsigned 32-bit integers in “a” and “b” for not-equal, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        k[j] := ( a[i+31:i] != b[i+31:i] ) ? 1 : 0
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmp_epu32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512i a, __m512i b, _MM_CMPINT_ENUM imm8
Param ETypes:: MASK k1, UI32 a, UI32 b, IMM imm8

__mmask16 _mm512_mask_cmp_epu32_mask(__mmask16 k1,
                                     __m512i a, __m512i b,
                                     _MM_CMPINT_ENUM imm8)

Intel Description

Compare packed unsigned 32-bit integers in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

CASE (imm8[2:0]) OF
0: OP := _MM_CMPINT_EQ
1: OP := _MM_CMPINT_LT
2: OP := _MM_CMPINT_LE
3: OP := _MM_CMPINT_FALSE
4: OP := _MM_CMPINT_NE
5: OP := _MM_CMPINT_NLT
6: OP := _MM_CMPINT_NLE
7: OP := _MM_CMPINT_TRUE
ESAC
FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := ( a[i+31:i] OP b[i+31:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmpeq_epu32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI32 a, UI32 b

__mmask16 _mm512_mask_cmpeq_epu32_mask(__mmask16 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed unsigned 32-bit integers in “a” and “b” for equality, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := ( a[i+31:i] == b[i+31:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmpge_epu32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI32 a, UI32 b

__mmask16 _mm512_mask_cmpge_epu32_mask(__mmask16 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed unsigned 32-bit integers in “a” and “b” for greater-than-or-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := ( a[i+31:i] >= b[i+31:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmpgt_epu32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI32 a, UI32 b

__mmask16 _mm512_mask_cmpgt_epu32_mask(__mmask16 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed unsigned 32-bit integers in “a” and “b” for greater-than, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := ( a[i+31:i] > b[i+31:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmple_epu32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI32 a, UI32 b

__mmask16 _mm512_mask_cmple_epu32_mask(__mmask16 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed unsigned 32-bit integers in “a” and “b” for less-than, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := ( a[i+31:i] <= b[i+31:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmplt_epu32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI32 a, UI32 b

__mmask16 _mm512_mask_cmplt_epu32_mask(__mmask16 k1,
                                       __m512i a,
                                       __m512i b)

Intel Description

Compare packed unsigned 32-bit integers in “a” and “b” for less-than-or-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := ( a[i+31:i] < b[i+31:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_mask_cmpneq_epu32_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask16
Param Types:: __mmask16 k1, __m512i a, __m512i b
Param ETypes:: MASK k1, UI32 a, UI32 b

__mmask16 _mm512_mask_cmpneq_epu32_mask(__mmask16 k1,
                                        __m512i a,
                                        __m512i b)

Intel Description

Compare packed unsigned 32-bit integers in “a” and “b” for not-equal, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

FOR j := 0 to 15
        i := j*32
        IF k1[j]
                k[j] := ( a[i+31:i] != b[i+31:i] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:16] := 0

_mm512_cmp_ph_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __m512h a, __m512h b, const int imm8
Param ETypes:: FP16 a, FP16 b, IMM imm8

__mmask32 _mm512_cmp_ph_mask(__m512h a, __m512h b,
                             const int imm8)

Intel Description

Compare packed half-precision (16-bit) floating-point elements in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k”.

Intel Implementation Psudeo-Code

CASE (imm8[4:0]) OF
OP := _CMP_EQ_OQ
OP := _CMP_LT_OS
OP := _CMP_LE_OS
OP := _CMP_UNORD_Q
OP := _CMP_NEQ_UQ
OP := _CMP_NLT_US
OP := _CMP_NLE_US
OP := _CMP_ORD_Q
OP := _CMP_EQ_UQ
OP := _CMP_NGE_US
OP := _CMP_NGT_US
OP := _CMP_FALSE_OQ
OP := _CMP_NEQ_OQ
OP := _CMP_GE_OS
OP := _CMP_GT_OS
OP := _CMP_TRUE_UQ
OP := _CMP_EQ_OS
OP := _CMP_LT_OQ
OP := _CMP_LE_OQ
OP := _CMP_UNORD_S
OP := _CMP_NEQ_US
OP := _CMP_NLT_UQ
OP := _CMP_NLE_UQ
OP := _CMP_ORD_S
OP := _CMP_EQ_US
OP := _CMP_NGE_UQ
OP := _CMP_NGT_UQ
OP := _CMP_FALSE_OS
OP := _CMP_NEQ_OS
OP := _CMP_GE_OQ
OP := _CMP_GT_OQ
OP := _CMP_TRUE_US
ESAC
FOR j := 0 to 31
        k[j] := (a.fp16[j] OP b.fp16[j]) ? 1 : 0
ENDFOR
k[MAX:32] := 0

_mm512_mask_cmp_ph_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __mmask32 k1, __m512h a, __m512h b, const int imm8
Param ETypes:: MASK k1, FP16 a, FP16 b, IMM imm8

__mmask32 _mm512_mask_cmp_ph_mask(__mmask32 k1, __m512h a,
                                  __m512h b,
                                  const int imm8)

Intel Description

Compare packed half-precision (16-bit) floating-point elements in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k” using zeromask “k1” (elements are zeroed out when the corresponding mask bit is not set).

Intel Implementation Psudeo-Code

CASE (imm8[4:0]) OF
OP := _CMP_EQ_OQ
OP := _CMP_LT_OS
OP := _CMP_LE_OS
OP := _CMP_UNORD_Q
OP := _CMP_NEQ_UQ
OP := _CMP_NLT_US
OP := _CMP_NLE_US
OP := _CMP_ORD_Q
OP := _CMP_EQ_UQ
OP := _CMP_NGE_US
OP := _CMP_NGT_US
OP := _CMP_FALSE_OQ
OP := _CMP_NEQ_OQ
OP := _CMP_GE_OS
OP := _CMP_GT_OS
OP := _CMP_TRUE_UQ
OP := _CMP_EQ_OS
OP := _CMP_LT_OQ
OP := _CMP_LE_OQ
OP := _CMP_UNORD_S
OP := _CMP_NEQ_US
OP := _CMP_NLT_UQ
OP := _CMP_NLE_UQ
OP := _CMP_ORD_S
OP := _CMP_EQ_US
OP := _CMP_NGE_UQ
OP := _CMP_NGT_UQ
OP := _CMP_FALSE_OS
OP := _CMP_NEQ_OS
OP := _CMP_GE_OQ
OP := _CMP_GT_OQ
OP := _CMP_TRUE_US
ESAC
FOR j := 0 to 31
        IF k1[j]
                k[j] := ( a.fp16[j] OP b.fp16[j] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:32] := 0

_mm512_cmp_round_ph_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __m512h a, __m512h b, const int imm8, const int sae
Param ETypes:: FP16 a, FP16 b, IMM imm8, IMM sae

__mmask32 _mm512_cmp_round_ph_mask(__m512h a, __m512h b,
                                   const int imm8,
                                   const int sae)

Intel Description

Compare packed half-precision (16-bit) floating-point elements in “a” and “b” based on the comparison operand specified by “imm8”, and store the results in mask vector “k”. [sae_note]

Intel Implementation Psudeo-Code

CASE (imm8[4:0]) OF
OP := _CMP_EQ_OQ
OP := _CMP_LT_OS
OP := _CMP_LE_OS
OP := _CMP_UNORD_Q
OP := _CMP_NEQ_UQ
OP := _CMP_NLT_US
OP := _CMP_NLE_US
OP := _CMP_ORD_Q
OP := _CMP_EQ_UQ
OP := _CMP_NGE_US
OP := _CMP_NGT_US
OP := _CMP_FALSE_OQ
OP := _CMP_NEQ_OQ
OP := _CMP_GE_OS
OP := _CMP_GT_OS
OP := _CMP_TRUE_UQ
OP := _CMP_EQ_OS
OP := _CMP_LT_OQ
OP := _CMP_LE_OQ
OP := _CMP_UNORD_S
OP := _CMP_NEQ_US
OP := _CMP_NLT_UQ
OP := _CMP_NLE_UQ
OP := _CMP_ORD_S
OP := _CMP_EQ_US
OP := _CMP_NGE_UQ
OP := _CMP_NGT_UQ
OP := _CMP_FALSE_OS
OP := _CMP_NEQ_OS
OP := _CMP_GE_OQ
OP := _CMP_GT_OQ
OP := _CMP_TRUE_US
ESAC
FOR j := 0 to 31
        k[j] := (a.fp16[j] OP b.fp16[j]) ? 1 : 0
ENDFOR
k[MAX:32] := 0

_mm512_mask_cmp_round_ph_mask#

Tech:: AVX-512
Category:: Compare
Header:: immintrin.h
Searchable:: AVX-512-Compare-ZMM
Register:: ZMM 512 bit
Return Type:: __mmask32
Param Types:: __mmask32 k1, __m512h a, __m512h b, const int imm8, const int sae
Param ETypes:: MASK k1, FP16 a, FP16 b, IMM imm8, IMM sae

__mmask32 _mm512_mask_cmp_round_ph_mask(__mmask32 k1,
                                        __m512h a,
                                        __m512h b,
                                        const int imm8,
                                        const int sae)

Intel Description

Intel Implementation Psudeo-Code

CASE (imm8[3:0]) OF
OP := _CMP_EQ_OQ
OP := _CMP_LT_OS
OP := _CMP_LE_OS
OP := _CMP_UNORD_Q
OP := _CMP_NEQ_UQ
OP := _CMP_NLT_US
OP := _CMP_NLE_US
OP := _CMP_ORD_Q
OP := _CMP_EQ_UQ
OP := _CMP_NGE_US
OP := _CMP_NGT_US
OP := _CMP_FALSE_OQ
OP := _CMP_NEQ_OQ
OP := _CMP_GE_OS
OP := _CMP_GT_OS
OP := _CMP_TRUE_UQ
OP := _CMP_EQ_OS
OP := _CMP_LT_OQ
OP := _CMP_LE_OQ
OP := _CMP_UNORD_S
OP := _CMP_NEQ_US
OP := _CMP_NLT_UQ
OP := _CMP_NLE_UQ
OP := _CMP_ORD_S
OP := _CMP_EQ_US
OP := _CMP_NGE_UQ
OP := _CMP_NGT_UQ
OP := _CMP_FALSE_OS
OP := _CMP_NEQ_OS
OP := _CMP_GE_OQ
OP := _CMP_GT_OQ
OP := _CMP_TRUE_US
ESAC
FOR j := 0 to 31
        IF k1[j]
                k[j] := ( a.fp16[j] OP b.fp16[j] ) ? 1 : 0
        ELSE
                k[j] := 0
        FI
ENDFOR
k[MAX:32] := 0

AVX-512-Compare-ZMM

Contents

AVX-512-Compare-ZMM#

_mm512_cmp_epi8_mask#

_mm512_cmpeq_epi8_mask#

_mm512_cmpge_epi8_mask#

_mm512_cmpgt_epi8_mask#

_mm512_cmple_epi8_mask#

_mm512_cmplt_epi8_mask#

_mm512_cmpneq_epi8_mask#

_mm512_mask_cmp_epi8_mask#

_mm512_mask_cmpeq_epi8_mask#

_mm512_mask_cmpge_epi8_mask#

_mm512_mask_cmpgt_epi8_mask#

_mm512_mask_cmple_epi8_mask#

_mm512_mask_cmplt_epi8_mask#

_mm512_mask_cmpneq_epi8_mask#

_mm512_cmp_epu8_mask#

_mm512_cmpeq_epu8_mask#

_mm512_cmpge_epu8_mask#

_mm512_cmpgt_epu8_mask#

_mm512_cmple_epu8_mask#

_mm512_cmplt_epu8_mask#

_mm512_cmpneq_epu8_mask#

_mm512_mask_cmp_epu8_mask#

_mm512_mask_cmpeq_epu8_mask#

_mm512_mask_cmpge_epu8_mask#

_mm512_mask_cmpgt_epu8_mask#

_mm512_mask_cmple_epu8_mask#

_mm512_mask_cmplt_epu8_mask#

_mm512_mask_cmpneq_epu8_mask#

_mm512_cmp_epu16_mask#

_mm512_cmpeq_epu16_mask#

_mm512_cmpge_epu16_mask#

_mm512_cmpgt_epu16_mask#

_mm512_cmple_epu16_mask#

_mm512_cmplt_epu16_mask#

_mm512_cmpneq_epu16_mask#

_mm512_mask_cmp_epu16_mask#

_mm512_mask_cmpeq_epu16_mask#

_mm512_mask_cmpge_epu16_mask#

_mm512_mask_cmpgt_epu16_mask#

_mm512_mask_cmple_epu16_mask#

_mm512_mask_cmplt_epu16_mask#

_mm512_mask_cmpneq_epu16_mask#

_mm512_cmp_epi16_mask#

_mm512_cmpeq_epi16_mask#

_mm512_cmpge_epi16_mask#

_mm512_cmpgt_epi16_mask#

_mm512_cmple_epi16_mask#

_mm512_cmplt_epi16_mask#

_mm512_cmpneq_epi16_mask#

_mm512_mask_cmp_epi16_mask#

_mm512_mask_cmpeq_epi16_mask#

_mm512_mask_cmpge_epi16_mask#

_mm512_mask_cmpgt_epi16_mask#

_mm512_mask_cmple_epi16_mask#

_mm512_mask_cmplt_epi16_mask#

_mm512_mask_cmpneq_epi16_mask#

_mm512_mask_test_epi8_mask#

_mm512_test_epi8_mask#

_mm512_mask_test_epi16_mask#

_mm512_test_epi16_mask#

_mm512_mask_testn_epi8_mask#

_mm512_testn_epi8_mask#

_mm512_mask_testn_epi16_mask#

_mm512_testn_epi16_mask#

_mm512_conflict_epi32#

_mm512_mask_conflict_epi32#

_mm512_maskz_conflict_epi32#

_mm512_conflict_epi64#

_mm512_mask_conflict_epi64#

_mm512_maskz_conflict_epi64#

_mm512_cmplt_epi32_mask#

_mm512_mask_cmplt_epi32_mask#

_mm512_cmp_epi64_mask#

_mm512_cmpeq_epi64_mask#

_mm512_cmpge_epi64_mask#

_mm512_cmpgt_epi64_mask#

_mm512_cmple_epi64_mask#