インテル® C++ コンパイラー 18.0 デベロッパー・ガイドおよびリファレンス

その他の操作の組込み関数

インテル® アドバンスト・ベクトル・エクステンション 512 (インテル® AVX-512) 組込み関数のプロトタイプは、zmmintrin.h ヘッダーファイルで定義されていますが、実際にヘッダーをコードにインクルードする場合は、immintrin.h を使用します。



変数 定義
src

書き込みマスクの結果に応じて使用されるソース要素

k

セレクターとして使用される書き込みマスク

a

1 つ目のソースベクトルの要素

b

2 つ目のソースベクトルの要素

c

3 つ目のソースベクトルの要素

丸め

丸め制御値。次のいずれかになります (sae によりすべての例外フラグが抑止されます)。

  • _MM_FROUND_TO_NEAREST_INT - 最も近い偶数に丸めます。
  • _MM_FROUND_TO_NEG_INF - 負の無限大に丸めます。
  • _MM_FROUND_TO_POS_INF -正の無限大に丸めます。
  • _MM_FROUND_TO_ZERO - ゼロに丸めます。
  • _MM_FROUND_CUR_DIRECTION - MXCSR レジスターのデフォルトを使用して丸めます。

interv

_MM_MANTISSA_NORM_ENUM には、次のいずれかの値を指定できます。

  • _MM_MANT_NORM_1_2 - インターバル [1, 2)
  • _MM_MANT_NORM_p5_2 - インターバル [1.5, 2)
  • _MM_MANT_NORM_p5_1 - インターバル [1.5, 1)
  • _MM_MANT_NORM_p75_1p5 - インターバル [0.75, 1.5)

sc

_MM_MANTISSA_SIGN_ENUM には、次のいずれかの値を指定できます。

  • _MM_MANT_SIGN_src - 符号 = 符号 (SRC)
  • _MM_MANT_SIGN_zero - 符号 = 0
  • _MM_MANT_SIGN_nan - 符号 (SRC) = 1 の場合、デスティネーション = NaN


_mm_broadcast_i32x2

__m128i _mm_broadcast_i32x2(__m128i a)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vbroadcasti32x2

a の下位 2 つのパックド 32 ビット整数をデスティネーションのすべての要素にブロードキャストします。



_mm_mask_broadcast_i32x2

__m128i _mm_mask_broadcast_i32x2(__m128i src, __mmask8 k, __m128i a)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vbroadcasti32x2

書き込みマスク k を使用して、a の下位 2 つのパックド 32 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_broadcast_i32x2

__m128i _mm_maskz_broadcast_i32x2(__mmask8 k, __m128i a)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vbroadcasti32x2

ゼロマスク k を使用して、a の下位 2 つのパックド 32 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_broadcast_i32x2

__m256i _mm256_broadcast_i32x2(__m128i a)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vbroadcasti32x2

a の下位 2 つのパックド 32 ビット整数をデスティネーションのすべての要素にブロードキャストします。



_mm256_mask_broadcast_i32x2

__m256i _mm256_mask_broadcast_i32x2(__m256i src, __mmask8 k, __m128i a)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vbroadcasti32x2

書き込みマスク k を使用して、a の下位 2 つのパックド 32 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_broadcast_i32x2

__m256i _mm256_maskz_broadcast_i32x2(__mmask8 k, __m128i a)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vbroadcasti32x2

ゼロマスク k を使用して、a の下位 2 つのパックド 32 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_broadcast_i32x2

__m512i _mm512_broadcast_i32x2(__m128i a)

CPUID フラグ: AVX512DQ

命令: vbroadcasti32x2

a の下位 2 つのパックド 32 ビット整数をデスティネーションのすべての要素にブロードキャストします。



_mm512_mask_broadcast_i32x2

__m512i _mm512_mask_broadcast_i32x2(__m512i src, __mmask16 k, __m128i a)

CPUID フラグ: AVX512DQ

命令: vbroadcasti32x2

書き込みマスク k を使用して、a の下位 2 つのパックド 32 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_broadcast_i32x2

__m512i _mm512_maskz_broadcast_i32x2(__mmask16 k, __m128i a)

CPUID フラグ: AVX512DQ

命令: vbroadcasti32x2

ゼロマスク k を使用して、a の下位 2 つのパックド 32 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_broadcast_i32x4

__m256i _mm256_broadcast_i32x4(__m128i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vbroadcasti32x4

a の 4 つのパックド 32 ビット整数を戻り値のすべての要素にブロードキャストします。



_mm256_mask_broadcast_i32x4

__m256i _mm256_mask_broadcast_i32x4(__m256i src, __mmask8 k, __m128i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vbroadcasti32x4

書き込みマスク k を使用して、a の 4 つのパックド 32 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_broadcast_i32x4

__m256i _mm256_maskz_broadcast_i32x4(__mmask8 k, __m128i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vbroadcasti32x4

ゼロマスク k を使用して、a の 4 つのパックド 32 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_broadcast_i32x8

__m512i _mm512_broadcast_i32x8(__m256i a)

CPUID フラグ: AVX512DQ

命令: vbroadcasti32x8

a の 8 つのパックド 32 ビット整数を戻り値のすべての要素にブロードキャストします。



_mm512_mask_broadcast_i32x8

__m512i _mm512_mask_broadcast_i32x8(__m512i src, __mmask16 k, __m256i a)

CPUID フラグ: AVX512DQ

命令: vbroadcasti32x8

書き込みマスク k を使用して、a の 8 つのパックド 32 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_broadcast_i32x8

__m512i _mm512_maskz_broadcast_i32x8(__mmask16 k, __m256i a)

CPUID フラグ: AVX512DQ

命令: vbroadcasti32x8

ゼロマスク k を使用して、a の 8 つのパックド 32 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_broadcast_i64x2

__m256i _mm256_broadcast_i64x2(__m128i a)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vbroadcasti64x2

a の 2 つのパックド 64 ビット整数を戻り値のすべての要素にブロードキャストします。



_mm256_mask_broadcast_i64x2

__m256i _mm256_mask_broadcast_i64x2(__m256i src, __mmask8 k, __m128i a)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vbroadcasti64x2

書き込みマスク k を使用して、a の 2 つのパックド 64 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_broadcast_i64x2

__m256i _mm256_maskz_broadcast_i64x2(__mmask8 k, __m128i a)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vbroadcasti64x2

ゼロマスク k を使用して、a の 2 つのパックド 64 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_broadcast_i64x2

__m512i _mm512_broadcast_i64x2(__m128i a)

CPUID フラグ: AVX512DQ

命令: vbroadcasti64x2

a の 2 つのパックド 64 ビット整数を戻り値のすべての要素にブロードキャストします。



_mm512_mask_broadcast_i64x2

__m512i _mm512_mask_broadcast_i64x2(__m512i src, __mmask8 k, __m128i a)

CPUID フラグ: AVX512DQ

命令: vbroadcasti64x2

書き込みマスク k を使用して、a の 2 つのパックド 64 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_broadcast_i64x2

__m512i _mm512_maskz_broadcast_i64x2(__mmask8 k, __m128i a)

CPUID フラグ: AVX512DQ

命令: vbroadcasti64x2

ゼロマスク k を使用して、a の 2 つのパックド 64 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_inserti32x4

__m256i _mm256_inserti32x4(__m256i a, __m128i b, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vinserti32x4

a を戻り値にコピーし、dstimm で指定された位置に b の 128 ビット (4 つのパックド 32 ビット整数) を挿入します。



_mm256_mask_inserti32x4

__m256i _mm256_mask_inserti32x4(__m256i src, __mmask8 k, __m256i a, __m128i b, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vinserti32x4

atmp にコピーし、tmpimm で指定された位置に b の 128 ビット (4 つのパックド 32 ビット整数) を挿入します。書き込みマスク k を使用して tmp を戻り値に格納します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_inserti32x4

__m256i _mm256_maskz_inserti32x4(__mmask8 k, __m256i a, __m128i b, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vinserti32x4

atmp にコピーし、tmpimm で指定された位置に b の 128 ビット (4 つのパックド 32 ビット整数) を挿入します。ゼロマスク k を使用して tmp を戻り値に格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_inserti32x8

__m512i _mm512_inserti32x8(__m512i a, __m256i b, int imm)

CPUID フラグ: AVX512DQ

命令: vinserti32x8

a を戻り値にコピーし、dstimm で指定された位置に b の 256 ビット (8 つのパックド 32 ビット整数) を挿入します。



_mm512_mask_inserti32x8

__m512i _mm512_mask_inserti32x8(__m512i src, __mmask16 k, __m512i a, __m256i b, int imm)

CPUID フラグ: AVX512DQ

命令: vinserti32x8

atmp にコピーし、tmpimm で指定された位置に b の 256 ビット (8 つのパックド 32 ビット整数) を挿入します。書き込みマスク k を使用して tmp を戻り値に格納します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_inserti32x8

__m512i _mm512_maskz_inserti32x8(__mmask16 k, __m512i a, __m256i b, int imm)

CPUID フラグ: AVX512DQ

命令: vinserti32x8

atmp にコピーし、tmpimm で指定された位置に b の 256 ビット (8 つのパックド 32 ビット整数) を挿入します。ゼロマスク k を使用して tmp を戻り値に格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_inserti64x2

__m256i _mm256_inserti64x2(__m256i a, __m128i b, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vinserti64x2

a を戻り値にコピーし、dstimm で指定された位置に b の 128 ビット (2 つのパックド 64 ビット整数) を挿入します。



_mm256_mask_inserti64x2

__m256i _mm256_mask_inserti64x2(__m256i src, __mmask8 k, __m256i a, __m128i b, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vinserti64x2

atmp にコピーし、tmpimm で指定された位置に b の 128 ビット (2 つのパックド 64 ビット整数) を挿入します。書き込みマスク k を使用して tmp を戻り値に格納します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_inserti64x2

__m256i _mm256_maskz_inserti64x2(__mmask8 k, __m256i a, __m128i b, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vinserti64x2

atmp にコピーし、tmpimm で指定された位置に b の 128 ビット (2 つのパックド 64 ビット整数) を挿入します。ゼロマスク k を使用して tmp を戻り値に格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_inserti64x2

__m512i _mm512_inserti64x2(__m512i a, __m128i b, int imm)

CPUID フラグ: AVX512DQ

命令: vinserti64x2

a を戻り値にコピーし、dstimm で指定された位置に b の 128 ビット (2 つのパックド 64 ビット整数) を挿入します。



_mm512_mask_inserti64x2

__m512i _mm512_mask_inserti64x2(__m512i src, __mmask8 k, __m512i a, __m128i b, int imm)

CPUID フラグ: AVX512DQ

命令: vinserti64x2

atmp にコピーし、tmpimm で指定された位置に b の 128 ビット (2 つのパックド 64 ビット整数) を挿入します。書き込みマスク k を使用して tmp を戻り値に格納します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_inserti64x2

__m512i _mm512_maskz_inserti64x2(__mmask8 k, __m512i a, __m128i b, int imm)

CPUID フラグ: AVX512DQ

命令: vinserti64x2

atmp にコピーし、tmpimm で指定された位置に b の 128 ビット (2 つのパックド 64 ビット整数) を挿入します。ゼロマスク k を使用して tmp を戻り値に格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_shuffle_i32x4

__m256i _mm256_mask_shuffle_i32x4(__m256i src, __mmask8 k, __m256i a, __m256i b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshufi32x4

imm で選択された ab の 128 ビット (4 つの 32 ビット整数) をシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_shuffle_i32x4

__m256i _mm256_maskz_shuffle_i32x4(__mmask8 k, __m256i a, __m256i b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshufi32x4

imm で選択された ab の 128 ビット (4 つの 32 ビット整数) をシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_shuffle_i32x4

__m256i _mm256_shuffle_i32x4(__m256i a, __m256i b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshufi32x4

imm で選択された ab の 128 ビット (4 つの 32 ビット整数) をシャッフルし、結果を返します。



_mm256_mask_shuffle_i64x2

__m256i _mm256_mask_shuffle_i64x2(__m256i src, __mmask8 k, __m256i a, __m256i b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshufi64x2

imm で選択された ab の 128 ビット (2 つの 64 ビット整数) をシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_shuffle_i64x2

__m256i _mm256_maskz_shuffle_i64x2(__mmask8 k, __m256i a, __m256i b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshufi64x2

imm で選択された ab の 128 ビット (2 つの 64 ビット整数) をシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_shuffle_i64x2

__m256i _mm256_shuffle_i64x2(__m256i a, __m256i b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshufi64x2

imm で選択された ab の 128 ビット (2 つの 64 ビット整数) をシャッフルし、結果を返します。



_mm_mask_blend_pd

__m128d _mm_mask_blend_pd(__mmask8 k, __m128d a, __m128d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vblendmpd

制御マスク k を使用して ab のパックド倍精度 (64 ビット) 浮動小数点要素をブレンド (混合) し、結果を返します。



_mm256_mask_blend_pd

__m256d _mm256_mask_blend_pd(__mmask8 k, __m256d a, __m256d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vblendmpd

制御マスク k を使用して ab のパックド倍精度 (64 ビット) 浮動小数点要素をブレンド (混合) し、結果を返します。



_mm_mask_blend_ps

__m128 _mm_mask_blend_ps(__mmask8 k, __m128 a, __m128 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vblendmps

制御マスク k を使用して ab のパックド単精度 (32 ビット) 浮動小数点要素をブレンド (混合) し、結果を返します。



_mm256_mask_blend_ps

__m256 _mm256_mask_blend_ps(__mmask8 k, __m256 a, __m256 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vblendmps

制御マスク k を使用して ab のパックド単精度 (32 ビット) 浮動小数点要素をブレンド (混合) し、結果を返します。



_mm256_broadcast_f32x2

__m256 _mm256_broadcast_f32x2(__m128 a)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vbroadcastf32x2

a の下位 2 つのパックド単精度 (32 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします。



_mm256_mask_broadcast_f32x2

__m256 _mm256_mask_broadcast_f32x2(__m256 src, __mmask8 k, __m128 a)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vbroadcastf32x2

書き込みマスク k を使用して、a の下位 2 つのパックド単精度 (32 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_broadcast_f32x2

__m256 _mm256_maskz_broadcast_f32x2(__mmask8 k, __m128 a)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vbroadcastf32x2

ゼロマスク k を使用して、a の下位 2 つのパックド単精度 (32 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_broadcast_f32x2

__m512 _mm512_broadcast_f32x2(__m128 a)

CPUID フラグ: AVX512DQ

命令: vbroadcastf32x2

a の下位 2 つのパックド単精度 (32 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします。



_mm512_mask_broadcast_f32x2

__m512 _mm512_mask_broadcast_f32x2(__m512 src, __mmask16 k, __m128 a)

CPUID フラグ: AVX512DQ

命令: vbroadcastf32x2

書き込みマスク k を使用して、a の下位 2 つのパックド単精度 (32 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_broadcast_f32x2

__m512 _mm512_maskz_broadcast_f32x2(__mmask16 k, __m128 a)

CPUID フラグ: AVX512DQ

命令: vbroadcastf32x2

ゼロマスク k を使用して、a の下位 2 つのパックド単精度 (32 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_broadcast_f32x4

__m256 _mm256_broadcast_f32x4(__m128 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vbroadcastf32x4

a の 4 つのパックド単精度 (32 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします。



_mm256_mask_broadcast_f32x4

__m256 _mm256_mask_broadcast_f32x4(__m256 src, __mmask8 k, __m128 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vbroadcastf32x4

書き込みマスク k を使用して、a の 4 つのパックド単精度 (32 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_broadcast_f32x4

__m256 _mm256_maskz_broadcast_f32x4(__mmask8 k, __m128 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vbroadcastf32x4

ゼロマスク k を使用して、a の 4 つのパックド単精度 (32 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_broadcast_f32x8

__m512 _mm512_broadcast_f32x8(__m256 a)

CPUID フラグ: AVX512DQ

命令: vbroadcastf32x8

a の 8 つのパックド単精度 (32 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします。



_mm512_mask_broadcast_f32x8

__m512 _mm512_mask_broadcast_f32x8(__m512 src, __mmask16 k, __m256 a)

CPUID フラグ: AVX512DQ

命令: vbroadcastf32x8

書き込みマスク k を使用して、a の 8 つのパックド単精度 (32 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_broadcast_f32x8

__m512 _mm512_maskz_broadcast_f32x8(__mmask16 k, __m256 a)

CPUID フラグ: AVX512DQ

命令: vbroadcastf32x8

ゼロマスク k を使用して、a の 8 つのパックド単精度 (32 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_broadcast_f64x2

__m256d _mm256_broadcast_f64x2(__m128d a)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vbroadcastf64x2

a の 2 つのパックド倍精度 (64 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします。



_mm256_mask_broadcast_f64x2

__m256d _mm256_mask_broadcast_f64x2(__m256d src, __mmask8 k, __m128d a)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vbroadcastf64x2

書き込みマスク k を使用して、a の 2 つのパックド倍精度 (64 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_broadcast_f64x2

__m256d _mm256_maskz_broadcast_f64x2(__mmask8 k, __m128d a)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vbroadcastf64x2

ゼロマスク k を使用して、a の 2 つのパックド倍精度 (64 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_broadcast_f64x2

__m512d _mm512_broadcast_f64x2(__m128d a)

CPUID フラグ: AVX512DQ

命令: vbroadcastf64x2

a の 2 つのパックド倍精度 (64 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします。



_mm512_mask_broadcast_f64x2

__m512d _mm512_mask_broadcast_f64x2(__m512d src, __mmask8 k, __m128d a)

CPUID フラグ: AVX512DQ

命令: vbroadcastf64x2

書き込みマスク k を使用して、a の 2 つのパックド倍精度 (64 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_broadcast_f64x2

__m512d _mm512_maskz_broadcast_f64x2(__mmask8 k, __m128d a)

CPUID フラグ: AVX512DQ

命令: vbroadcastf64x2

ゼロマスク k を使用して、a の 2 つのパックド倍精度 (64 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_broadcastsd_pd

__m256d _mm256_mask_broadcastsd_pd(__m256d src, __mmask8 k, __m128d a)

CPUID フラグ: AVX512F、AVX512VL

命令: vbroadcastsd

書き込みマスク k を使用して、a の下位倍精度 (64 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_broadcastsd_pd

__m256d _mm256_maskz_broadcastsd_pd(__mmask8 k, __m128d a)

CPUID フラグ: AVX512F、AVX512VL

命令: vbroadcastsd

ゼロマスク k を使用して、a の下位倍精度 (64 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_broadcastss_ps

__m128 _mm_mask_broadcastss_ps(__m128 src, __mmask8 k, __m128 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vbroadcastss

書き込みマスク k を使用して、a の下位単精度 (32 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_broadcastss_ps

__m128 _mm_maskz_broadcastss_ps(__mmask8 k, __m128 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vbroadcastss

ゼロマスク k を使用して、a の下位単精度 (32 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_broadcastss_ps

__m256 _mm256_mask_broadcastss_ps(__m256 src, __mmask8 k, __m128 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vbroadcastss

書き込みマスク k を使用して、a の下位単精度 (32 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_broadcastss_ps

__m256 _mm256_maskz_broadcastss_ps(__mmask8 k, __m128 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vbroadcastss

ゼロマスク k を使用して、a の下位単精度 (32 ビット) 浮動小数点要素を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_compress_pd

__m128d _mm_mask_compress_pd(__m128d src, __mmask8 k, __m128d a)

CPUID フラグ: AVX512F、AVX512VL

命令: vcompresspd

a のアクティブな倍精度 (64 ビット) 浮動小数点要素 (書き込みマスク k の対応するビットがセットされている要素) を戻り値に連続して格納し、残りの要素を src からコピーします。



_mm_maskz_compress_pd

__m128d _mm_maskz_compress_pd(__mmask8 k, __m128d a)

CPUID フラグ: AVX512F、AVX512VL

命令: vcompresspd

a のアクティブな倍精度 (64 ビット) 浮動小数点要素 (ゼロマスク k の対応するビットがセットされている要素) を戻り値に連続して格納し、残りの要素を 0 に設定します。



_mm256_mask_compress_pd

__m256d _mm256_mask_compress_pd(__m256d src, __mmask8 k, __m256d a)

CPUID フラグ: AVX512F、AVX512VL

命令: vcompresspd

a のアクティブな倍精度 (64 ビット) 浮動小数点要素 (書き込みマスク k の対応するビットがセットされている要素) を戻り値に連続して格納し、残りの要素を src からコピーします。



_mm256_maskz_compress_pd

__m256d _mm256_maskz_compress_pd(__mmask8 k, __m256d a)

CPUID フラグ: AVX512F、AVX512VL

命令: vcompresspd

a のアクティブな倍精度 (64 ビット) 浮動小数点要素 (ゼロマスク k の対応するビットがセットされている要素) を戻り値に連続して格納し、残りの要素を 0 に設定します。



_mm_mask_compress_ps

__m128 _mm_mask_compress_ps(__m128 src, __mmask8 k, __m128 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vcompressps

a のアクティブな単精度 (32 ビット) 浮動小数点要素 (書き込みマスク k の対応するビットがセットされている要素) を戻り値に連続して格納し、残りの要素を src からコピーします。



_mm_maskz_compress_ps

__m128 _mm_maskz_compress_ps(__mmask8 k, __m128 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vcompressps

a のアクティブな単精度 (32 ビット) 浮動小数点要素 (ゼロマスク k の対応するビットがセットされている要素) を戻り値に連続して格納し、残りの要素を 0 に設定します。



_mm256_mask_compress_ps

__m256 _mm256_mask_compress_ps(__m256 src, __mmask8 k, __m256 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vcompressps

a のアクティブな単精度 (32 ビット) 浮動小数点要素 (書き込みマスク k の対応するビットがセットされている要素) を戻り値に連続して格納し、残りの要素を src からコピーします。



_mm256_maskz_compress_ps

__m256 _mm256_maskz_compress_ps(__mmask8 k, __m256 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vcompressps

a のアクティブな単精度 (32 ビット) 浮動小数点要素 (ゼロマスク k の対応するビットがセットされている要素) を戻り値に連続して格納し、残りの要素を 0 に設定します。



_mm_mask_expand_pd

__m128d _mm_mask_expand_pd(__m128d src, __mmask8 k, __m128d a)

CPUID フラグ: AVX512F、AVX512VL

命令: vexpandpd

a の連続するアクティブな倍精度 (64 ビット) 浮動小数点要素 (マスク k の対応するビットがセットされている要素) をロードし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_expand_pd

__m128d _mm_maskz_expand_pd(__mmask8 k, __m128d a)

CPUID フラグ: AVX512F、AVX512VL

命令: vexpandpd

a の連続するアクティブな倍精度 (64 ビット) 浮動小数点要素 (マスク k の対応するビットがセットされている要素) をロードし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_expand_pd

__m256d _mm256_mask_expand_pd(__m256d src, __mmask8 k, __m256d a)

CPUID フラグ: AVX512F、AVX512VL

命令: vexpandpd

a の連続するアクティブな倍精度 (64 ビット) 浮動小数点要素 (マスク k の対応するビットがセットされている要素) をロードし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_expand_pd

__m256d _mm256_maskz_expand_pd(__mmask8 k, __m256d a)

CPUID フラグ: AVX512F、AVX512VL

命令: vexpandpd

a の連続するアクティブな倍精度 (64 ビット) 浮動小数点要素 (マスク k の対応するビットがセットされている要素) をロードし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_expand_ps

__m128 _mm_mask_expand_ps(__m128 src, __mmask8 k, __m128 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vexpandps

a の連続するアクティブな単精度 (32 ビット) 浮動小数点要素 (マスク k の対応するビットがセットされている要素) をロードし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_expand_ps

__m128 _mm_maskz_expand_ps(__mmask8 k, __m128 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vexpandps

a の連続するアクティブな単精度 (32 ビット) 浮動小数点要素 (マスク k の対応するビットがセットされている要素) をロードし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_expand_ps

__m256 _mm256_mask_expand_ps(__m256 src, __mmask8 k, __m256 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vexpandps

a の連続するアクティブな単精度 (32 ビット) 浮動小数点要素 (マスク k の対応するビットがセットされている要素) をロードし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_expand_ps

__m256 _mm256_maskz_expand_ps(__mmask8 k, __m256 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vexpandps

a の連続するアクティブな単精度 (32 ビット) 浮動小数点要素 (マスク k の対応するビットがセットされている要素) をロードし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_extractf32x4_ps

__m128 _mm256_extractf32x4_ps(__m256 a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vextractf32x4

imm で選択された 128 ビット (4 つのパックド単精度 (32 ビット) 浮動小数点要素) を a から抽出し、結果を戻り値に格納します。



_mm256_mask_extractf32x4_ps

__m128 _mm256_mask_extractf32x4_ps(__m128 src, __mmask8 k, __m256 a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vextractf32x4

imm で選択された 128 ビット (4 つのパックド単精度 (32 ビット) 浮動小数点要素) を a から抽出し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_extractf32x4_ps

__m128 _mm256_maskz_extractf32x4_ps(__mmask8 k, __m256 a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vextractf32x4

imm で選択された 128 ビット (4 つのパックド単精度 (32 ビット) 浮動小数点要素) を a から抽出し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_extractf32x8_ps

__m256 _mm512_extractf32x8_ps(__m512 a, int imm)

CPUID フラグ: AVX512DQ

命令: vextractf32x8

imm で選択された 256 ビット (8 つのパックド単精度 (32 ビット) 浮動小数点要素) を a から抽出し、結果を戻り値に格納します。



_mm512_mask_extractf32x8_ps

__m256 _mm512_mask_extractf32x8_ps(__m256 src, __mmask8 k, __m512 a, int imm)

CPUID フラグ: AVX512DQ

命令: vextractf32x8

imm で選択された 256 ビット (8 つのパックド単精度 (32 ビット) 浮動小数点要素) を a から抽出し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_extractf32x8_ps

__m256 _mm512_maskz_extractf32x8_ps(__mmask8 k, __m512 a, int imm)

CPUID フラグ: AVX512DQ

命令: vextractf32x8

imm で選択された 256 ビット (8 つのパックド単精度 (32 ビット) 浮動小数点要素) を a から抽出し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_extractf64x2_pd

__m128d _mm256_extractf64x2_pd(__m256d a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vextractf64x2

imm で選択された 128 ビット (2 つのパックド倍精度 (64 ビット) 浮動小数点要素) を a から抽出し、結果を戻り値に格納します。



_mm256_mask_extractf64x2_pd

__m128d _mm256_mask_extractf64x2_pd(__m128d src, __mmask8 k, __m256d a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vextractf64x2

imm で選択された 128 ビット (2 つのパックド倍精度 (64 ビット) 浮動小数点要素) を a から抽出し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_extractf64x2_pd

__m128d _mm256_maskz_extractf64x2_pd(__mmask8 k, __m256d a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vextractf64x2

imm で選択された 128 ビット (2 つのパックド倍精度 (64 ビット) 浮動小数点要素) を a から抽出し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_extractf64x2_pd

__m128d _mm512_extractf64x2_pd(__m512d a, int imm)

CPUID フラグ: AVX512DQ

命令: vextractf64x2

imm で選択された 128 ビット (2 つのパックド倍精度 (64 ビット) 浮動小数点要素) を a から抽出し、結果を戻り値に格納します。



_mm512_mask_extractf64x2_pd

__m128d _mm512_mask_extractf64x2_pd(__m128d src, __mmask8 k, __m512d a, int imm)

CPUID フラグ: AVX512DQ

命令: vextractf64x2

imm で選択された 128 ビット (2 つのパックド倍精度 (64 ビット) 浮動小数点要素) を a から抽出し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_extractf64x2_pd

__m128d _mm512_maskz_extractf64x2_pd(__mmask8 k, __m512d a, int imm)

CPUID フラグ: AVX512DQ

命令: vextractf64x2

imm で選択された 128 ビット (2 つのパックド倍精度 (64 ビット) 浮動小数点要素) を a から抽出し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_fixupimm_pd

__m128d _mm_fixupimm_pd(__m128d a, __m128d b, __m128i c, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vfixupimmpd

c のパックド 64 ビット整数を使用して ab のパックド倍精度 (64 ビット) 浮動小数点要素を修正し、結果を返します。imm はレポートに必要なフラグの設定に使用されます。



_mm_mask_fixupimm_pd

__m128d _mm_mask_fixupimm_pd(__m128d a, __mmask8 k, __m128d b, __m128i c, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vfixupimmpd

c のパックド 64 ビット整数を使用して ab のパックド倍精度 (64 ビット) 浮動小数点要素を修正し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は a の要素がコピーされます)。imm はレポートに必要なフラグの設定に使用されます。



_mm_maskz_fixupimm_pd

__m128d _mm_maskz_fixupimm_pd(__mmask8 k, __m128d a, __m128d b, __m128i c, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vfixupimmpd

c のパックド 64 ビット整数を使用して ab のパックド倍精度 (64 ビット) 浮動小数点要素を修正し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。imm はレポートに必要なフラグの設定に使用されます。



_mm256_fixupimm_pd

__m256d _mm256_fixupimm_pd(__m256d a, __m256d b, __m256i c, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vfixupimmpd

c のパックド 64 ビット整数を使用して ab のパックド倍精度 (64 ビット) 浮動小数点要素を修正し、結果を返します。imm はレポートに必要なフラグの設定に使用されます。



_mm256_mask_fixupimm_pd

__m256d _mm256_mask_fixupimm_pd(__m256d a, __mmask8 k, __m256d b, __m256i c, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vfixupimmpd

c のパックド 64 ビット整数を使用して ab のパックド倍精度 (64 ビット) 浮動小数点要素を修正し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は a の要素がコピーされます)。imm はレポートに必要なフラグの設定に使用されます。



_mm256_maskz_fixupimm_pd

__m256d _mm256_maskz_fixupimm_pd(__mmask8 k, __m256d a, __m256d b, __m256i c, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vfixupimmpd

c のパックド 64 ビット整数を使用して ab のパックド倍精度 (64 ビット) 浮動小数点要素を修正し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。imm はレポートに必要なフラグの設定に使用されます。



_mm_fixupimm_ps

__m128 _mm_fixupimm_ps(__m128 a, __m128 b, __m128i c, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vfixupimmps

c のパックド 32 ビット整数を使用して ab のパックド単精度 (32 ビット) 浮動小数点要素を修正し、結果を返します。imm はレポートに必要なフラグの設定に使用されます。



_mm_mask_fixupimm_ps

__m128 _mm_mask_fixupimm_ps(__m128 a, __mmask8 k, __m128 b, __m128i c, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vfixupimmps

c のパックド 32 ビット整数を使用して ab のパックド単精度 (32 ビット) 浮動小数点要素を修正し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は a の要素がコピーされます)。imm はレポートに必要なフラグの設定に使用されます。



_mm_maskz_fixupimm_ps

__m128 _mm_maskz_fixupimm_ps(__mmask8 k, __m128 a, __m128 b, __m128i c, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vfixupimmps

c のパックド 32 ビット整数を使用して ab のパックド単精度 (32 ビット) 浮動小数点要素を修正し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。imm はレポートに必要なフラグの設定に使用されます。



_mm256_fixupimm_ps

__m256 _mm256_fixupimm_ps(__m256 a, __m256 b, __m256i c, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vfixupimmps

c のパックド 32 ビット整数を使用して ab のパックド単精度 (32 ビット) 浮動小数点要素を修正し、結果を返します。imm はレポートに必要なフラグの設定に使用されます。



_mm256_mask_fixupimm_ps

__m256 _mm256_mask_fixupimm_ps(__m256 a, __mmask8 k, __m256 b, __m256i c, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vfixupimmps

c のパックド 32 ビット整数を使用して ab のパックド単精度 (32 ビット) 浮動小数点要素を修正し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は a の要素がコピーされます)。imm はレポートに必要なフラグの設定に使用されます。



_mm256_maskz_fixupimm_ps

__m256 _mm256_maskz_fixupimm_ps(__mmask8 k, __m256 a, __m256 b, __m256i c, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vfixupimmps

c のパックド 32 ビット整数を使用して ab のパックド単精度 (32 ビット) 浮動小数点要素を修正し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。imm はレポートに必要なフラグの設定に使用されます。



_mm_getexp_pd

__m128d _mm_getexp_pd(__m128d a)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetexppd

a の各パックド倍精度 (64 ビット) 浮動小数点要素の指数部を、整数の指数部を表すパックド倍精度 (64 ビット) 浮動小数点要素に変換し、結果を返します。この組込み関数は、各要素の floor(log2(x)) を計算します。



_mm_mask_getexp_pd

__m128d _mm_mask_getexp_pd(__m128d src, __mmask8 k, __m128d a)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetexppd

a の各パックド倍精度 (64 ビット) 浮動小数点要素の指数部を、整数の指数部を表すパックド倍精度 (64 ビット) 浮動小数点要素に変換し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。この組込み関数は、各要素の floor(log2(x)) を計算します。



_mm_maskz_getexp_pd

__m128d _mm_maskz_getexp_pd(__mmask8 k, __m128d a)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetexppd

a の各パックド倍精度 (64 ビット) 浮動小数点要素の指数部を、整数の指数部を表すパックド倍精度 (64 ビット) 浮動小数点要素に変換し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。この組込み関数は、各要素の floor(log2(x)) を計算します。



_mm256_getexp_pd

__m256d _mm256_getexp_pd(__m256d a)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetexppd

a の各パックド倍精度 (64 ビット) 浮動小数点要素の指数部を、整数の指数部を表すパックド倍精度 (64 ビット) 浮動小数点要素に変換し、結果を返します。この組込み関数は、各要素の floor(log2(x)) を計算します。



_mm256_mask_getexp_pd

__m256d _mm256_mask_getexp_pd(__m256d src, __mmask8 k, __m256d a)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetexppd

a の各パックド倍精度 (64 ビット) 浮動小数点要素の指数部を、整数の指数部を表すパックド倍精度 (64 ビット) 浮動小数点要素に変換し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。この組込み関数は、各要素の floor(log2(x)) を計算します。



_mm256_maskz_getexp_pd

__m256d _mm256_maskz_getexp_pd(__mmask8 k, __m256d a)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetexppd

a の各パックド倍精度 (64 ビット) 浮動小数点要素の指数部を、整数の指数部を表すパックド倍精度 (64 ビット) 浮動小数点要素に変換し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。この組込み関数は、各要素の floor(log2(x)) を計算します。



_mm_getexp_ps

__m128 _mm_getexp_ps(__m128 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetexpps

a の各パックド単精度 (32 ビット) 浮動小数点要素の指数部を、整数の指数部を表すパックド単精度 (32 ビット) 浮動小数点要素に変換し、結果を返します。この組込み関数は、各要素の floor(log2(x)) を計算します。



_mm_mask_getexp_ps

__m128 _mm_mask_getexp_ps(__m128 src, __mmask8 k, __m128 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetexpps

a の各パックド単精度 (32 ビット) 浮動小数点要素の指数部を、整数の指数部を表すパックド単精度 (32 ビット) 浮動小数点要素に変換し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。この組込み関数は、各要素の floor(log2(x)) を計算します。



_mm_maskz_getexp_ps

__m128 _mm_maskz_getexp_ps(__mmask8 k, __m128 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetexpps

a の各パックド単精度 (32 ビット) 浮動小数点要素の指数部を、整数の指数部を表すパックド単精度 (32 ビット) 浮動小数点要素に変換し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。この組込み関数は、各要素の floor(log2(x)) を計算します。



_mm256_getexp_ps

__m256 _mm256_getexp_ps(__m256 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetexpps

a の各パックド単精度 (32 ビット) 浮動小数点要素の指数部を、整数の指数部を表すパックド単精度 (32 ビット) 浮動小数点要素に変換し、結果を返します。この組込み関数は、各要素の floor(log2(x)) を計算します。



_mm256_mask_getexp_ps

__m256 _mm256_mask_getexp_ps(__m256 src, __mmask8 k, __m256 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetexpps

a の各パックド単精度 (32 ビット) 浮動小数点要素の指数部を、整数の指数部を表すパックド単精度 (32 ビット) 浮動小数点要素に変換し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。この組込み関数は、各要素の floor(log2(x)) を計算します。



_mm256_maskz_getexp_ps

__m256 _mm256_maskz_getexp_ps(__mmask8 k, __m256 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetexpps

a の各パックド単精度 (32 ビット) 浮動小数点要素の指数部を、整数の指数部を表すパックド単精度 (32 ビット) 浮動小数点要素に変換し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。この組込み関数は、各要素の floor(log2(x)) を計算します。



_mm_getmant_pd

__m128d _mm_getmant_pd(__m128d a, _MM_MANTISSA_NORM_ENUM interv, _MM_MANTISSA_SIGN_ENUM sc)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetmantpd

a のパックド倍精度 (64 ビット) 浮動小数点要素の仮数を正規化し、結果を返します。この組込み関数は、±(2^k)*|x.significand| を計算します。kinterv で定義される範囲、符号は sc とソースの符号に依存します。



_mm_mask_getmant_pd

__m128d _mm_mask_getmant_pd(__m128d src, __mmask8 k, __m128d a, _MM_MANTISSA_NORM_ENUM interv, _MM_MANTISSA_SIGN_ENUM sc)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetmantpd

a のパックド倍精度 (64 ビット) 浮動小数点要素の仮数を正規化し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。この組込み関数は、±(2^k)*|x.significand| を計算します。kinterv で定義される範囲、符号は sc とソースの符号に依存します。



_mm_maskz_getmant_pd

__m128d _mm_maskz_getmant_pd(__mmask8 k, __m128d a, _MM_MANTISSA_NORM_ENUM interv, _MM_MANTISSA_SIGN_ENUM sc)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetmantpd

a のパックド倍精度 (64 ビット) 浮動小数点要素の仮数を正規化し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。この組込み関数は、±(2^k)*|x.significand| を計算します。kinterv で定義される範囲、符号は sc とソースの符号に依存します。



_mm256_getmant_pd

__m256d _mm256_getmant_pd(__m256d a, _MM_MANTISSA_NORM_ENUM interv, _MM_MANTISSA_SIGN_ENUM sc)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetmantpd

a のパックド倍精度 (64 ビット) 浮動小数点要素の仮数を正規化し、結果を返します。この組込み関数は、±(2^k)*|x.significand| を計算します。kinterv で定義される範囲、符号は sc とソースの符号に依存します。



_mm256_mask_getmant_pd

__m256d _mm256_mask_getmant_pd(__m256d src, __mmask8 k, __m256d a, _MM_MANTISSA_NORM_ENUM interv, _MM_MANTISSA_SIGN_ENUM sc)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetmantpd

a のパックド倍精度 (64 ビット) 浮動小数点要素の仮数を正規化し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。この組込み関数は、±(2^k)*|x.significand| を計算します。kinterv で定義される範囲、符号は sc とソースの符号に依存します。



_mm256_maskz_getmant_pd

__m256d _mm256_maskz_getmant_pd(__mmask8 k, __m256d a, _MM_MANTISSA_NORM_ENUM interv, _MM_MANTISSA_SIGN_ENUM sc)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetmantpd

a のパックド倍精度 (64 ビット) 浮動小数点要素の仮数を正規化し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。この組込み関数は、±(2^k)*|x.significand| を計算します。kinterv で定義される範囲、符号は sc とソースの符号に依存します。



_mm_getmant_ps

__m128 _mm_getmant_ps(__m128 a, _MM_MANTISSA_NORM_ENUM interv, _MM_MANTISSA_SIGN_ENUM sc)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetmantps

a のパックド単精度 (32 ビット) 浮動小数点要素の仮数を正規化し、結果を返します。この組込み関数は、±(2^k)*|x.significand| を計算します。kinterv で定義される範囲、符号は sc とソースの符号に依存します。



_mm_mask_getmant_ps

__m128 _mm_mask_getmant_ps(__m128 src, __mmask8 k, __m128 a, _MM_MANTISSA_NORM_ENUM interv, _MM_MANTISSA_SIGN_ENUM sc)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetmantps

a のパックド単精度 (32 ビット) 浮動小数点要素の仮数を正規化し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。この組込み関数は、±(2^k)*|x.significand| を計算します。kinterv で定義される範囲、符号は sc とソースの符号に依存します。



_mm_maskz_getmant_ps

__m128 _mm_maskz_getmant_ps(__mmask8 k, __m128 a, _MM_MANTISSA_NORM_ENUM interv, _MM_MANTISSA_SIGN_ENUM sc)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetmantps

a のパックド単精度 (32 ビット) 浮動小数点要素の仮数を正規化し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。この組込み関数は、±(2^k)*|x.significand| を計算します。kinterv で定義される範囲、符号は sc とソースの符号に依存します。



_mm256_getmant_ps

__m256 _mm256_getmant_ps(__m256 a, _MM_MANTISSA_NORM_ENUM interv, _MM_MANTISSA_SIGN_ENUM sc)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetmantps

a のパックド単精度 (32 ビット) 浮動小数点要素の仮数を正規化し、結果を返します。この組込み関数は、±(2^k)*|x.significand| を計算します。kinterv で定義される範囲、符号は sc とソースの符号に依存します。



_mm256_mask_getmant_ps

__m256 _mm256_mask_getmant_ps(__m256 src, __mmask8 k, __m256 a, _MM_MANTISSA_NORM_ENUM interv, _MM_MANTISSA_SIGN_ENUM sc)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetmantps

a のパックド単精度 (32 ビット) 浮動小数点要素の仮数を正規化し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。この組込み関数は、±(2^k)*|x.significand| を計算します。kinterv で定義される範囲、符号は sc とソースの符号に依存します。



_mm256_maskz_getmant_ps

__m256 _mm256_maskz_getmant_ps(__mmask8 k, __m256 a, _MM_MANTISSA_NORM_ENUM interv, _MM_MANTISSA_SIGN_ENUM sc)

CPUID フラグ: AVX512F、AVX512VL

命令: vgetmantps

a のパックド単精度 (32 ビット) 浮動小数点要素の仮数を正規化し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。この組込み関数は、±(2^k)*|x.significand| を計算します。kinterv で定義される範囲、符号は sc とソースの符号に依存します。



_mm256_insertf32x4

__m256 _mm256_insertf32x4(__m256 a, __m128 b, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vinsertf32x4

a を戻り値にコピーし、dstimm で指定された位置に b の 128 ビット (4 つのパックド単精度 (32 ビット) 浮動小数点要素) を挿入します。



_mm256_mask_insertf32x4

__m256 _mm256_mask_insertf32x4(__m256 src, __mmask8 k, __m256 a, __m128 b, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vinsertf32x4

atmp にコピーし、tmpimm で指定された位置に b の 128 ビット (4 つのパックド単精度 (32 ビット) 浮動小数点要素) を挿入します。書き込みマスク k を使用して tmp を戻り値に格納します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_insertf32x4

__m256 _mm256_maskz_insertf32x4(__mmask8 k, __m256 a, __m128 b, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vinsertf32x4

atmp にコピーし、tmpimm で指定された位置に b の 128 ビット (4 つのパックド単精度 (32 ビット) 浮動小数点要素) を挿入します。ゼロマスク k を使用して tmp を戻り値に格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_insertf32x8

__m512 _mm512_insertf32x8(__m512 a, __m256 b, int imm)

CPUID フラグ: AVX512DQ

命令: vinsertf32x8

a を戻り値にコピーし、dstimm で指定された位置に b の 256 ビット (8 つのパックド単精度 (32 ビット) 浮動小数点要素) を挿入します。



_mm512_mask_insertf32x8

__m512 _mm512_mask_insertf32x8(__m512 src, __mmask16 k, __m512 a, __m256 b, int imm)

CPUID フラグ: AVX512DQ

命令: vinsertf32x8

atmp にコピーし、tmpimm で指定された位置に b の 256 ビット (8 つのパックド単精度 (32 ビット) 浮動小数点要素) を挿入します。書き込みマスク k を使用して tmp を戻り値に格納します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_insertf32x8

__m512 _mm512_maskz_insertf32x8(__mmask16 k, __m512 a, __m256 b, int imm)

CPUID フラグ: AVX512DQ

命令: vinsertf32x8

atmp にコピーし、tmpimm で指定された位置に b の 256 ビット (8 つのパックド単精度 (32 ビット) 浮動小数点要素) を挿入します。ゼロマスク k を使用して tmp を戻り値に格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_insertf64x2

__m256d _mm256_insertf64x2(__m256d a, __m128d b, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vinsertf64x2

a を戻り値にコピーし、dstimm で指定された位置に b の 128 ビット (2 つのパックド倍精度 (64 ビット) 浮動小数点要素) を挿入します。



_mm256_mask_insertf64x2

__m256d _mm256_mask_insertf64x2(__m256d src, __mmask8 k, __m256d a, __m128d b, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vinsertf64x2

atmp にコピーし、tmpimm で指定された位置に b の 128 ビット (2 つのパックド倍精度 (64 ビット) 浮動小数点要素) を挿入します。書き込みマスク k を使用して tmp を戻り値に格納します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_insertf64x2

__m256d _mm256_maskz_insertf64x2(__mmask8 k, __m256d a, __m128d b, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vinsertf64x2

atmp にコピーし、tmpimm で指定された位置に b の 128 ビット (2 つのパックド倍精度 (64 ビット) 浮動小数点要素) を挿入します。ゼロマスク k を使用して tmp を戻り値に格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_insertf64x2

__m512d _mm512_insertf64x2(__m512d a, __m128d b, int imm)

CPUID フラグ: AVX512DQ

命令: vinsertf64x2

a を戻り値にコピーし、dstimm で指定された位置に b の 128 ビット (2 つのパックド倍精度 (64 ビット) 浮動小数点要素) を挿入します。



_mm512_mask_insertf64x2

__m512d _mm512_mask_insertf64x2(__m512d src, __mmask8 k, __m512d a, __m128d b, int imm)

CPUID フラグ: AVX512DQ

命令: vinsertf64x2

atmp にコピーし、tmpimm で指定された位置に b の 128 ビット (2 つのパックド倍精度 (64 ビット) 浮動小数点要素) を挿入します。書き込みマスク k を使用して tmp を戻り値に格納します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_insertf64x2

__m512d _mm512_maskz_insertf64x2(__mmask8 k, __m512d a, __m128d b, int imm)

CPUID フラグ: AVX512DQ

命令: vinsertf64x2

atmp にコピーし、tmpimm で指定された位置に b の 128 ビット (2 つのパックド倍精度 (64 ビット) 浮動小数点要素) を挿入します。ゼロマスク k を使用して tmp を戻り値に格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask2_permutex2var_pd

__m128d _mm_mask2_permutex2var_pd(__m128d a, __m128i idx, __mmask8 k, __m128d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2pd

idx の対応するセレクターとインデックスを使用して、ab の倍精度 (64 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は idx の要素がコピーされます)。



_mm256_mask2_permutex2var_pd

__m256d _mm256_mask2_permutex2var_pd(__m256d a, __m256i idx, __mmask8 k, __m256d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2pd

idx の対応するセレクターとインデックスを使用して、ab の倍精度 (64 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は idx の要素がコピーされます)。



_mm_maskz_permutex2var_pd

__m128d _mm_maskz_permutex2var_pd(__mmask8 k, __m128d a, __m128i idx, __m128d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2pd、vpermt2pd

idx の対応するセレクターとインデックスを使用して、ab の倍精度 (64 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_permutex2var_pd

__m128d _mm_permutex2var_pd(__m128d a, __m128i idx, __m128d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2pd、vpermt2pd

idx の対応するセレクターとインデックスを使用して、ab の倍精度 (64 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、結果を返します。



_mm256_maskz_permutex2var_pd

__m256d _mm256_maskz_permutex2var_pd(__mmask8 k, __m256d a, __m256i idx, __m256d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2pd、vpermt2pd

idx の対応するセレクターとインデックスを使用して、ab の倍精度 (64 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_permutex2var_pd

__m256d _mm256_permutex2var_pd(__m256d a, __m256i idx, __m256d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2pd、vpermt2pd

idx の対応するセレクターとインデックスを使用して、ab の倍精度 (64 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、結果を返します。



_mm_mask2_permutex2var_ps

__m128 _mm_mask2_permutex2var_ps(__m128 a, __m128i idx, __mmask8 k, __m128 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2ps

idx の対応するセレクターとインデックスを使用して、ab の単精度 (32 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は idx の要素がコピーされます)。



_mm256_mask2_permutex2var_ps

__m256 _mm256_mask2_permutex2var_ps(__m256 a, __m256i idx, __mmask8 k, __m256 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2ps

idx の対応するセレクターとインデックスを使用して、ab の単精度 (32 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は idx の要素がコピーされます)。



_mm_maskz_permutex2var_ps

__m128 _mm_maskz_permutex2var_ps(__mmask8 k, __m128 a, __m128i idx, __m128 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2ps、vpermt2ps

idx の対応するセレクターとインデックスを使用して、ab の単精度 (32 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_permutex2var_ps

__m128 _mm_permutex2var_ps(__m128 a, __m128i idx, __m128 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2ps、vpermt2ps

idx の対応するセレクターとインデックスを使用して、ab の単精度 (32 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、結果を返します。



_mm256_maskz_permutex2var_ps

__m256 _mm256_maskz_permutex2var_ps(__mmask8 k, __m256 a, __m256i idx, __m256 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2ps、vpermt2ps

idx の対応するセレクターとインデックスを使用して、ab の単精度 (32 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_permutex2var_ps

__m256 _mm256_permutex2var_ps(__m256 a, __m256i idx, __m256 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2ps、vpermt2ps

idx の対応するセレクターとインデックスを使用して、ab の単精度 (32 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、結果を返します。



_mm_mask_permute_pd

__m128d _mm_mask_permute_pd(__m128d src, __mmask8 k, __m128d a, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermilpd

imm のコントロールを使用して、a の倍精度 (64 ビット) 浮動小数点要素をシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_mask_permutevar_pd

__m128d _mm_mask_permutevar_pd(__m128d src, __mmask8 k, __m128d a, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermilpd

b のコントロールを使用して、a の倍精度 (64 ビット) 浮動小数点要素をシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_permute_pd

__m128d _mm_maskz_permute_pd(__mmask8 k, __m128d a, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermilpd

imm のコントロールを使用して、a の倍精度 (64 ビット) 浮動小数点要素をシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_maskz_permutevar_pd

__m128d _mm_maskz_permutevar_pd(__mmask8 k, __m128d a, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermilpd

b のコントロールを使用して、a の倍精度 (64 ビット) 浮動小数点要素をシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_permute_pd

__m256d _mm256_mask_permute_pd(__m256d src, __mmask8 k, __m256d a, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermilpd

imm のコントロールを使用して、a の倍精度 (64 ビット) 浮動小数点要素を 128 ビット・レーン内でシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_mask_permutevar_pd

__m256d _mm256_mask_permutevar_pd(__m256d src, __mmask8 k, __m256d a, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermilpd

b のコントロールを使用して、a の倍精度 (64 ビット) 浮動小数点要素を 128 ビット・レーン内でシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_permute_pd

__m256d _mm256_maskz_permute_pd(__mmask8 k, __m256d a, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermilpd

imm のコントロールを使用して、a の倍精度 (64 ビット) 浮動小数点要素を 128 ビット・レーン内でシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_maskz_permutevar_pd

__m256d _mm256_maskz_permutevar_pd(__mmask8 k, __m256d a, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermilpd

b のコントロールを使用して、a の倍精度 (64 ビット) 浮動小数点要素を 128 ビット・レーン内でシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_permute_ps

__m128 _mm_mask_permute_ps(__m128 src, __mmask8 k, __m128 a, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermilps

imm のコントロールを使用して、a の単精度 (32 ビット) 浮動小数点要素をシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_mask_permutevar_ps

__m128 _mm_mask_permutevar_ps(__m128 src, __mmask8 k, __m128 a, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermilps

b のコントロールを使用して、a の単精度 (32 ビット) 浮動小数点要素をシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_permute_ps

__m128 _mm_maskz_permute_ps(__mmask8 k, __m128 a, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermilps

imm のコントロールを使用して、a の単精度 (32 ビット) 浮動小数点要素をシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_maskz_permutevar_ps

__m128 _mm_maskz_permutevar_ps(__mmask8 k, __m128 a, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermilps

b のコントロールを使用して、a の単精度 (32 ビット) 浮動小数点要素をシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_permute_ps

__m256 _mm256_mask_permute_ps(__m256 src, __mmask8 k, __m256 a, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermilps

imm のコントロールを使用して、a の単精度 (32 ビット) 浮動小数点要素を 128 ビット・レーン内でシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_mask_permutevar_ps

__m256 _mm256_mask_permutevar_ps(__m256 src, __mmask8 k, __m256 a, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermilps

b のコントロールを使用して、a の単精度 (32 ビット) 浮動小数点要素を 128 ビット・レーン内でシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_permute_ps

__m256 _mm256_maskz_permute_ps(__mmask8 k, __m256 a, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermilps

imm のコントロールを使用して、a の単精度 (32 ビット) 浮動小数点要素を 128 ビット・レーン内でシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_maskz_permutevar_ps

__m256 _mm256_maskz_permutevar_ps(__mmask8 k, __m256 a, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermilps

b のコントロールを使用して、a の単精度 (32 ビット) 浮動小数点要素を 128 ビット・レーン内でシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_permutex_pd

__m256d _mm256_mask_permutex_pd(__m256d src, __mmask8 k, __m256d a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermpd

imm のコントロールを使用して、a の倍精度 (64 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_mask_permutexvar_pd

__m256d _mm256_mask_permutexvar_pd(__m256d src, __mmask8 k, __m256i idx, __m256d a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermpd

idx の対応するインデックスを使用して、a の倍精度 (64 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_permutex_pd

__m256d _mm256_maskz_permutex_pd(__mmask8 k, __m256d a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermpd

imm のコントロールを使用して、a の倍精度 (64 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_maskz_permutexvar_pd

__m256d _mm256_maskz_permutexvar_pd(__mmask8 k, __m256i idx, __m256d a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermpd

idx の対応するインデックスを使用して、a の倍精度 (64 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_permutex_pd

__m256d _mm256_permutex_pd(__m256d a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermpd

imm のコントロールを使用して、a の倍精度 (64 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、結果を返します。



_mm256_permutexvar_pd

__m256d _mm256_permutexvar_pd(__m256i idx, __m256d a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermpd

idx のコントロールを使用して、a の倍精度 (64 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、結果を返します。



_mm256_mask_permutexvar_ps

__m256 _mm256_mask_permutexvar_ps(__m256 src, __mmask8 k, __m256i idx, __m256 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermps

idx の対応するインデックスを使用して、a の単精度 (32 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_permutexvar_ps

__m256 _mm256_maskz_permutexvar_ps(__mmask8 k, __m256i idx, __m256 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermps

idx の対応するインデックスを使用して、a の単精度 (32 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_permutexvar_ps

__m256 _mm256_permutexvar_ps(__m256i idx, __m256 a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermps

idx の対応するインデックスを使用して、a の単精度 (32 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルします。



_mm_mask_permutex2var_pd

__m128d _mm_mask_permutex2var_pd(__m128d a, __mmask8 k, __m128i idx, __m128d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermt2pd

idx の対応するセレクターとインデックスを使用して、ab の倍精度 (64 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は a の要素がコピーされます)。



_mm256_mask_permutex2var_pd

__m256d _mm256_mask_permutex2var_pd(__m256d a, __mmask8 k, __m256i idx, __m256d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermt2pd

idx の対応するセレクターとインデックスを使用して、ab の倍精度 (64 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は a の要素がコピーされます)。



_mm_mask_permutex2var_ps

__m128 _mm_mask_permutex2var_ps(__m128 a, __mmask8 k, __m128i idx, __m128 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermt2ps

idx の対応するセレクターとインデックスを使用して、ab の単精度 (32 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は a の要素がコピーされます)。



_mm256_mask_permutex2var_ps

__m256 _mm256_mask_permutex2var_ps(__m256 a, __mmask8 k, __m256i idx, __m256 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermt2ps

idx の対応するセレクターとインデックスを使用して、ab の単精度 (32 ビット) 浮動小数点要素を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は a の要素がコピーされます)。



_mm_mask_range_pd

__m128d _mm_mask_range_pd(__m128d src, __mmask8 k, __m128d a, __m128d b, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vrangepd

imm のコントロールに応じて、ab のパックド倍精度 (64 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_range_pd

__m128d _mm_maskz_range_pd(__mmask8 k, __m128d a, __m128d b, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vrangepd

imm のコントロールに応じて、ab のパックド倍精度 (64 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_range_pd

__m128d _mm_range_pd(__m128d a, __m128d b, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vrangepd

imm のコントロールに応じて、ab のパックド倍精度 (64 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、結果を返します。



_mm256_mask_range_pd

__m256d _mm256_mask_range_pd(__m256d src, __mmask8 k, __m256d a, __m256d b, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vrangepd

imm のコントロールに応じて、ab のパックド倍精度 (64 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_range_pd

__m256d _mm256_maskz_range_pd(__mmask8 k, __m256d a, __m256d b, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vrangepd

imm のコントロールに応じて、ab のパックド倍精度 (64 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_range_pd

__m256d _mm256_range_pd(__m256d a, __m256d b, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vrangepd

imm のコントロールに応じて、ab のパックド倍精度 (64 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、結果を返します。



_mm512_mask_range_pd

__m512d _mm512_mask_range_pd(__m512d src, __mmask8 k, __m512d a, __m512d b, int imm)

CPUID フラグ: AVX512DQ

命令: vrangepd

imm のコントロールに応じて、ab のパックド倍精度 (64 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_mask_range_round_pd

__m512d _mm512_mask_range_round_pd(__m512d src, __mmask8 k, __m512d a, __m512d b, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vrangepd

imm のコントロールに応じて、ab のパックド倍精度 (64 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_range_pd

__m512d _mm512_maskz_range_pd(__mmask8 k, __m512d a, __m512d b, int imm)

CPUID フラグ: AVX512DQ

命令: vrangepd

imm のコントロールに応じて、ab のパックド倍精度 (64 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_maskz_range_round_pd

__m512d _mm512_maskz_range_round_pd(__mmask8 k, __m512d a, __m512d b, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vrangepd

imm のコントロールに応じて、ab のパックド倍精度 (64 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_range_pd

__m512d _mm512_range_pd(__m512d a, __m512d b, int imm)

CPUID フラグ: AVX512DQ

命令: vrangepd

imm のコントロールに応じて、ab のパックド倍精度 (64 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、結果を返します。



_mm512_range_round_pd

__m512d _mm512_range_round_pd(__m512d a, __m512d b, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vrangepd

imm のコントロールに応じて、ab のパックド倍精度 (64 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、結果を返します。



_mm_mask_range_ps

__m128 _mm_mask_range_ps(__m128 src, __mmask8 k, __m128 a, __m128 b, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vrangeps

imm のコントロールに応じて、ab のパックド単精度 (32 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_range_ps

__m128 _mm_maskz_range_ps(__mmask8 k, __m128 a, __m128 b, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vrangeps

imm のコントロールに応じて、ab のパックド単精度 (32 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_range_ps

__m128 _mm_range_ps(__m128 a, __m128 b, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vrangeps

imm のコントロールに応じて、ab のパックド単精度 (32 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、結果を返します。



_mm256_mask_range_ps

__m256 _mm256_mask_range_ps(__m256 src, __mmask8 k, __m256 a, __m256 b, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vrangeps

imm のコントロールに応じて、ab のパックド単精度 (32 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_range_ps

__m256 _mm256_maskz_range_ps(__mmask8 k, __m256 a, __m256 b, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vrangeps

imm のコントロールに応じて、ab のパックド単精度 (32 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_range_ps

__m256 _mm256_range_ps(__m256 a, __m256 b, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vrangeps

imm のコントロールに応じて、ab のパックド単精度 (32 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、結果を返します。



_mm512_mask_range_ps

__m512 _mm512_mask_range_ps(__m512 src, __mmask16 k, __m512 a, __m512 b, int imm)

CPUID フラグ: AVX512DQ

命令: vrangeps

imm のコントロールに応じて、ab のパックド単精度 (32 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_mask_range_round_ps

__m512 _mm512_mask_range_round_ps(__m512 src, __mmask16 k, __m512 a, __m512 b, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vrangeps

imm のコントロールに応じて、ab のパックド単精度 (32 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_range_ps

__m512 _mm512_maskz_range_ps(__mmask16 k, __m512 a, __m512 b, int imm)

CPUID フラグ: AVX512DQ

命令: vrangeps

imm のコントロールに応じて、ab のパックド単精度 (32 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_maskz_range_round_ps

__m512 _mm512_maskz_range_round_ps(__mmask16 k, __m512 a, __m512 b, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vrangeps

imm のコントロールに応じて、ab のパックド単精度 (32 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_range_ps

__m512 _mm512_range_ps(__m512 a, __m512 b, int imm)

CPUID フラグ: AVX512DQ

命令: vrangeps

imm のコントロールに応じて、ab のパックド単精度 (32 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、結果を返します。



_mm512_range_round_ps

__m512 _mm512_range_round_ps(__m512 a, __m512 b, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vrangeps

imm のコントロールに応じて、ab のパックド単精度 (32 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、結果を返します。



_mm_mask_range_round_sd

__m128d _mm_mask_range_round_sd(__m128d src, __mmask8 k, __m128d a, __m128d b, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vrangesd

imm のコントロールに応じて、ab の下位の倍精度 (64 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、書き込みマスク k を使用して結果を戻り値の下位要素に格納し (マスクビット 0 が設定されていない場合は src の要素がコピーされます)、a の上位要素を dst の上位要素にコピーします。



_mm_mask_range_sd

__m128d _mm_mask_range_sd(__m128d src, __mmask8 k, __m128d a, __m128d b, int imm)

CPUID フラグ: AVX512DQ

命令: vrangesd

imm のコントロールに応じて、ab の下位の倍精度 (64 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、書き込みマスク k を使用して結果を戻り値の下位要素に格納し (マスクビット 0 が設定されていない場合は src の要素がコピーされます)、a の上位要素を dst の上位要素にコピーします。



_mm_maskz_range_round_sd

__m128d _mm_maskz_range_round_sd(__mmask8 k, __m128d a, __m128d b, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vrangesd

imm のコントロールに応じて、ab の下位の倍精度 (64 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、ゼロマスク k を使用して結果を戻り値の下位要素に格納し (マスクビット 0 が設定されていない場合は要素が 0 に設定されます)、a の上位要素を dst の上位要素にコピーします。



_mm_maskz_range_sd

__m128d _mm_maskz_range_sd(__mmask8 k, __m128d a, __m128d b, int imm)

CPUID フラグ: AVX512DQ

命令: vrangesd

imm のコントロールに応じて、ab の下位の倍精度 (64 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、ゼロマスク k を使用して結果を戻り値の下位要素に格納し (マスクビット 0 が設定されていない場合は要素が 0 に設定されます)、a の上位要素を dst の上位要素にコピーします。



_mm_range_round_sd

__m128d _mm_range_round_sd(__m128d a, __m128d b, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vrangesd

imm のコントロールに応じて、ab の下位の倍精度 (64 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、結果を戻り値の下位要素に格納し、a の上位要素を dst の上位要素にコピーします。



_mm_mask_range_round_ss

__m128 _mm_mask_range_round_ss(__m128 src, __mmask8 k, __m128 a, __m128 b, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vrangess

imm のコントロールに応じて、ab の下位の単精度 (32 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、書き込みマスク k を使用して結果を戻り値の下位要素に格納し (マスクビット 0 が設定されていない場合は src の要素がコピーされます)、a の上位 3 つのパックド要素を dst の上位要素にコピーします。



_mm_mask_range_ss

__m128 _mm_mask_range_ss(__m128 src, __mmask8 k, __m128 a, __m128 b, int imm)

CPUID フラグ: AVX512DQ

命令: vrangess

imm のコントロールに応じて、ab の下位の単精度 (32 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、書き込みマスク k を使用して結果を戻り値の下位要素に格納し (マスクビット 0 が設定されていない場合は src の要素がコピーされます)、a の上位 3 つのパックド要素を dst の上位要素にコピーします。



_mm_maskz_range_round_ss

__m128 _mm_maskz_range_round_ss(__mmask8 k, __m128 a, __m128 b, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vrangess

imm のコントロールに応じて、ab の下位の単精度 (32 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、ゼロマスク k を使用して結果を戻り値の下位要素に格納し (マスクビット 0 が設定されていない場合は要素が 0 に設定されます)、a の上位 3 つのパックド要素を dst の上位要素にコピーします。



_mm_maskz_range_ss

__m128 _mm_maskz_range_ss(__mmask8 k, __m128 a, __m128 b, int imm)

CPUID フラグ: AVX512DQ

命令: vrangess

imm のコントロールに応じて、ab の下位の単精度 (32 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、ゼロマスク k を使用して結果を戻り値の下位要素に格納し (マスクビット 0 が設定されていない場合は要素が 0 に設定されます)、a の上位 3 つのパックド要素を dst の上位要素にコピーします。



_mm_range_round_ss

__m128 _mm_range_round_ss(__m128 a, __m128 b, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vrangess

imm のコントロールに応じて、ab の下位の単精度 (32 ビット) 浮動小数点要素の最大値、最小値、絶対最大値、または絶対最小値を計算し、結果を戻り値の下位要素に格納し、a の上位 3 つのパックド要素を dst の上位要素にコピーします。



_mm_mask_reduce_pd

__m128d _mm_mask_reduce_pd(__m128d src, __mmask8 k, __m128d a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vreducepd

a のパックド倍精度 (64 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_reduce_pd

__m128d _mm_maskz_reduce_pd(__mmask8 k, __m128d a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vreducepd

a のパックド倍精度 (64 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_reduce_pd

__m128d _mm_reduce_pd(__m128d a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vreducepd

a のパックド倍精度 (64 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、結果を返します。



_mm256_mask_reduce_pd

__m256d _mm256_mask_reduce_pd(__m256d src, __mmask8 k, __m256d a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vreducepd

a のパックド倍精度 (64 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_reduce_pd

__m256d _mm256_maskz_reduce_pd(__mmask8 k, __m256d a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vreducepd

a のパックド倍精度 (64 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_reduce_pd

__m256d _mm256_reduce_pd(__m256d a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vreducepd

a のパックド倍精度 (64 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、結果を返します。



_mm512_mask_reduce_pd

__m512d _mm512_mask_reduce_pd(__m512d src, __mmask8 k, __m512d a, int imm)

CPUID フラグ: AVX512DQ

命令: vreducepd

a のパックド倍精度 (64 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_mask_reduce_round_pd

__m512d _mm512_mask_reduce_round_pd(__m512d src, __mmask8 k, __m512d a, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vreducepd

a のパックド倍精度 (64 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_reduce_pd

__m512d _mm512_maskz_reduce_pd(__mmask8 k, __m512d a, int imm)

CPUID フラグ: AVX512DQ

命令: vreducepd

a のパックド倍精度 (64 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_maskz_reduce_round_pd

__m512d _mm512_maskz_reduce_round_pd(__mmask8 k, __m512d a, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vreducepd

a のパックド倍精度 (64 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_reduce_pd

__m512d _mm512_reduce_pd(__m512d a, int imm)

CPUID フラグ: AVX512DQ

命令: vreducepd

a のパックド倍精度 (64 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、結果を返します。



_mm512_reduce_round_pd

__m512d _mm512_reduce_round_pd(__m512d a, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vreducepd

a のパックド倍精度 (64 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、結果を返します。



_mm_mask_reduce_ps

__m128 _mm_mask_reduce_ps(__m128 src, __mmask8 k, __m128 a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vreduceps

a のパックド単精度 (32 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_reduce_ps

__m128 _mm_maskz_reduce_ps(__mmask8 k, __m128 a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vreduceps

a のパックド単精度 (32 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_reduce_ps

__m128 _mm_reduce_ps(__m128 a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vreduceps

a のパックド単精度 (32 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、結果を返します。



_mm256_mask_reduce_ps

__m256 _mm256_mask_reduce_ps(__m256 src, __mmask8 k, __m256 a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vreduceps

a のパックド単精度 (32 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_reduce_ps

__m256 _mm256_maskz_reduce_ps(__mmask8 k, __m256 a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vreduceps

a のパックド単精度 (32 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_reduce_ps

__m256 _mm256_reduce_ps(__m256 a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vreduceps

a のパックド単精度 (32 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、結果を返します。



_mm512_mask_reduce_ps

__m512 _mm512_mask_reduce_ps(__m512 src, __mmask16 k, __m512 a, int imm)

CPUID フラグ: AVX512DQ

命令: vreduceps

a のパックド単精度 (32 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_mask_reduce_round_ps

__m512 _mm512_mask_reduce_round_ps(__m512 src, __mmask16 k, __m512 a, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vreduceps

a のパックド単精度 (32 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_reduce_ps

__m512 _mm512_maskz_reduce_ps(__mmask16 k, __m512 a, int imm)

CPUID フラグ: AVX512DQ

命令: vreduceps

a のパックド単精度 (32 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_maskz_reduce_round_ps

__m512 _mm512_maskz_reduce_round_ps(__mmask16 k, __m512 a, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vreduceps

a のパックド単精度 (32 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_reduce_ps

__m512 _mm512_reduce_ps(__m512 a, int imm)

CPUID フラグ: AVX512DQ

命令: vreduceps

a のパックド単精度 (32 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、結果を返します。



_mm512_reduce_round_ps

__m512 _mm512_reduce_round_ps(__m512 a, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vreduceps

a のパックド単精度 (32 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、結果を返します。



_mm_mask_reduce_round_sd

__m128d _mm_mask_reduce_round_sd(__m128d src, __mmask8 k, __m128d a, __m128d b, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vreducesd

a の下位の倍精度 (64 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、書き込みマスク k を使用して結果を戻り値の下位要素に格納し (マスクビット 0 が設定されていない場合は src の要素がコピーされます)、b の上位要素を dst の上位要素にコピーします。



_mm_mask_reduce_sd

__m128d _mm_mask_reduce_sd(__m128d src, __mmask8 k, __m128d a, __m128d b, int imm)

CPUID フラグ: AVX512DQ

命令: vreducesd

a の下位の倍精度 (64 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、書き込みマスク k を使用して結果を戻り値の下位要素に格納し (マスクビット 0 が設定されていない場合は src の要素がコピーされます)、b の上位要素を dst の上位要素にコピーします。



_mm_maskz_reduce_round_sd

__m128d _mm_maskz_reduce_round_sd(__mmask8 k, __m128d a, __m128d b, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vreducesd

a の下位の倍精度 (64 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、ゼロマスク k を使用して結果を戻り値の下位要素に格納し (マスクビット 0 が設定されていない場合は要素が 0 に設定されます)、b の上位要素を dst の上位要素にコピーします。



_mm_maskz_reduce_sd

__m128d _mm_maskz_reduce_sd(__mmask8 k, __m128d a, __m128d b, int imm)

CPUID フラグ: AVX512DQ

命令: vreducesd

a の下位の倍精度 (64 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、ゼロマスク k を使用して結果を戻り値の下位要素に格納し (マスクビット 0 が設定されていない場合は要素が 0 に設定されます)、b の上位要素を dst の上位要素にコピーします。



_mm_reduce_round_sd

__m128d _mm_reduce_round_sd(__m128d a, __m128d b, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vreducesd

a の下位の倍精度 (64 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、結果を戻り値の下位要素に格納し、b の上位要素を dst の上位要素にコピーします。



_mm_reduce_sd

__m128d _mm_reduce_sd(__m128d a, __m128d b, int imm)

CPUID フラグ: AVX512DQ

命令: vreducesd

a の下位の倍精度 (64 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、結果を戻り値の下位要素に格納し、b の上位要素を dst の上位要素にコピーします。



_mm_mask_reduce_round_ss

__m128 _mm_mask_reduce_round_ss(__m128 src, __mmask8 k, __m128 a, __m128 b, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vreducess

a の下位の単精度 (32 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、書き込みマスク k を使用して結果を戻り値の下位要素に格納し (マスクビット 0 が設定されていない場合は src の要素がコピーされます)、b の上位 3 つのパックド要素を dst の上位要素にコピーします。



_mm_mask_reduce_ss

__m128 _mm_mask_reduce_ss(__m128 src, __mmask8 k, __m128 a, __m128 b, int imm)

CPUID フラグ: AVX512DQ

命令: vreducess

a の下位の単精度 (32 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、書き込みマスク k を使用して結果を戻り値の下位要素に格納し (マスクビット 0 が設定されていない場合は src の要素がコピーされます)、b の上位 3 つのパックド要素を dst の上位要素にコピーします。



_mm_maskz_reduce_round_ss

__m128 _mm_maskz_reduce_round_ss(__mmask8 k, __m128 a, __m128 b, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vreducess

a の下位の単精度 (32 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、ゼロマスク k を使用して結果を戻り値の下位要素に格納し (マスクビット 0 が設定されていない場合は要素が 0 に設定されます)、b の上位 3 つのパックド要素を dst の上位要素にコピーします。



_mm_maskz_reduce_ss

__m128 _mm_maskz_reduce_ss(__mmask8 k, __m128 a, __m128 b, int imm)

CPUID フラグ: AVX512DQ

命令: vreducess

a の下位の単精度 (32 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、ゼロマスク k を使用して結果を戻り値の下位要素に格納し (マスクビット 0 が設定されていない場合は要素が 0 に設定されます)、b の上位 3 つのパックド要素を dst の上位要素にコピーします。



_mm_reduce_round_ss

__m128 _mm_reduce_round_ss(__m128 a, __m128 b, int imm, int rounding)

CPUID フラグ: AVX512DQ

命令: vreducess

a の下位の単精度 (32 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、結果を戻り値の下位要素に格納し、b の上位 3 つのパックド要素を dst の上位要素にコピーします。



_mm_reduce_ss

__m128 _mm_reduce_ss(__m128 a, __m128 b, int imm)

CPUID フラグ: AVX512DQ

命令: vreducess

a の下位の単精度 (32 ビット) 浮動小数点要素を imm で指定したビット数にレデュースし、結果を戻り値の下位要素に格納し、b の上位 3 つのパックド要素を dst の上位要素にコピーします。



_mm_mask_roundscale_pd

__m128d _mm_mask_roundscale_pd(__m128d src, __mmask8 k, __m128d a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vrndscalepd

a のパックド倍精度 (64 ビット) 浮動小数点要素を imm で指定した小数の桁数に丸め、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_roundscale_pd

__m128d _mm_maskz_roundscale_pd(__mmask8 k, __m128d a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vrndscalepd

a のパックド倍精度 (64 ビット) 浮動小数点要素を imm で指定した小数の桁数に丸め、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_roundscale_pd

__m128d _mm_roundscale_pd(__m128d a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vrndscalepd

a のパックド倍精度 (64 ビット) 浮動小数点要素を imm で指定した小数の桁数に丸め、結果を返します。



_mm256_mask_roundscale_pd

__m256d _mm256_mask_roundscale_pd(__m256d src, __mmask8 k, __m256d a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vrndscalepd

a のパックド倍精度 (64 ビット) 浮動小数点要素を imm で指定した小数の桁数に丸め、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_roundscale_pd

__m256d _mm256_maskz_roundscale_pd(__mmask8 k, __m256d a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vrndscalepd

a のパックド倍精度 (64 ビット) 浮動小数点要素を imm で指定した小数の桁数に丸め、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_roundscale_pd

__m256d _mm256_roundscale_pd(__m256d a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vrndscalepd

a のパックド倍精度 (64 ビット) 浮動小数点要素を imm で指定した小数の桁数に丸め、結果を返します。



_mm_mask_roundscale_ps

__m128 _mm_mask_roundscale_ps(__m128 src, __mmask8 k, __m128 a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vrndscaleps

a のパックド単精度 (32 ビット) 浮動小数点要素を imm で指定した小数の桁数に丸め、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_roundscale_ps

__m128 _mm_maskz_roundscale_ps(__mmask8 k, __m128 a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vrndscaleps

a のパックド単精度 (32 ビット) 浮動小数点要素を imm で指定した小数の桁数に丸め、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_roundscale_ps

__m128 _mm_roundscale_ps(__m128 a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vrndscaleps

a のパックド単精度 (32 ビット) 浮動小数点要素を imm で指定した小数の桁数に丸め、結果を返します。



_mm256_mask_roundscale_ps

__m256 _mm256_mask_roundscale_ps(__m256 src, __mmask8 k, __m256 a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vrndscaleps

a のパックド単精度 (32 ビット) 浮動小数点要素を imm で指定した小数の桁数に丸め、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_roundscale_ps

__m256 _mm256_maskz_roundscale_ps(__mmask8 k, __m256 a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vrndscaleps

a のパックド単精度 (32 ビット) 浮動小数点要素を imm で指定した小数の桁数に丸め、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_roundscale_ps

__m256 _mm256_roundscale_ps(__m256 a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vrndscaleps

a のパックド単精度 (32 ビット) 浮動小数点要素を imm で指定した小数の桁数に丸め、結果を返します。



_mm_mask_scalef_pd

__m128d _mm_mask_scalef_pd(__m128d src, __mmask8 k, __m128d a, __m128d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vscalefpd

b の値を使用して、a のパックド倍精度 (64 ビット) 浮動小数点要素をスケーリングし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_scalef_pd

__m128d _mm_maskz_scalef_pd(__mmask8 k, __m128d a, __m128d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vscalefpd

b の値を使用して、a のパックド倍精度 (64 ビット) 浮動小数点要素をスケーリングし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_scalef_pd

__m128d _mm_scalef_pd(__m128d a, __m128d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vscalefpd

b の値を使用して、a のパックド倍精度 (64 ビット) 浮動小数点要素をスケーリングし、結果を返します。



_mm256_mask_scalef_pd

__m256d _mm256_mask_scalef_pd(__m256d src, __mmask8 k, __m256d a, __m256d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vscalefpd

b の値を使用して、a のパックド倍精度 (64 ビット) 浮動小数点要素をスケーリングし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_scalef_pd

__m256d _mm256_maskz_scalef_pd(__mmask8 k, __m256d a, __m256d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vscalefpd

b の値を使用して、a のパックド倍精度 (64 ビット) 浮動小数点要素をスケーリングし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_scalef_pd

__m256d _mm256_scalef_pd(__m256d a, __m256d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vscalefpd

b の値を使用して、a のパックド倍精度 (64 ビット) 浮動小数点要素をスケーリングし、結果を返します。



_mm_mask_scalef_ps

__m128 _mm_mask_scalef_ps(__m128 src, __mmask8 k, __m128 a, __m128 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vscalefps

b の値を使用して、a のパックド単精度 (32 ビット) 浮動小数点要素をスケーリングし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_scalef_ps

__m128 _mm_maskz_scalef_ps(__mmask8 k, __m128 a, __m128 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vscalefps

b の値を使用して、a のパックド単精度 (32 ビット) 浮動小数点要素をスケーリングし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_scalef_ps

__m128 _mm_scalef_ps(__m128 a, __m128 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vscalefps

b の値を使用して、a のパックド単精度 (32 ビット) 浮動小数点要素をスケーリングし、結果を返します。



_mm256_mask_scalef_ps

__m256 _mm256_mask_scalef_ps(__m256 src, __mmask8 k, __m256 a, __m256 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vscalefps

b の値を使用して、a のパックド単精度 (32 ビット) 浮動小数点要素をスケーリングし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_scalef_ps

__m256 _mm256_maskz_scalef_ps(__mmask8 k, __m256 a, __m256 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vscalefps

b の値を使用して、a のパックド単精度 (32 ビット) 浮動小数点要素をスケーリングし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_scalef_ps

__m256 _mm256_scalef_ps(__m256 a, __m256 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vscalefps

b の値を使用して、a のパックド単精度 (32 ビット) 浮動小数点要素をスケーリングし、結果を返します。



_mm256_mask_shuffle_f32x4

__m256 _mm256_mask_shuffle_f32x4(__m256 src, __mmask8 k, __m256 a, __m256 b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshuff32x4

imm で選択された ab の 128 ビット (4 つの単精度 (32 ビット) 浮動小数点要素) をシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_shuffle_f32x4

__m256 _mm256_maskz_shuffle_f32x4(__mmask8 k, __m256 a, __m256 b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshuff32x4

imm で選択された ab の 128 ビット (4 つの単精度 (32 ビット) 浮動小数点要素) をシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_shuffle_f32x4

__m256 _mm256_shuffle_f32x4(__m256 a, __m256 b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshuff32x4

imm で選択された ab の 128 ビット (4 つの単精度 (32 ビット) 浮動小数点要素) をシャッフルし、ゼロマスク k を使用して結果を返します。



_mm256_mask_shuffle_f64x2

__m256d _mm256_mask_shuffle_f64x2(__m256d src, __mmask8 k, __m256d a, __m256d b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshuff64x2

imm で選択された ab の 128 ビット (2 つの倍精度 (64 ビット) 浮動小数点要素) をシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_shuffle_f64x2

__m256d _mm256_maskz_shuffle_f64x2(__mmask8 k, __m256d a, __m256d b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshuff64x2

imm で選択された ab の 128 ビット (2 つの倍精度 (64 ビット) 浮動小数点要素) をシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_shuffle_f64x2

__m256d _mm256_shuffle_f64x2(__m256d a, __m256d b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshuff64x2

imm で選択された ab の 128 ビット (2 つの倍精度 (64 ビット) 浮動小数点要素) をシャッフルし、ゼロマスク k を使用して結果を返します。



_mm_mask_shuffle_pd

__m128d _mm_mask_shuffle_pd(__m128d src, __mmask8 k, __m128d a, __m128d b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshufpd

imm のコントロールを使用して、倍精度 (64 ビット) 浮動小数点要素をシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_shuffle_pd

__m128d _mm_maskz_shuffle_pd(__mmask8 k, __m128d a, __m128d b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshufpd

imm のコントロールを使用して、倍精度 (64 ビット) 浮動小数点要素をシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_shuffle_pd

__m256d _mm256_mask_shuffle_pd(__m256d src, __mmask8 k, __m256d a, __m256d b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshufpd

imm のコントロールを使用して、倍精度 (64 ビット) 浮動小数点要素を 128 ビット・レーン内でシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_shuffle_pd

__m256d _mm256_maskz_shuffle_pd(__mmask8 k, __m256d a, __m256d b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshufpd

imm のコントロールを使用して、倍精度 (64 ビット) 浮動小数点要素を 128 ビット・レーン内でシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_shuffle_ps

__m128 _mm_mask_shuffle_ps(__m128 src, __mmask8 k, __m128 a, __m128 b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshufps

imm のコントロールを使用して、a の単精度 (32 ビット) 浮動小数点要素をシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_shuffle_ps

__m128 _mm_maskz_shuffle_ps(__mmask8 k, __m128 a, __m128 b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshufps

imm のコントロールを使用して、a の単精度 (32 ビット) 浮動小数点要素をシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_shuffle_ps

__m256 _mm256_mask_shuffle_ps(__m256 src, __mmask8 k, __m256 a, __m256 b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshufps

imm のコントロールを使用して、a の単精度 (32 ビット) 浮動小数点要素を 128 ビット・レーン内でシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_shuffle_ps

__m256 _mm256_maskz_shuffle_ps(__mmask8 k, __m256 a, __m256 b, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vshufps

imm のコントロールを使用して、a の単精度 (32 ビット) 浮動小数点要素を 128 ビット・レーン内でシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_unpackhi_pd

__m128d _mm_mask_unpackhi_pd(__m128d src, __mmask8 k, __m128d a, __m128d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vunpckhpd

ab の上位半分から倍精度 (64 ビット) 浮動小数点要素をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_unpackhi_pd

__m128d _mm_maskz_unpackhi_pd(__mmask8 k, __m128d a, __m128d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vunpckhpd

ab の上位半分から倍精度 (64 ビット) 浮動小数点要素をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_unpackhi_pd

__m256d _mm256_mask_unpackhi_pd(__m256d src, __mmask8 k, __m256d a, __m256d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vunpckhpd

ab の各 128 ビット・レーンの上位半分から倍精度 (64 ビット) 浮動小数点要素をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_unpackhi_pd

__m256d _mm256_maskz_unpackhi_pd(__mmask8 k, __m256d a, __m256d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vunpckhpd

ab の各 128 ビット・レーンの上位半分から倍精度 (64 ビット) 浮動小数点要素をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_unpackhi_ps

__m128 _mm_mask_unpackhi_ps(__m128 src, __mmask8 k, __m128 a, __m128 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vunpckhps

ab の上位半分から単精度 (32 ビット) 浮動小数点要素をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_unpackhi_ps

__m128 _mm_maskz_unpackhi_ps(__mmask8 k, __m128 a, __m128 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vunpckhps

ab の上位半分から単精度 (32 ビット) 浮動小数点要素をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_unpackhi_ps

__m256 _mm256_mask_unpackhi_ps(__m256 src, __mmask8 k, __m256 a, __m256 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vunpckhps

ab の各 128 ビット・レーンの上位半分から単精度 (32 ビット) 浮動小数点要素をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_unpackhi_ps

__m256 _mm256_maskz_unpackhi_ps(__mmask8 k, __m256 a, __m256 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vunpckhps

ab の各 128 ビット・レーンの上位半分から単精度 (32 ビット) 浮動小数点要素をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_unpacklo_pd

__m128d _mm_mask_unpacklo_pd(__m128d src, __mmask8 k, __m128d a, __m128d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vunpcklpd

ab の下位半分から倍精度 (64 ビット) 浮動小数点要素をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_unpacklo_pd

__m128d _mm_maskz_unpacklo_pd(__mmask8 k, __m128d a, __m128d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vunpcklpd

ab の下位半分から倍精度 (64 ビット) 浮動小数点要素をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_unpacklo_pd

__m256d _mm256_mask_unpacklo_pd(__m256d src, __mmask8 k, __m256d a, __m256d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vunpcklpd

ab の各 128 ビット・レーンの下位半分から倍精度 (64 ビット) 浮動小数点要素をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_unpacklo_pd

__m256d _mm256_maskz_unpacklo_pd(__mmask8 k, __m256d a, __m256d b)

CPUID フラグ: AVX512F、AVX512VL

命令: vunpcklpd

ab の各 128 ビット・レーンの下位半分から倍精度 (64 ビット) 浮動小数点要素をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_unpacklo_ps

__m128 _mm_mask_unpacklo_ps(__m128 src, __mmask8 k, __m128 a, __m128 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vunpcklps

ab の下位半分から単精度 (32 ビット) 浮動小数点要素をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_unpacklo_ps

__m128 _mm_maskz_unpacklo_ps(__mmask8 k, __m128 a, __m128 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vunpcklps

ab の下位半分から単精度 (32 ビット) 浮動小数点要素をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_unpacklo_ps

__m256 _mm256_mask_unpacklo_ps(__m256 src, __mmask8 k, __m256 a, __m256 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vunpcklps

ab の各 128 ビット・レーンの下位半分から単精度 (32 ビット) 浮動小数点要素をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_unpacklo_ps

__m256 _mm256_maskz_unpacklo_ps(__mmask8 k, __m256 a, __m256 b)

CPUID フラグ: AVX512F、AVX512VL

命令: vunpcklps

ab の各 128 ビット・レーンの下位半分から単精度 (32 ビット) 浮動小数点要素をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_alignr_epi32

__m128i _mm_alignr_epi32(__m128i a, __m128i b, const int count)

CPUID フラグ: AVX512F、AVX512VL

命令: valignd

ab を結合し、32 バイトの中間結果を count 32 ビット要素分だけ右にシフトし、最終結果の下位 16 バイト (4 要素) を戻り値に格納します。



_mm_mask_alignr_epi32

__m128i _mm_mask_alignr_epi32(__m128i src, __mmask8 k, __m128i a, __m128i b, const int count)

CPUID フラグ: AVX512F、AVX512VL

命令: valignd

ab を結合し、32 バイトの中間結果を count 32 ビット要素分だけ右にシフトし、書き込みマスク k を使用して最終結果の下位 16 バイト (4 要素) を戻り値に格納します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_alignr_epi32

__m128i _mm_maskz_alignr_epi32(__mmask8 k, __m128i a, __m128i b, const int count)

CPUID フラグ: AVX512F、AVX512VL

命令: valignd

ab を結合し、32 バイトの中間結果を count 32 ビット要素分だけ右にシフトし、ゼロマスク k を使用して最終結果の下位 16 バイト (4 要素) を戻り値に格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_alignr_epi32

__m256i _mm256_alignr_epi32(__m256i a, __m256i b, const int count)

CPUID フラグ: AVX512F、AVX512VL

命令: valignd

ab を結合し、64 バイトの中間結果を count 32 ビット要素分だけ右にシフトし、最終結果の下位 32 バイト (8 要素) を戻り値に格納します。



_mm256_mask_alignr_epi32

__m256i _mm256_mask_alignr_epi32(__m256i src, __mmask8 k, __m256i a, __m256i b, const int count)

CPUID フラグ: AVX512F、AVX512VL

命令: valignd

ab を結合し、64 バイトの中間結果を count 32 ビット要素分だけ右にシフトし、書き込みマスク k を使用して最終結果の下位 32 バイト (8 要素) を戻り値に格納します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_alignr_epi32

__m256i _mm256_maskz_alignr_epi32(__mmask8 k, __m256i a, __m256i b, const int count)

CPUID フラグ: AVX512F、AVX512VL

命令: valignd

ab を結合し、64 バイトの中間結果を count 32 ビット要素分だけ右にシフトし、ゼロマスク k を使用して最終結果の下位 32 バイト (8 要素) を戻り値に格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_alignr_epi64

__m128i _mm_alignr_epi64(__m128i a, __m128i b, const int count)

CPUID フラグ: AVX512F、AVX512VL

命令: valignq

ab を結合し、32 バイトの中間結果を count 64 ビット要素分だけ右にシフトし、最終結果の下位 16 バイト (2 要素) を戻り値に格納します。



_mm_mask_alignr_epi64

__m128i _mm_mask_alignr_epi64(__m128i src, __mmask8 k, __m128i a, __m128i b, const int count)

CPUID フラグ: AVX512F、AVX512VL

命令: valignq

ab を結合し、32 バイトの中間結果を count 64 ビット要素分だけ右にシフトし、書き込みマスク k を使用して最終結果の下位 16 バイト (2 要素) を戻り値に格納します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_alignr_epi64

__m128i _mm_maskz_alignr_epi64(__mmask8 k, __m128i a, __m128i b, const int count)

CPUID フラグ: AVX512F、AVX512VL

命令: valignq

ab を結合し、32 バイトの中間結果を count 64 ビット要素分だけ右にシフトし、ゼロマスク k を使用して最終結果の下位 16 バイト (2 要素) を戻り値に格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_alignr_epi64

__m256i _mm256_alignr_epi64(__m256i a, __m256i b, const int count)

CPUID フラグ: AVX512F、AVX512VL

命令: valignq

ab を結合し、64 バイトの中間結果を count 64 ビット要素分だけ右にシフトし、最終結果の下位 32 バイト (4 要素) を戻り値に格納します。



_mm256_mask_alignr_epi64

__m256i _mm256_mask_alignr_epi64(__m256i src, __mmask8 k, __m256i a, __m256i b, const int count)

CPUID フラグ: AVX512F、AVX512VL

命令: valignq

ab を結合し、64 バイトの中間結果を count 64 ビット要素分だけ右にシフトし、書き込みマスク k を使用して最終結果の下位 32 バイト (4 要素) を戻り値に格納します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_alignr_epi64

__m256i _mm256_maskz_alignr_epi64(__mmask8 k, __m256i a, __m256i b, const int count)

CPUID フラグ: AVX512F、AVX512VL

命令: valignq

ab を結合し、64 バイトの中間結果を count 64 ビット要素分だけ右にシフトし、ゼロマスク k を使用して最終結果の下位 32 バイト (4 要素) を戻り値に格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_dbsad_epu8

__m128i _mm_dbsad_epu8(__m128i a, __m128i b, int imm)

CPUID フラグ: AVX512BW、AVX512VL

命令: vdbpsadbw

ab の対応する 4 つの符号なし 8 ビット整数の差分絶対値和 (SAD) を計算し、16 ビットの結果を戻り値に格納します。



_mm_mask_dbsad_epu8

__m128i _mm_mask_dbsad_epu8(__m128i src, __mmask8 k, __m128i a, __m128i b, int imm)

CPUID フラグ: AVX512BW、AVX512VL

命令: vdbpsadbw

ab の対応する 4 つの符号なし 8 ビット整数の差分絶対値和 (SAD) を計算し、書き込みマスク k を使用して 16 ビットの結果を戻り値に格納します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_dbsad_epu8

__m128i _mm_maskz_dbsad_epu8(__mmask8 k, __m128i a, __m128i b, int imm)

CPUID フラグ: AVX512BW、AVX512VL

命令: vdbpsadbw

ab の対応する 4 つの符号なし 8 ビット整数の差分絶対値和 (SAD) を計算し、ゼロマスク k を使用して 16 ビットの結果を戻り値に格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_dbsad_epu8

__m256i _mm256_dbsad_epu8(__m256i a, __m256i b, int imm)

CPUID フラグ: AVX512BW、AVX512VL

命令: vdbpsadbw

ab の対応する 4 つの符号なし 8 ビット整数の差分絶対値和 (SAD) を計算し、16 ビットの結果を戻り値に格納します。



_mm256_mask_dbsad_epu8

__m256i _mm256_mask_dbsad_epu8(__m256i src, __mmask16 k, __m256i a, __m256i b, int imm)

CPUID フラグ: AVX512BW、AVX512VL

命令: vdbpsadbw

ab の対応する 4 つの符号なし 8 ビット整数の差分絶対値和 (SAD) を計算し、書き込みマスク k を使用して 16 ビットの結果を戻り値に格納します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_dbsad_epu8

__m256i _mm256_maskz_dbsad_epu8(__mmask16 k, __m256i a, __m256i b, int imm)

CPUID フラグ: AVX512BW、AVX512VL

命令: vdbpsadbw

ab の対応する 4 つの符号なし 8 ビット整数の差分絶対値和 (SAD) を計算し、ゼロマスク k を使用して 16 ビットの結果を戻り値に格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_dbsad_epu8

__m512i _mm512_dbsad_epu8(__m512i a, __m512i b, int imm)

CPUID フラグ: AVX512BW

命令: vdbpsadbw

ab の対応する 4 つの符号なし 8 ビット整数の差分絶対値和 (SAD) を計算し、16 ビットの結果を戻り値に格納します。



_mm512_mask_dbsad_epu8

__m512i _mm512_mask_dbsad_epu8(__m512i src, __mmask32 k, __m512i a, __m512i b, int imm)

CPUID フラグ: AVX512BW

命令: vdbpsadbw

ab の対応する 4 つの符号なし 8 ビット整数の差分絶対値和 (SAD) を計算し、書き込みマスク k を使用して 16 ビットの結果を戻り値に格納します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_dbsad_epu8

__m512i _mm512_maskz_dbsad_epu8(__mmask32 k, __m512i a, __m512i b, int imm)

CPUID フラグ: AVX512BW

命令: vdbpsadbw

ab の対応する 4 つの符号なし 8 ビット整数の差分絶対値和 (SAD) を計算し、ゼロマスク k を使用して 16 ビットの結果を戻り値に格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_extracti32x4_epi32

__m128i _mm256_extracti32x4_epi32(__m256i a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vextracti32x4

imm で選択された 128 ビット (4 つのパックド 32 ビット整数) を a から抽出し、結果を戻り値に格納します。



_mm256_mask_extracti32x4_epi32

__m128i _mm256_mask_extracti32x4_epi32(__m128i src, __mmask8 k, __m256i a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vextracti32x4

imm で選択された 128 ビット (4 つのパックド 32 ビット整数) を a から抽出し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_extracti32x4_epi32

__m128i _mm256_maskz_extracti32x4_epi32(__mmask8 k, __m256i a, int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vextracti32x4

imm で選択された 128 ビット (4 つのパックド 32 ビット整数) を a から抽出し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_extracti32x8_epi32

__m256i _mm512_extracti32x8_epi32(__m512i a, int imm)

CPUID フラグ: AVX512DQ

命令: vextracti32x8

imm で選択された 256 ビット (8 つのパックド 32 ビット整数) を a から抽出し、結果を戻り値に格納します。



_mm512_mask_extracti32x8_epi32

__m256i _mm512_mask_extracti32x8_epi32(__m256i src, __mmask8 k, __m512i a, int imm)

CPUID フラグ: AVX512DQ

命令: vextracti32x8

imm で選択された 256 ビット (8 つのパックド 32 ビット整数) を a から抽出し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_extracti32x8_epi32

__m256i _mm512_maskz_extracti32x8_epi32(__mmask8 k, __m512i a, int imm)

CPUID フラグ: AVX512DQ

命令: vextracti32x8

imm で選択された 256 ビット (8 つのパックド 32 ビット整数) を a から抽出し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_extracti64x2_epi64

__m128i _mm256_extracti64x2_epi64(__m256i a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vextracti64x2

imm で選択された 128 ビット (2 つのパックド 64 ビット整数) を a から抽出し、結果を戻り値に格納します。



_mm256_mask_extracti64x2_epi64

__m128i _mm256_mask_extracti64x2_epi64(__m128i src, __mmask8 k, __m256i a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vextracti64x2

imm で選択された 128 ビット (2 つのパックド 64 ビット整数) を a から抽出し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_extracti64x2_epi64

__m128i _mm256_maskz_extracti64x2_epi64(__mmask8 k, __m256i a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vextracti64x2

imm で選択された 128 ビット (2 つのパックド 64 ビット整数) を a から抽出し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_extracti64x2_epi64

__m128i _mm512_extracti64x2_epi64(__m512i a, int imm)

CPUID フラグ: AVX512DQ

命令: vextracti64x2

imm で選択された 128 ビット (2 つのパックド 64 ビット整数) を a から抽出し、結果を戻り値に格納します。



_mm512_mask_extracti64x2_epi64

__m128i _mm512_mask_extracti64x2_epi64(__m128i src, __mmask8 k, __m512i a, int imm)

CPUID フラグ: AVX512DQ

命令: vextracti64x2

imm で選択された 128 ビット (2 つのパックド 64 ビット整数) を a から抽出し、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_extracti64x2_epi64

__m128i _mm512_maskz_extracti64x2_epi64(__mmask8 k, __m512i a, int imm)

CPUID フラグ: AVX512DQ

命令: vextracti64x2

imm で選択された 128 ビット (2 つのパックド 64 ビット整数) を a から抽出し、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_alignr_epi8

__m128i _mm_mask_alignr_epi8(__m128i src, __mmask16 k, __m128i a, __m128i b, const int count)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpalignr

ab の 16 バイト・ブロックのペアを結合し、32 バイトの中間結果を count バイト分だけ右にシフトし、書き込みマスク k を使用して最終結果の下位 16 バイトを戻り値に格納します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_alignr_epi8

__m128i _mm_maskz_alignr_epi8(__mmask16 k, __m128i a, __m128i b, const int count)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpalignr

ab の 16 バイト・ブロックのペアを結合し、32 バイトの中間結果を count バイト分だけ右にシフトし、ゼロマスク k を使用して最終結果の下位 16 バイトを戻り値に格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_alignr_epi8

__m256i _mm256_mask_alignr_epi8(__m256i src, __mmask32 k, __m256i a, __m256i b, const int count)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpalignr

ab の 16 バイト・ブロックのペアを結合し、32 バイトの中間結果を count バイト分だけ右にシフトし、書き込みマスク k を使用して最終結果の下位 16 バイトを戻り値に格納します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_alignr_epi8

__m256i _mm256_maskz_alignr_epi8(__mmask32 k, __m256i a, __m256i b, const int count)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpalignr

ab の 16 バイト・ブロックのペアを結合し、32 バイトの中間結果を count バイト分だけ右にシフトし、ゼロマスク k を使用して最終結果の下位 16 バイトを戻り値に格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_alignr_epi8

__m512i _mm512_alignr_epi8(__m512i a, __m512i b, const int count)

CPUID フラグ: AVX512BW

命令: vpalignr

ab の 16 バイト・ブロックのペアを結合し、32 バイトの中間結果を count バイト分だけ右にシフトし、最終結果の下位 16 バイトを戻り値に格納します。



_mm512_mask_alignr_epi8

__m512i _mm512_mask_alignr_epi8(__m512i src, __mmask64 k, __m512i a, __m512i b, const int count)

CPUID フラグ: AVX512BW

命令: vpalignr

ab の 16 バイト・ブロックのペアを結合し、32 バイトの中間結果を count バイト分だけ右にシフトし、書き込みマスク k を使用して最終結果の下位 16 バイトを戻り値に格納します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_alignr_epi8

__m512i _mm512_maskz_alignr_epi8(__mmask64 k, __m512i a, __m512i b, const int count)

CPUID フラグ: AVX512BW

命令: vpalignr

ab の 16 バイト・ブロックのペアを結合し、32 バイトの中間結果を count バイト分だけ右にシフトし、ゼロマスク k を使用して最終結果の下位 16 バイトを戻り値に格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_blend_epi8

__m128i _mm_mask_blend_epi8(__mmask16 k, __m128i a, __m128i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpblendmb

制御マスク k を使用して ab のパックド 8 ビット整数をブレンド (混合) し、結果を返します。



_mm256_mask_blend_epi8

__m256i _mm256_mask_blend_epi8(__mmask32 k, __m256i a, __m256i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpblendmb

制御マスク k を使用して ab のパックド 8 ビット整数をブレンド (混合) し、結果を返します。



_mm512_mask_blend_epi8

__m512i _mm512_mask_blend_epi8(__mmask64 k, __m512i a, __m512i b)

CPUID フラグ: AVX512BW

命令: vpblendmb

制御マスク k を使用して ab のパックド 8 ビット整数をブレンド (混合) し、結果を返します。



_mm_mask_blend_epi32

__m128i _mm_mask_blend_epi32(__mmask8 k, __m128i a, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpblendmd

制御マスク k を使用して ab のパックド 32 ビット整数をブレンド (混合) し、結果を返します。



_mm256_mask_blend_epi32

__m256i _mm256_mask_blend_epi32(__mmask8 k, __m256i a, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpblendmd

制御マスク k を使用して ab のパックド 32 ビット整数をブレンド (混合) し、結果を返します。



_mm_mask_blend_epi64

__m128i _mm_mask_blend_epi64(__mmask8 k, __m128i a, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpblendmq

制御マスク k を使用して ab のパックド 64 ビット整数をブレンド (混合) し、結果を返します。



_mm256_mask_blend_epi64

__m256i _mm256_mask_blend_epi64(__mmask8 k, __m256i a, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpblendmq

制御マスク k を使用して ab のパックド 64 ビット整数をブレンド (混合) し、結果を返します。



_mm_mask_blend_epi16

__m128i _mm_mask_blend_epi16(__mmask8 k, __m128i a, __m128i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpblendmw

制御マスク k を使用して ab のパックド 16 ビット整数をブレンド (混合) し、結果を返します。



_mm256_mask_blend_epi16

__m256i _mm256_mask_blend_epi16(__mmask16 k, __m256i a, __m256i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpblendmw

制御マスク k を使用して ab のパックド 16 ビット整数をブレンド (混合) し、結果を返します。



_mm512_mask_blend_epi16

__m512i _mm512_mask_blend_epi16(__mmask32 k, __m512i a, __m512i b)

CPUID フラグ: AVX512BW

命令: vpblendmw

制御マスク k を使用して ab のパックド 16 ビット整数をブレンド (混合) し、結果を返します。



_mm_mask_broadcastb_epi8

__m128i _mm_mask_broadcastb_epi8(__m128i src, __mmask16 k, __m128i a)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpbroadcastb

書き込みマスク k を使用して、a の下位のパックド 8 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_broadcastb_epi8

__m128i _mm_maskz_broadcastb_epi8(__mmask16 k, __m128i a)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpbroadcastb

ゼロマスク k を使用して、a の下位のパックド 8 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_broadcastb_epi8

__m256i _mm256_mask_broadcastb_epi8(__m256i src, __mmask32 k, __m128i a)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpbroadcastb

書き込みマスク k を使用して、a の下位のパックド 8 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_broadcastb_epi8

__m256i _mm256_maskz_broadcastb_epi8(__mmask32 k, __m128i a)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpbroadcastb

ゼロマスク k を使用して、a の下位のパックド 8 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_broadcastb_epi8

__m512i _mm512_broadcastb_epi8(__m128i a)

CPUID フラグ: AVX512BW

命令: vpbroadcastb

a の下位のパックド 8 ビット整数を戻り値のすべての要素にブロードキャストします。



_mm512_mask_broadcastb_epi8

__m512i _mm512_mask_broadcastb_epi8(__m512i src, __mmask64 k, __m128i a)

CPUID フラグ: AVX512BW

命令: vpbroadcastb

書き込みマスク k を使用して、a の下位のパックド 8 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_broadcastb_epi8

__m512i _mm512_maskz_broadcastb_epi8(__mmask64 k, __m128i a)

CPUID フラグ: AVX512BW

命令: vpbroadcastb

ゼロマスク k を使用して、a の下位のパックド 8 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_broadcastd_epi32

__m128i _mm_mask_broadcastd_epi32(__m128i src, __mmask8 k, __m128i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpbroadcastd

書き込みマスク k を使用して、a の下位のパックド 32 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_broadcastd_epi32

__m128i _mm_maskz_broadcastd_epi32(__mmask8 k, __m128i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpbroadcastd

ゼロマスク k を使用して、a の下位のパックド 32 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_broadcastd_epi32

__m256i _mm256_mask_broadcastd_epi32(__m256i src, __mmask8 k, __m128i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpbroadcastd

書き込みマスク k を使用して、a の下位のパックド 32 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_broadcastd_epi32

__m256i _mm256_maskz_broadcastd_epi32(__mmask8 k, __m128i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpbroadcastd

ゼロマスク k を使用して、a の下位のパックド 32 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_broadcastmb_epi64

__m128i _mm_broadcastmb_epi64(__mmask8 k)

CPUID フラグ: AVX512CD、AVX512VL

命令: vpbroadcastmb2q

入力マスク k の下位 8 ビットを戻り値のすべての 64 ビット要素にブロードキャストします。



_mm256_broadcastmb_epi64

__m256i _mm256_broadcastmb_epi64(__mmask8 k)

CPUID フラグ: AVX512CD、AVX512VL

命令: vpbroadcastmb2q

入力マスク k の下位 8 ビットを戻り値のすべての 64 ビット要素にブロードキャストします。



_mm_broadcastmw_epi32

__m128i _mm_broadcastmw_epi32(__mmask16 k)

CPUID フラグ: AVX512CD、AVX512VL

命令: vpbroadcastmw2d

入力マスク k の下位 16 ビットを戻り値のすべての 32 ビット要素にブロードキャストします。



_mm256_broadcastmw_epi32

__m256i _mm256_broadcastmw_epi32(__mmask16 k)

CPUID フラグ: AVX512CD、AVX512VL

命令: vpbroadcastmw2d

入力マスク k の下位 16 ビットを戻り値のすべての 32 ビット要素にブロードキャストします。



_mm_mask_broadcastq_epi64

__m128i _mm_mask_broadcastq_epi64(__m128i src, __mmask8 k, __m128i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpbroadcastq

書き込みマスク k を使用して、a の下位のパックド 64 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_broadcastq_epi64

__m128i _mm_maskz_broadcastq_epi64(__mmask8 k, __m128i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpbroadcastq

ゼロマスク k を使用して、a の下位のパックド 64 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_broadcastq_epi64

__m256i _mm256_mask_broadcastq_epi64(__m256i src, __mmask8 k, __m128i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpbroadcastq

書き込みマスク k を使用して、a の下位のパックド 64 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_broadcastq_epi64

__m256i _mm256_maskz_broadcastq_epi64(__mmask8 k, __m128i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpbroadcastq

ゼロマスク k を使用して、a の下位のパックド 64 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_broadcastw_epi16

__m128i _mm_mask_broadcastw_epi16(__m128i src, __mmask8 k, __m128i a)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpbroadcastw

書き込みマスク k を使用して、a の下位のパックド 16 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_broadcastw_epi16

__m128i _mm_maskz_broadcastw_epi16(__mmask8 k, __m128i a)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpbroadcastw

ゼロマスク k を使用して、a の下位のパックド 16 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_broadcastw_epi16

__m256i _mm256_mask_broadcastw_epi16(__m256i src, __mmask16 k, __m128i a)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpbroadcastw

書き込みマスク k を使用して、a の下位のパックド 16 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_broadcastw_epi16

__m256i _mm256_maskz_broadcastw_epi16(__mmask16 k, __m128i a)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpbroadcastw

ゼロマスク k を使用して、a の下位のパックド 16 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_broadcastw_epi16

__m512i _mm512_broadcastw_epi16(__m128i a)

CPUID フラグ: AVX512BW

命令: vpbroadcastw

a の下位のパックド 16 ビット整数を戻り値のすべての要素にブロードキャストします。



_mm512_mask_broadcastw_epi16

__m512i _mm512_mask_broadcastw_epi16(__m512i src, __mmask32 k, __m128i a)

CPUID フラグ: AVX512BW

命令: vpbroadcastw

書き込みマスク k を使用して、a の下位のパックド 16 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_broadcastw_epi16

__m512i _mm512_maskz_broadcastw_epi16(__mmask32 k, __m128i a)

CPUID フラグ: AVX512BW

命令: vpbroadcastw

ゼロマスク k を使用して、a の下位のパックド 16 ビット整数を戻り値のすべての要素にブロードキャストします (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_compress_epi32

__m128i _mm_mask_compress_epi32(__m128i src, __mmask8 k, __m128i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpcompressd

a のアクティブな 32 ビット整数 (書き込みマスク k の対応するビットがセットされている要素) を戻り値に連続して格納し、残りの要素を src からコピーします。



_mm_maskz_compress_epi32

__m128i _mm_maskz_compress_epi32(__mmask8 k, __m128i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpcompressd

a のアクティブな 32 ビット整数 (ゼロマスク k の対応するビットがセットされている要素) を戻り値に連続して格納し、残りの要素を 0 に設定します。



_mm256_mask_compress_epi32

__m256i _mm256_mask_compress_epi32(__m256i src, __mmask8 k, __m256i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpcompressd

a のアクティブな 32 ビット整数 (書き込みマスク k の対応するビットがセットされている要素) を戻り値に連続して格納し、残りの要素を src からコピーします。



_mm256_maskz_compress_epi32

__m256i _mm256_maskz_compress_epi32(__mmask8 k, __m256i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpcompressd

a のアクティブな 32 ビット整数 (ゼロマスク k の対応するビットがセットされている要素) を戻り値に連続して格納し、残りの要素を 0 に設定します。



_mm_mask_compress_epi64

__m128i _mm_mask_compress_epi64(__m128i src, __mmask8 k, __m128i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpcompressq

a のアクティブな 64 ビット整数 (書き込みマスク k の対応するビットがセットされている要素) を戻り値に連続して格納し、残りの要素を src からコピーします。



_mm_maskz_compress_epi64

__m128i _mm_maskz_compress_epi64(__mmask8 k, __m128i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpcompressq

a のアクティブな 64 ビット整数 (ゼロマスク k の対応するビットがセットされている要素) を戻り値に連続して格納し、残りの要素を 0 に設定します。



_mm256_mask_compress_epi64

__m256i _mm256_mask_compress_epi64(__m256i src, __mmask8 k, __m256i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpcompressq

a のアクティブな 64 ビット整数 (書き込みマスク k の対応するビットがセットされている要素) を戻り値に連続して格納し、残りの要素を src からコピーします。



_mm256_maskz_compress_epi64

__m256i _mm256_maskz_compress_epi64(__mmask8 k, __m256i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpcompressq

a のアクティブな 64 ビット整数 (ゼロマスク k の対応するビットがセットされている要素) を戻り値に連続して格納し、残りの要素を 0 に設定します。



_mm256_mask_permutexvar_epi32

__m256i _mm256_mask_permutexvar_epi32(__m256i src, __mmask8 k, __m256i idx, __m256i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermd

idx の対応するインデックスを使用して、a の 32 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_permutexvar_epi32

__m256i _mm256_maskz_permutexvar_epi32(__mmask8 k, __m256i idx, __m256i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermd

idx の対応するインデックスを使用して、a の 32 ビット整数を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_permutexvar_epi32

__m256i _mm256_permutexvar_epi32(__m256i idx, __m256i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermd

idx の対応するインデックスを使用して、a の 32 ビット整数を複数のレーンにわたってシャッフルし、結果を返します。



_mm_mask2_permutex2var_epi32

__m128i _mm_mask2_permutex2var_epi32(__m128i a, __m128i idx, __mmask8 k, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2d

idx の対応するセレクターとインデックスを使用して、ab の 32 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は idx の要素がコピーされます)。



_mm256_mask2_permutex2var_epi32

__m256i _mm256_mask2_permutex2var_epi32(__m256i a, __m256i idx, __mmask8 k, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2d

idx の対応するセレクターとインデックスを使用して、ab の 32 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は idx の要素がコピーされます)。



_mm_maskz_permutex2var_epi32

__m128i _mm_maskz_permutex2var_epi32(__mmask8 k, __m128i a, __m128i idx, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2d、vpermt2d

idx の対応するセレクターとインデックスを使用して、ab の 32 ビット整数を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_permutex2var_epi32

__m128i _mm_permutex2var_epi32(__m128i a, __m128i idx, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2d、vpermt2d

idx の対応するセレクターとインデックスを使用して、ab の 32 ビット整数を複数のレーンにわたってシャッフルし、結果を返します。



_mm256_maskz_permutex2var_epi32

__m256i _mm256_maskz_permutex2var_epi32(__mmask8 k, __m256i a, __m256i idx, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2d、vpermt2d

idx の対応するセレクターとインデックスを使用して、ab の 32 ビット整数を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_permutex2var_epi32

__m256i _mm256_permutex2var_epi32(__m256i a, __m256i idx, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2d、vpermt2d

idx の対応するセレクターとインデックスを使用して、ab の 32 ビット整数を複数のレーンにわたってシャッフルし、結果を返します。



_mm_mask2_permutex2var_epi64

__m128i _mm_mask2_permutex2var_epi64(__m128i a, __m128i idx, __mmask8 k, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2q

idx の対応するセレクターとインデックスを使用して、ab の 64 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は idx の要素がコピーされます)。



_mm256_mask2_permutex2var_epi64

__m256i _mm256_mask2_permutex2var_epi64(__m256i a, __m256i idx, __mmask8 k, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2q

idx の対応するセレクターとインデックスを使用して、ab の 64 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は idx の要素がコピーされます)。



_mm_maskz_permutex2var_epi64

__m128i _mm_maskz_permutex2var_epi64(__mmask8 k, __m128i a, __m128i idx, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2q、vpermt2q

idx の対応するセレクターとインデックスを使用して、ab の 64 ビット整数を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_permutex2var_epi64

__m128i _mm_permutex2var_epi64(__m128i a, __m128i idx, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2q、vpermt2q

idx の対応するセレクターとインデックスを使用して、ab の 64 ビット整数を複数のレーンにわたってシャッフルし、結果を返します。



_mm256_maskz_permutex2var_epi64

__m256i _mm256_maskz_permutex2var_epi64(__mmask8 k, __m256i a, __m256i idx, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2q、vpermt2q

idx の対応するセレクターとインデックスを使用して、ab の 64 ビット整数を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_permutex2var_epi64

__m256i _mm256_permutex2var_epi64(__m256i a, __m256i idx, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermi2q、vpermt2q

idx の対応するセレクターとインデックスを使用して、ab の 64 ビット整数を複数のレーンにわたってシャッフルし、結果を返します。



_mm_mask2_permutex2var_epi16

__m128i _mm_mask2_permutex2var_epi16(__m128i a, __m128i idx, __mmask8 k, __m128i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpermi2w

idx の対応するセレクターとインデックスを使用して、ab の 16 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は idx の要素がコピーされます)。



_mm256_mask2_permutex2var_epi16

__m256i _mm256_mask2_permutex2var_epi16(__m256i a, __m256i idx, __mmask16 k, __m256i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpermi2w

idx の対応するセレクターとインデックスを使用して、ab の 16 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は idx の要素がコピーされます)。



_mm512_mask2_permutex2var_epi16

__m512i _mm512_mask2_permutex2var_epi16(__m512i a, __m512i idx, __mmask32 k, __m512i b)

CPUID フラグ: AVX512BW

命令: vpermi2w

idx の対応するセレクターとインデックスを使用して、ab の 16 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は idx の要素がコピーされます)。



_mm_maskz_permutex2var_epi16

__m128i _mm_maskz_permutex2var_epi16(__mmask8 k, __m128i a, __m128i idx, __m128i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpermi2w、vpermt2w

idx の対応するセレクターとインデックスを使用して、ab の 16 ビット整数を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_permutex2var_epi16

__m128i _mm_permutex2var_epi16(__m128i a, __m128i idx, __m128i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpermi2w、vpermt2w

idx の対応するセレクターとインデックスを使用して、ab の 16 ビット整数を複数のレーンにわたってシャッフルし、結果を返します。



_mm256_maskz_permutex2var_epi16

__m256i _mm256_maskz_permutex2var_epi16(__mmask16 k, __m256i a, __m256i idx, __m256i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpermi2w、vpermt2w

idx の対応するセレクターとインデックスを使用して、ab の 16 ビット整数を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_permutex2var_epi16

__m256i _mm256_permutex2var_epi16(__m256i a, __m256i idx, __m256i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpermi2w、vpermt2w

idx の対応するセレクターとインデックスを使用して、ab の 16 ビット整数を複数のレーンにわたってシャッフルし、結果を返します。



_mm512_maskz_permutex2var_epi16

__m512i _mm512_maskz_permutex2var_epi16(__mmask32 k, __m512i a, __m512i idx, __m512i b)

CPUID フラグ: AVX512BW

命令: vpermi2w、vpermt2w

idx の対応するセレクターとインデックスを使用して、ab の 16 ビット整数を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_permutex2var_epi16

__m512i _mm512_permutex2var_epi16(__m512i a, __m512i idx, __m512i b)

CPUID フラグ: AVX512BW

命令: vpermi2w、vpermt2w

idx の対応するセレクターとインデックスを使用して、ab の 16 ビット整数を複数のレーンにわたってシャッフルし、結果を返します。



_mm256_mask_permutex_epi64

__m256i _mm256_mask_permutex_epi64(__m256i src, __mmask8 k, __m256i a, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermq

imm のコントロールを使用して、a の 64 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_mask_permutexvar_epi64

__m256i _mm256_mask_permutexvar_epi64(__m256i src, __mmask8 k, __m256i idx, __m256i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermq

idx の対応するインデックスを使用して、a の 64 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_permutex_epi64

__m256i _mm256_maskz_permutex_epi64(__mmask8 k, __m256i a, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermq

imm のコントロールを使用して、a の 64 ビット整数を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_maskz_permutexvar_epi64

__m256i _mm256_maskz_permutexvar_epi64(__mmask8 k, __m256i idx, __m256i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermq

idx の対応するインデックスを使用して、a の 64 ビット整数を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_permutex_epi64

__m256i _mm256_permutex_epi64(__m256i a, const int imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermq

imm のコントロールを使用して、a の 64 ビット整数を複数のレーンにわたってシャッフルし、結果を返します。



_mm256_permutexvar_epi64

__m256i _mm256_permutexvar_epi64(__m256i idx, __m256i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermq

idx の対応するインデックスを使用して、a の 64 ビット整数を複数のレーンにわたってシャッフルし、結果を返します。



_mm_mask_permutex2var_epi32

__m128i _mm_mask_permutex2var_epi32(__m128i a, __mmask8 k, __m128i idx, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermt2d

idx の対応するセレクターとインデックスを使用して、ab の 32 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は a の要素がコピーされます)。



_mm256_mask_permutex2var_epi32

__m256i _mm256_mask_permutex2var_epi32(__m256i a, __mmask8 k, __m256i idx, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermt2d

idx の対応するセレクターとインデックスを使用して、ab の 32 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は a の要素がコピーされます)。



_mm_mask_permutex2var_epi64

__m128i _mm_mask_permutex2var_epi64(__m128i a, __mmask8 k, __m128i idx, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermt2q

idx の対応するセレクターとインデックスを使用して、ab の 64 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は a の要素がコピーされます)。



_mm256_mask_permutex2var_epi64

__m256i _mm256_mask_permutex2var_epi64(__m256i a, __mmask8 k, __m256i idx, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpermt2q

idx の対応するセレクターとインデックスを使用して、ab の 64 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は a の要素がコピーされます)。



_mm_mask_permutex2var_epi16

__m128i _mm_mask_permutex2var_epi16(__m128i a, __mmask8 k, __m128i idx, __m128i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpermt2w

idx の対応するセレクターとインデックスを使用して、ab の 16 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は a の要素がコピーされます)。



_mm256_mask_permutex2var_epi16

__m256i _mm256_mask_permutex2var_epi16(__m256i a, __mmask16 k, __m256i idx, __m256i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpermt2w

idx の対応するセレクターとインデックスを使用して、ab の 16 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は a の要素がコピーされます)。



_mm512_mask_permutex2var_epi16

__m512i _mm512_mask_permutex2var_epi16(__m512i a, __mmask32 k, __m512i idx, __m512i b)

CPUID フラグ: AVX512BW

命令: vpermt2w

idx の対応するセレクターとインデックスを使用して、ab の 16 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は a の要素がコピーされます)。



_mm_mask_permutexvar_epi16

__m128i _mm_mask_permutexvar_epi16(__m128i src, __mmask8 k, __m128i idx, __m128i a)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpermw

idx の対応するインデックスを使用して、a の 16 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_permutexvar_epi16

__m128i _mm_maskz_permutexvar_epi16(__mmask8 k, __m128i idx, __m128i a)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpermw

idx の対応するインデックスを使用して、a の 16 ビット整数を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_permutexvar_epi16

__m128i _mm_permutexvar_epi16(__m128i idx, __m128i a)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpermw

idx の対応するインデックスを使用して、a の 16 ビット整数を複数のレーンにわたってシャッフルし、結果を返します。



_mm256_mask_permutexvar_epi16

__m256i _mm256_mask_permutexvar_epi16(__m256i src, __mmask16 k, __m256i idx, __m256i a)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpermw

idx の対応するインデックスを使用して、a の 16 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_permutexvar_epi16

__m256i _mm256_maskz_permutexvar_epi16(__mmask16 k, __m256i idx, __m256i a)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpermw

idx の対応するインデックスを使用して、a の 16 ビット整数を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_permutexvar_epi16

__m256i _mm256_permutexvar_epi16(__m256i idx, __m256i a)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpermw

idx の対応するインデックスを使用して、a の 16 ビット整数を複数のレーンにわたってシャッフルし、結果を返します。



_mm512_mask_permutexvar_epi16

__m512i _mm512_mask_permutexvar_epi16(__m512i src, __mmask32 k, __m512i idx, __m512i a)

CPUID フラグ: AVX512BW

命令: vpermw

idx の対応するインデックスを使用して、a の 16 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_permutexvar_epi16

__m512i _mm512_maskz_permutexvar_epi16(__mmask32 k, __m512i idx, __m512i a)

CPUID フラグ: AVX512BW

命令: vpermw

idx の対応するインデックスを使用して、a の 16 ビット整数を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_permutexvar_epi16

__m512i _mm512_permutexvar_epi16(__m512i idx, __m512i a)

CPUID フラグ: AVX512BW

命令: vpermw

idx の対応するインデックスを使用して、a の 16 ビット整数を複数のレーンにわたってシャッフルし、結果を返します。



_mm_mask_expand_epi32

__m128i _mm_mask_expand_epi32(__m128i src, __mmask8 k, __m128i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpexpandd

a の連続するアクティブな 32 ビット整数 (マスク k の対応するビットがセットされている要素) をロードし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_expand_epi32

__m128i _mm_maskz_expand_epi32(__mmask8 k, __m128i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpexpandd

a の連続するアクティブな 32 ビット整数 (マスク k の対応するビットがセットされている要素) をロードし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_expand_epi32

__m256i _mm256_mask_expand_epi32(__m256i src, __mmask8 k, __m256i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpexpandd

a の連続するアクティブな 32 ビット整数 (マスク k の対応するビットがセットされている要素) をロードし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_expand_epi32

__m256i _mm256_maskz_expand_epi32(__mmask8 k, __m256i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpexpandd

a の連続するアクティブな 32 ビット整数 (マスク k の対応するビットがセットされている要素) をロードし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_expand_epi64

__m128i _mm_mask_expand_epi64(__m128i src, __mmask8 k, __m128i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpexpandq

a の連続するアクティブな 64 ビット整数 (マスク k の対応するビットがセットされている要素) をロードし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_expand_epi64

__m128i _mm_maskz_expand_epi64(__mmask8 k, __m128i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpexpandq

a の連続するアクティブな 64 ビット整数 (マスク k の対応するビットがセットされている要素) をロードし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_expand_epi64

__m256i _mm256_mask_expand_epi64(__m256i src, __mmask8 k, __m256i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpexpandq

a の連続するアクティブな 64 ビット整数 (マスク k の対応するビットがセットされている要素) をロードし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_expand_epi64

__m256i _mm256_maskz_expand_epi64(__mmask8 k, __m256i a)

CPUID フラグ: AVX512F、AVX512VL

命令: vpexpandq

a の連続するアクティブな 64 ビット整数 (マスク k の対応するビットがセットされている要素) をロードし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_movm_epi8

__m128i _mm_movm_epi8(__mmask16 k)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpmovm2b

k の対応するビットの値に応じて、戻り値の各パックド 8 ビット整数をすべて 1 または 0 に設定します。



_mm256_movm_epi8

__m256i _mm256_movm_epi8(__mmask32 k)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpmovm2b

k の対応するビットの値に応じて、戻り値の各パックド 8 ビット整数をすべて 1 または 0 に設定します。



_mm512_movm_epi8

__m512i _mm512_movm_epi8(__mmask64 k)

CPUID フラグ: AVX512BW

命令: vpmovm2b

k の対応するビットの値に応じて、戻り値の各パックド 8 ビット整数をすべて 1 または 0 に設定します。



_mm_movm_epi32

__m128i _mm_movm_epi32(__mmask8 k)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vpmovm2d

k の対応するビットの値に応じて、戻り値の各パックド 32 ビット整数をすべて 1 または 0 に設定します。



_mm256_movm_epi32

__m256i _mm256_movm_epi32(__mmask8 k)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vpmovm2d

k の対応するビットの値に応じて、戻り値の各パックド 32 ビット整数をすべて 1 または 0 に設定します。



_mm512_movm_epi32

__m512i _mm512_movm_epi32(__mmask16 k)

CPUID フラグ: AVX512DQ

命令: vpmovm2d

k の対応するビットの値に応じて、戻り値の各パックド 32 ビット整数をすべて 1 または 0 に設定します。



_mm_movm_epi64

__m128i _mm_movm_epi64(__mmask8 k)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vpmovm2q

k の対応するビットの値に応じて、戻り値の各パックド 64 ビット整数をすべて 1 または 0 に設定します。



_mm256_movm_epi64

__m256i _mm256_movm_epi64(__mmask8 k)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vpmovm2q

k の対応するビットの値に応じて、戻り値の各パックド 64 ビット整数をすべて 1 または 0 に設定します。



_mm512_movm_epi64

__m512i _mm512_movm_epi64(__mmask8 k)

CPUID フラグ: AVX512DQ

命令: vpmovm2q

k の対応するビットの値に応じて、戻り値の各パックド 64 ビット整数をすべて 1 または 0 に設定します。



_mm_movm_epi16

__m128i _mm_movm_epi16(__mmask8 k)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpmovm2w

k の対応するビットの値に応じて、戻り値の各パックド 16 ビット整数をすべて 1 または 0 に設定します。



_mm256_movm_epi16

__m256i _mm256_movm_epi16(__mmask16 k)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpmovm2w

k の対応するビットの値に応じて、戻り値の各パックド 16 ビット整数をすべて 1 または 0 に設定します。



_mm512_movm_epi16

__m512i _mm512_movm_epi16(__mmask32 k)

CPUID フラグ: AVX512BW

命令: vpmovm2w

k の対応するビットの値に応じて、戻り値の各パックド 16 ビット整数をすべて 1 または 0 に設定します。



_mm512_sad_epu8

__m512i _mm512_sad_epu8(__m512i a, __m512i b)

CPUID フラグ: AVX512BW

命令: vpsadbw

ab のパックド符号なし 8 ビット整数の差分絶対値を計算し、連続する 8 つの差分絶対値ごとに水平に合計して、4 つの符号なし 16 ビット整数を戻り値の 64 ビット要素の下位 16 ビットにパックします。



_mm_mask_shuffle_epi8

__m128i _mm_mask_shuffle_epi8(__m128i src, __mmask16 k, __m128i a, __m128i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpshufb

b の対応する 8 ビット要素にあるシャッフル制御マスクに応じて、a のパックド 8 ビット整数をシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_shuffle_epi8

__m128i _mm_maskz_shuffle_epi8(__mmask16 k, __m128i a, __m128i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpshufb

b の対応する 8 ビット要素にあるシャッフル制御マスクに応じて、a のパックド 8 ビット整数をシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_shuffle_epi8

__m256i _mm256_mask_shuffle_epi8(__m256i src, __mmask32 k, __m256i a, __m256i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpshufb

b の対応する 8 ビット要素にあるシャッフル制御マスクに応じて、a のパックド 8 ビット整数をシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_shuffle_epi8

__m256i _mm256_maskz_shuffle_epi8(__mmask32 k, __m256i a, __m256i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpshufb

b の対応する 8 ビット要素にあるシャッフル制御マスクに応じて、a のパックド 8 ビット整数をシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_mask_shuffle_epi8

__m512i _mm512_mask_shuffle_epi8(__m512i src, __mmask64 k, __m512i a, __m512i b)

CPUID フラグ: AVX512BW

命令: vpshufb

b の対応する 8 ビット要素にあるコントロールを使用して、a の 8 ビット整数を 128 ビット・レーン内でシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_shuffle_epi8

__m512i _mm512_maskz_shuffle_epi8(__mmask64 k, __m512i a, __m512i b)

CPUID フラグ: AVX512BW

命令: vpshufb

b の対応する 8 ビット要素にあるシャッフル制御マスクに応じて、a のパックド 8 ビット整数をシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_shuffle_epi8

__m512i _mm512_shuffle_epi8(__m512i a, __m512i b)

CPUID フラグ: AVX512BW

命令: vpshufb

b の対応する 8 ビット要素にあるシャッフル制御マスクに応じて、a のパックド 8 ビット整数をシャッフルし、結果を返します。



_mm_mask_shuffle_epi32

__m128i _mm_mask_shuffle_epi32(__m128i src, __mmask8 k, __m128i a, _MM_PERM_ENUM imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vpshufd

imm のコントロールを使用して、a の 32 ビット整数をシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_shuffle_epi32

__m128i _mm_maskz_shuffle_epi32(__mmask8 k, __m128i a, _MM_PERM_ENUM imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vpshufd

imm のコントロールを使用して、a の 32 ビット整数をシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_shuffle_epi32

__m256i _mm256_mask_shuffle_epi32(__m256i src, __mmask8 k, __m256i a, _MM_PERM_ENUM imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vpshufd

imm のコントロールを使用して、a の 32 ビット整数を 128 ビット・レーン内でシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_shuffle_epi32

__m256i _mm256_maskz_shuffle_epi32(__mmask8 k, __m256i a, _MM_PERM_ENUM imm)

CPUID フラグ: AVX512F、AVX512VL

命令: vpshufd

imm のコントロールを使用して、a の 32 ビット整数を 128 ビット・レーン内でシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_shufflehi_epi16

__m128i _mm_mask_shufflehi_epi16(__m128i src, __mmask8 k, __m128i a, int imm)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpshufhw

imm のコントロールを使用して、a の上位 64 ビットにある 16 ビット整数をシャッフルします。書き込みマスク k を使用して結果を戻り値の上位 64 ビットに格納し (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)、a の下位 64 ビットを dst の下位 64 ビットにコピーします。



_mm_maskz_shufflehi_epi16

__m128i _mm_maskz_shufflehi_epi16(__mmask8 k, __m128i a, int imm)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpshufhw

imm のコントロールを使用して、a の上位 64 ビットにある 16 ビット整数をシャッフルします。ゼロマスク k を使用して結果を戻り値の上位 64 ビットに格納し (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)、a の下位 64 ビットを dst の下位 64 ビットにコピーします。



_mm256_mask_shufflehi_epi16

__m256i _mm256_mask_shufflehi_epi16(__m256i src, __mmask16 k, __m256i a, int imm)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpshufhw

imm のコントロールを使用して、a の 128 ビット・レーンの上位 64 ビットにある 16 ビット整数をシャッフルします。書き込みマスク k を使用して結果を戻り値の 128 ビット・レーンの上位 64 ビットに格納し (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)、a の 128 ビット・レーンの下位 64 ビットを dst の 128 ビット・レーンの下位 64 ビットにコピーします。



_mm256_maskz_shufflehi_epi16

__m256i _mm256_maskz_shufflehi_epi16(__mmask16 k, __m256i a, int imm)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpshufhw

imm のコントロールを使用して、a の 128 ビット・レーンの上位 64 ビットにある 16 ビット整数をシャッフルします。ゼロマスク k を使用して結果を戻り値の 128 ビット・レーンの上位 64 ビットに格納し (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)、a の 128 ビット・レーンの下位 64 ビットを dst の 128 ビット・レーンの下位 64 ビットにコピーします。



_mm512_mask_shufflehi_epi16

__m512i _mm512_mask_shufflehi_epi16(__m512i src, __mmask32 k, __m512i a, int imm)

CPUID フラグ: AVX512BW

命令: vpshufhw

imm のコントロールを使用して、a の 128 ビット・レーンの上位 64 ビットにある 16 ビット整数をシャッフルします。書き込みマスク k を使用して結果を戻り値の 128 ビット・レーンの上位 64 ビットに格納し (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)、a の 128 ビット・レーンの下位 64 ビットを dst の 128 ビット・レーンの下位 64 ビットにコピーします。



_mm512_maskz_shufflehi_epi16

__m512i _mm512_maskz_shufflehi_epi16(__mmask32 k, __m512i a, int imm)

CPUID フラグ: AVX512BW

命令: vpshufhw

imm のコントロールを使用して、a の 128 ビット・レーンの上位 64 ビットにある 16 ビット整数をシャッフルします。ゼロマスク k を使用して結果を戻り値の 128 ビット・レーンの上位 64 ビットに格納し (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)、a の 128 ビット・レーンの下位 64 ビットを dst の 128 ビット・レーンの下位 64 ビットにコピーします。



_mm512_shufflehi_epi16

__m512i _mm512_shufflehi_epi16(__m512i a, int imm)

CPUID フラグ: AVX512BW

命令: vpshufhw

imm のコントロールを使用して、a の 128 ビット・レーンの上位 64 ビットにある 16 ビット整数をシャッフルします。結果を戻り値の 128 ビット・レーンの上位 64 ビットに格納し、a の 128 ビット・レーンの下位 64 ビットを dst の 128 ビット・レーンの下位 64 ビットにコピーします。



_mm_mask_shufflelo_epi16

__m128i _mm_mask_shufflelo_epi16(__m128i src, __mmask8 k, __m128i a, int imm)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpshuflw

imm のコントロールを使用して、a の下位 64 ビットにある 16 ビット整数をシャッフルします。書き込みマスク k を使用して結果を戻り値の下位 64 ビットに格納し (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)、a の上位 64 ビットを dst の上位 64 ビットにコピーします。



_mm_maskz_shufflelo_epi16

__m128i _mm_maskz_shufflelo_epi16(__mmask8 k, __m128i a, int imm)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpshuflw

imm のコントロールを使用して、a の下位 64 ビットにある 16 ビット整数をシャッフルします。ゼロマスク k を使用して結果を戻り値の下位 64 ビットに格納し (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)、a の上位 64 ビットを dst の上位 64 ビットにコピーします。



_mm256_mask_shufflelo_epi16

__m256i _mm256_mask_shufflelo_epi16(__m256i src, __mmask16 k, __m256i a, int imm)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpshuflw

imm のコントロールを使用して、a の 128 ビット・レーンの下位 64 ビットにある 16 ビット整数をシャッフルします。書き込みマスク k を使用して結果を戻り値の 128 ビット・レーンの下位 64 ビットに格納し (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)、a の 128 ビット・レーンの上位 64 ビットを dst の 128 ビット・レーンの上位 64 ビットにコピーします。



_mm256_maskz_shufflelo_epi16

__m256i _mm256_maskz_shufflelo_epi16(__mmask16 k, __m256i a, int imm)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpshuflw

imm のコントロールを使用して、a の 128 ビット・レーンの下位 64 ビットにある 16 ビット整数をシャッフルします。ゼロマスク k を使用して結果を戻り値の 128 ビット・レーンの下位 64 ビットに格納し (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)、a の 128 ビット・レーンの上位 64 ビットを dst の 128 ビット・レーンの上位 64 ビットにコピーします。



_mm512_mask_shufflelo_epi16

__m512i _mm512_mask_shufflelo_epi16(__m512i src, __mmask32 k, __m512i a, int imm)

CPUID フラグ: AVX512BW

命令: vpshuflw

imm のコントロールを使用して、a の 128 ビット・レーンの下位 64 ビットにある 16 ビット整数をシャッフルします。書き込みマスク k を使用して結果を戻り値の 128 ビット・レーンの下位 64 ビットに格納し (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)、a の 128 ビット・レーンの上位 64 ビットを dst の 128 ビット・レーンの上位 64 ビットにコピーします。



_mm512_maskz_shufflelo_epi16

__m512i _mm512_maskz_shufflelo_epi16(__mmask32 k, __m512i a, int imm)

CPUID フラグ: AVX512BW

命令: vpshuflw

imm のコントロールを使用して、a の 128 ビット・レーンの下位 64 ビットにある 16 ビット整数をシャッフルします。ゼロマスク k を使用して結果を戻り値の 128 ビット・レーンの下位 64 ビットに格納し (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)、a の 128 ビット・レーンの上位 64 ビットを dst の 128 ビット・レーンの上位 64 ビットにコピーします。



_mm512_shufflelo_epi16

__m512i _mm512_shufflelo_epi16(__m512i a, int imm)

CPUID フラグ: AVX512BW

命令: vpshuflw

imm のコントロールを使用して、a の 128 ビット・レーンの下位 64 ビットにある 16 ビット整数をシャッフルします。結果を戻り値の 128 ビット・レーンの下位 64 ビットに格納し、a の 128 ビット・レーンの上位 64 ビットを dst の 128 ビット・レーンの上位 64 ビットにコピーします。



_mm_mask_unpackhi_epi8

__m128i _mm_mask_unpackhi_epi8(__m128i src, __mmask16 k, __m128i a, __m128i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpunpckhbw

ab の上位半分から 8 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_unpackhi_epi8

__m128i _mm_maskz_unpackhi_epi8(__mmask16 k, __m128i a, __m128i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpunpckhbw

ab の上位半分から 8 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_unpackhi_epi8

__m256i _mm256_mask_unpackhi_epi8(__m256i src, __mmask32 k, __m256i a, __m256i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpunpckhbw

ab の各 128 ビット・レーンの上位半分から 8 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_unpackhi_epi8

__m256i _mm256_maskz_unpackhi_epi8(__mmask32 k, __m256i a, __m256i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpunpckhbw

ab の各 128 ビット・レーンの上位半分から 8 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_mask_unpackhi_epi8

__m512i _mm512_mask_unpackhi_epi8(__m512i src, __mmask64 k, __m512i a, __m512i b)

CPUID フラグ: AVX512BW

命令: vpunpckhbw

ab の各 128 ビット・レーンの上位半分から 8 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_unpackhi_epi8

__m512i _mm512_maskz_unpackhi_epi8(__mmask64 k, __m512i a, __m512i b)

CPUID フラグ: AVX512BW

命令: vpunpckhbw

ab の各 128 ビット・レーンの上位半分から 8 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_unpackhi_epi8

__m512i _mm512_unpackhi_epi8(__m512i a, __m512i b)

CPUID フラグ: AVX512BW

命令: vpunpckhbw

ab の各 128 ビット・レーンの上位半分から 8 ビット整数をアンパックして、インターリーブし、結果を返します。



_mm_mask_unpackhi_epi32

__m128i _mm_mask_unpackhi_epi32(__m128i src, __mmask8 k, __m128i a, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpunpckhdq

ab の上位半分から 32 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_unpackhi_epi32

__m128i _mm_maskz_unpackhi_epi32(__mmask8 k, __m128i a, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpunpckhdq

ab の上位半分から 32 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_unpackhi_epi32

__m256i _mm256_mask_unpackhi_epi32(__m256i src, __mmask8 k, __m256i a, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpunpckhdq

ab の各 128 ビット・レーンの上位半分から 32 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_unpackhi_epi32

__m256i _mm256_maskz_unpackhi_epi32(__mmask8 k, __m256i a, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpunpckhdq

ab の各 128 ビット・レーンの上位半分から 32 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_unpackhi_epi64

__m128i _mm_mask_unpackhi_epi64(__m128i src, __mmask8 k, __m128i a, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpunpckhqdq

ab の上位半分から 64 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_unpackhi_epi64

__m128i _mm_maskz_unpackhi_epi64(__mmask8 k, __m128i a, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpunpckhqdq

ab の上位半分から 64 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_unpackhi_epi64

__m256i _mm256_mask_unpackhi_epi64(__m256i src, __mmask8 k, __m256i a, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpunpckhqdq

ab の各 128 ビット・レーンの上位半分から 64 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_unpackhi_epi64

__m256i _mm256_maskz_unpackhi_epi64(__mmask8 k, __m256i a, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpunpckhqdq

ab の各 128 ビット・レーンの上位半分から 64 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_unpackhi_epi16

__m128i _mm_mask_unpackhi_epi16(__m128i src, __mmask8 k, __m128i a, __m128i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpunpckhwd

ab の上位半分から 16 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_unpackhi_epi16

__m128i _mm_maskz_unpackhi_epi16(__mmask8 k, __m128i a, __m128i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpunpckhwd

ab の上位半分から 16 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_unpackhi_epi16

__m256i _mm256_mask_unpackhi_epi16(__m256i src, __mmask16 k, __m256i a, __m256i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpunpckhwd

ab の各 128 ビット・レーンの上位半分から 16 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_unpackhi_epi16

__m256i _mm256_maskz_unpackhi_epi16(__mmask16 k, __m256i a, __m256i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpunpckhwd

ab の各 128 ビット・レーンの上位半分から 16 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_mask_unpackhi_epi16

__m512i _mm512_mask_unpackhi_epi16(__m512i src, __mmask32 k, __m512i a, __m512i b)

CPUID フラグ: AVX512BW

命令: vpunpckhwd

ab の各 128 ビット・レーンの上位半分から 16 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_unpackhi_epi16

__m512i _mm512_maskz_unpackhi_epi16(__mmask32 k, __m512i a, __m512i b)

CPUID フラグ: AVX512BW

命令: vpunpckhwd

ab の各 128 ビット・レーンの上位半分から 16 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_unpackhi_epi16

__m512i _mm512_unpackhi_epi16(__m512i a, __m512i b)

CPUID フラグ: AVX512BW

命令: vpunpckhwd

ab の各 128 ビット・レーンの上位半分から 16 ビット整数をアンパックして、インターリーブし、結果を返します。



_mm_mask_unpacklo_epi8

__m128i _mm_mask_unpacklo_epi8(__m128i src, __mmask16 k, __m128i a, __m128i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpunpcklbw

ab の下位半分から 8 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_unpacklo_epi8

__m128i _mm_maskz_unpacklo_epi8(__mmask16 k, __m128i a, __m128i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpunpcklbw

ab の下位半分から 8 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_unpacklo_epi8

__m256i _mm256_mask_unpacklo_epi8(__m256i src, __mmask32 k, __m256i a, __m256i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpunpcklbw

ab の各 128 ビット・レーンの下位半分から 8 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_unpacklo_epi8

__m256i _mm256_maskz_unpacklo_epi8(__mmask32 k, __m256i a, __m256i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpunpcklbw

ab の各 128 ビット・レーンの下位半分から 8 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_mask_unpacklo_epi8

__m512i _mm512_mask_unpacklo_epi8(__m512i src, __mmask64 k, __m512i a, __m512i b)

CPUID フラグ: AVX512BW

命令: vpunpcklbw

ab の各 128 ビット・レーンの下位半分から 8 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_unpacklo_epi8

__m512i _mm512_maskz_unpacklo_epi8(__mmask64 k, __m512i a, __m512i b)

CPUID フラグ: AVX512BW

命令: vpunpcklbw

ab の各 128 ビット・レーンの下位半分から 8 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_unpacklo_epi8

__m512i _mm512_unpacklo_epi8(__m512i a, __m512i b)

CPUID フラグ: AVX512BW

命令: vpunpcklbw

ab の各 128 ビット・レーンの下位半分から 8 ビット整数をアンパックして、インターリーブし、結果を返します。



_mm_mask_unpacklo_epi32

__m128i _mm_mask_unpacklo_epi32(__m128i src, __mmask8 k, __m128i a, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpunpckldq

ab の下位半分から 32 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_unpacklo_epi32

__m128i _mm_maskz_unpacklo_epi32(__mmask8 k, __m128i a, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpunpckldq

ab の下位半分から 32 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_unpacklo_epi32

__m256i _mm256_mask_unpacklo_epi32(__m256i src, __mmask8 k, __m256i a, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpunpckldq

ab の各 128 ビット・レーンの下位半分から 32 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_unpacklo_epi32

__m256i _mm256_maskz_unpacklo_epi32(__mmask8 k, __m256i a, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpunpckldq

ab の各 128 ビット・レーンの下位半分から 32 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_unpacklo_epi64

__m128i _mm_mask_unpacklo_epi64(__m128i src, __mmask8 k, __m128i a, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpunpcklqdq

ab の下位半分から 64 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_unpacklo_epi64

__m128i _mm_maskz_unpacklo_epi64(__mmask8 k, __m128i a, __m128i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpunpcklqdq

ab の下位半分から 64 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_unpacklo_epi64

__m256i _mm256_mask_unpacklo_epi64(__m256i src, __mmask8 k, __m256i a, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpunpcklqdq

ab の各 128 ビット・レーンの下位半分から 64 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_unpacklo_epi64

__m256i _mm256_maskz_unpacklo_epi64(__mmask8 k, __m256i a, __m256i b)

CPUID フラグ: AVX512F、AVX512VL

命令: vpunpcklqdq

ab の各 128 ビット・レーンの下位半分から 64 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_mask_unpacklo_epi16

__m128i _mm_mask_unpacklo_epi16(__m128i src, __mmask8 k, __m128i a, __m128i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpunpcklwd

ab の下位半分から 16 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_unpacklo_epi16

__m128i _mm_maskz_unpacklo_epi16(__mmask8 k, __m128i a, __m128i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpunpcklwd

ab の下位半分から 16 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_mask_unpacklo_epi16

__m256i _mm256_mask_unpacklo_epi16(__m256i src, __mmask16 k, __m256i a, __m256i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpunpcklwd

ab の各 128 ビット・レーンの下位半分から 16 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_unpacklo_epi16

__m256i _mm256_maskz_unpacklo_epi16(__mmask16 k, __m256i a, __m256i b)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpunpcklwd

ab の各 128 ビット・レーンの下位半分から 16 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_mask_unpacklo_epi16

__m512i _mm512_mask_unpacklo_epi16(__m512i src, __mmask32 k, __m512i a, __m512i b)

CPUID フラグ: AVX512BW

命令: vpunpcklwd

ab の各 128 ビット・レーンの下位半分から 16 ビット整数をアンパックして、インターリーブし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_unpacklo_epi16

__m512i _mm512_maskz_unpacklo_epi16(__mmask32 k, __m512i a, __m512i b)

CPUID フラグ: AVX512BW

命令: vpunpcklwd

ab の各 128 ビット・レーンの下位半分から 16 ビット整数をアンパックして、インターリーブし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_unpacklo_epi16

__m512i _mm512_unpacklo_epi16(__m512i a, __m512i b)

CPUID フラグ: AVX512BW

命令: vpunpcklwd

ab の各 128 ビット・レーンの下位半分から 16 ビット整数をアンパックして、インターリーブし、結果を返します。



_mm512_kunpackd

__mmask64 _mm512_kunpackd(__mmask64 a, __mmask64 b)

CPUID フラグ: AVX512BW

命令: kunpckdq

マスク ab の 32 ビットをアンパックして、インターリーブし、64 ビットの結果を返します。



_mm512_kunpackw

__mmask32 _mm512_kunpackw(__mmask32 a, __mmask32 b)

CPUID フラグ: AVX512BW

命令: kunpckwd

マスク ab の 32 ビットをアンパックして、インターリーブし、32 ビットの結果を k に格納します。



_mm_fpclass_pd_mask

__mmask8 _mm_fpclass_pd_mask(__m128d a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vfpclasspd

a のパックド倍精度 (64 ビット) 浮動小数点要素について、imm で指定された特殊カテゴリーのテストを行い、結果をマスク値の対応するビットに格納します。



_mm_mask_fpclass_pd_mask

__mmask8 _mm_mask_fpclass_pd_mask(__mmask8 k1, __m128d a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vfpclasspd

a のパックド倍精度 (64 ビット) 浮動小数点要素について、imm で指定された特殊カテゴリーのテストを行い、ゼロマスク k1 を使用して結果をマスク値の対応するビットに格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_fpclass_pd_mask

__mmask8 _mm256_fpclass_pd_mask(__m256d a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vfpclasspd

a のパックド倍精度 (64 ビット) 浮動小数点要素について、imm で指定された特殊カテゴリーのテストを行い、結果をマスク値の対応するビットに格納します。



_mm256_mask_fpclass_pd_mask

__mmask8 _mm256_mask_fpclass_pd_mask(__mmask8 k1, __m256d a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vfpclasspd

a のパックド倍精度 (64 ビット) 浮動小数点要素について、imm で指定された特殊カテゴリーのテストを行い、ゼロマスク k1 を使用して結果をマスク値の対応するビットに格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_fpclass_pd_mask

__mmask8 _mm512_fpclass_pd_mask(__m512d a, int imm)

CPUID フラグ: AVX512DQ

命令: vfpclasspd

a のパックド倍精度 (64 ビット) 浮動小数点要素について、imm で指定された特殊カテゴリーのテストを行い、結果をマスク値の対応するビットに格納します。



_mm512_mask_fpclass_pd_mask

__mmask8 _mm512_mask_fpclass_pd_mask(__mmask8 k1, __m512d a, int imm)

CPUID フラグ: AVX512DQ

命令: vfpclasspd

a のパックド倍精度 (64 ビット) 浮動小数点要素について、imm で指定された特殊カテゴリーのテストを行い、ゼロマスク k1 を使用して結果をマスク値の対応するビットに格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_fpclass_ps_mask

__mmask8 _mm_fpclass_ps_mask(__m128 a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vfpclassps

a のパックド単精度 (32 ビット) 浮動小数点要素について、imm で指定された特殊カテゴリーのテストを行い、結果をマスク値の対応するビットに格納します。



_mm_mask_fpclass_ps_mask

__mmask8 _mm_mask_fpclass_ps_mask(__mmask8 k1, __m128 a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vfpclassps

a のパックド単精度 (32 ビット) 浮動小数点要素について、imm で指定された特殊カテゴリーのテストを行い、ゼロマスク k1 を使用して結果をマスク値の対応するビットに格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_fpclass_ps_mask

__mmask8 _mm256_fpclass_ps_mask(__m256 a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vfpclassps

a のパックド単精度 (32 ビット) 浮動小数点要素について、imm で指定された特殊カテゴリーのテストを行い、結果をマスク値の対応するビットに格納します。



_mm256_mask_fpclass_ps_mask

__mmask8 _mm256_mask_fpclass_ps_mask(__mmask8 k1, __m256 a, int imm)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vfpclassps

a のパックド単精度 (32 ビット) 浮動小数点要素について、imm で指定された特殊カテゴリーのテストを行い、ゼロマスク k1 を使用して結果をマスク値の対応するビットに格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_fpclass_ps_mask

__mmask16 _mm512_fpclass_ps_mask(__m512 a, int imm)

CPUID フラグ: AVX512DQ

命令: vfpclassps

a のパックド単精度 (32 ビット) 浮動小数点要素について、imm で指定された特殊カテゴリーのテストを行い、結果をマスク値の対応するビットに格納します。



_mm512_mask_fpclass_ps_mask

__mmask16 _mm512_mask_fpclass_ps_mask(__mmask16 k1, __m512 a, int imm)

CPUID フラグ: AVX512DQ

命令: vfpclassps

a のパックド単精度 (32 ビット) 浮動小数点要素について、imm で指定された特殊カテゴリーのテストを行い、ゼロマスク k1 を使用して結果をマスク値の対応するビットに格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_fpclass_sd_mask

__mmask8 _mm_fpclass_sd_mask(__m128d a, int imm)

CPUID フラグ: AVX512DQ

命令: vfpclasssd

a の下位の倍精度 (64 ビット) 浮動小数点要素について、imm で指定された特殊カテゴリーのテストを行い、結果をマスク値の対応するビットに格納します。



_mm_mask_fpclass_sd_mask

__mmask8 _mm_mask_fpclass_sd_mask(__mmask8 k1, __m128d a, int imm)

CPUID フラグ: AVX512DQ

命令: vfpclasssd

a の下位の倍精度 (64 ビット) 浮動小数点要素について、imm で指定された特殊カテゴリーのテストを行い、ゼロマスク k1 を使用して結果をマスク値の対応するビットに格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_fpclass_ss_mask

__mmask8 _mm_fpclass_ss_mask(__m128 a, int imm)

CPUID フラグ: AVX512DQ

命令: vfpclassss

a の下位の単精度 (32 ビット) 浮動小数点要素について、imm で指定された特殊カテゴリーのテストを行い、結果をマスク値の対応するビットに格納します。



_mm_mask_fpclass_ss_mask

__mmask8 _mm_mask_fpclass_ss_mask(__mmask8 k1, __m128 a, int imm)

CPUID フラグ: AVX512DQ

命令: vfpclassss

a の下位の単精度 (32 ビット) 浮動小数点要素について、imm で指定された特殊カテゴリーのテストを行い、ゼロマスク k1 を使用して結果をマスク値の対応するビットに格納します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_movepi8_mask

__mmask16 _mm_movepi8_mask(__m128i a)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpmovb2m

a の対応するパックド 8 ビット整数の最上位ビット (MSB) の値に応じて、マスク値の各ビットを設定します。



_mm256_movepi8_mask

__mmask32 _mm256_movepi8_mask(__m256i a)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpmovb2m

a の対応するパックド 8 ビット整数の最上位ビット (MSB) の値に応じて、マスク値の各ビットを設定します。



_mm512_movepi8_mask

__mmask64 _mm512_movepi8_mask(__m512i a)

CPUID フラグ: AVX512BW

命令: vpmovb2m

a の対応するパックド 8 ビット整数の最上位ビット (MSB) の値に応じて、マスク値の各ビットを設定します。



_mm_movepi32_mask

__mmask8 _mm_movepi32_mask(__m128i a)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vpmovd2m

a の対応するパックド 32 ビット整数の最上位ビット (MSB) の値に応じて、マスク値の各ビットを設定します。



_mm256_movepi32_mask

__mmask8 _mm256_movepi32_mask(__m256i a)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vpmovd2m

a の対応するパックド 32 ビット整数の最上位ビット (MSB) の値に応じて、マスク値の各ビットを設定します。



_mm512_movepi32_mask

__mmask16 _mm512_movepi32_mask(__m512i a)

CPUID フラグ: AVX512DQ

命令: vpmovd2m

a の対応するパックド 32 ビット整数の最上位ビット (MSB) の値に応じて、マスク値の各ビットを設定します。



_mm_movepi64_mask

__mmask8 _mm_movepi64_mask(__m128i a)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vpmovq2m

a の対応するパックド 64 ビット整数の最上位ビット (MSB) の値に応じて、マスク値の各ビットを設定します。



_mm256_movepi64_mask

__mmask8 _mm256_movepi64_mask(__m256i a)

CPUID フラグ: AVX512DQ、AVX512VL

命令: vpmovq2m

a の対応するパックド 64 ビット整数の最上位ビット (MSB) の値に応じて、マスク値の各ビットを設定します。



_mm512_movepi64_mask

__mmask8 _mm512_movepi64_mask(__m512i a)

CPUID フラグ: AVX512DQ

命令: vpmovq2m

a の対応するパックド 64 ビット整数の最上位ビット (MSB) の値に応じて、マスク値の各ビットを設定します。



_mm_movepi16_mask

__mmask8 _mm_movepi16_mask(__m128i a)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpmovw2m

a の対応するパックド 16 ビット整数の最上位ビット (MSB) の値に応じて、マスク値の各ビットを設定します。



_mm256_movepi16_mask

__mmask16 _mm256_movepi16_mask(__m256i a)

CPUID フラグ: AVX512BW、AVX512VL

命令: vpmovw2m

a の対応するパックド 16 ビット整数の最上位ビット (MSB) の値に応じて、マスク値の各ビットを設定します。



_mm512_movepi16_mask

__mmask32 _mm512_movepi16_mask(__m512i a)

CPUID フラグ: AVX512BW

命令: vpmovw2m

a の対応するパックド 16 ビット整数の最上位ビット (MSB) の値に応じて、マスク値の各ビットを設定します。



_mm_permutexvar_epi8

__m128i _mm_permutexvar_epi8(__m128i idx, __m128i a) 

CPUID フラグ: AVX512VBMI、AVX512VL

命令: vpermb

idx の対応するインデックスを使用して、a の 8 ビット整数を複数のレーンにわたってシャッフルし、結果を返します。



_mm_mask_permutexvar_epi8

__m128i _mm_mask_permutexvar_epi8(__m128i src, __mmask16 k, __m128i idx, __m128i a) 

CPUID フラグ: AVX512VBMI、AVX512VL

命令: vpermb

idx の対応するインデックスを使用して、a の 8 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm_maskz_permutexvar_epi8

__m128i _mm_maskz_permutexvar_epi8(__mmask16 k, __m128i idx, __m128i a) 

CPUID フラグ: AVX512VBMI、AVX512VL

命令: vpermb

idx の対応するインデックスを使用して、a の 8 ビット整数を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm256_permutexvar_epi8

__m256i _mm256_permutexvar_epi8(__m256i idx, __m256i a) 

CPUID フラグ: AVX512VBMI、AVX512VL

命令: vpermb

idx の対応するインデックスを使用して、a の 8 ビット整数を複数のレーンにわたってシャッフルし、結果を返します。



_mm256_mask_permutexvar_epi8

__m256i _mm256_mask_permutexvar_epi8(__m256i src, __mmask32 k, __m256i idx, __m256i a) 

CPUID フラグ: AVX512VBMI、AVX512VL

命令: vpermb

idx の対応するインデックスを使用して、a の 8 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm256_maskz_permutexvar_epi8

__m256i _mm256_maskz_permutexvar_epi8(__mmask32 k, __m256i idx, __m256i a) 

CPUID フラグ: AVX512VBMI、AVX512VL

命令: vpermb

idx の対応するインデックスを使用して、a の 8 ビット整数を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_permutexvar_epi8

__m512i _mm512_permutexvar_epi8(__m512i idx, __m512i a) 

CPUID フラグ: AVX512VBMI

命令: vpermb

idx の対応するセレクターとインデックスを使用して、ab の 8 ビット整数を複数のレーンにわたってシャッフルし、結果を返します。



_mm512_mask_permutexvar_epi8

__m512i _mm512_mask_permutexvar_epi8(__m512i src, __mmask64 k, __m512i idx, __m512i a) 

CPUID フラグ: AVX512VBMI

命令: vpermb

idx の対応するインデックスを使用して、a の 8 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は src の要素がコピーされます)。



_mm512_maskz_permutexvar_epi8

__m512i _mm512_maskz_permutexvar_epi8(__mmask64 k, __m512i idx, __m512i a) 

CPUID フラグ: AVX512VBMI

命令: vpermb

idx の対応するインデックスを使用して、a の 8 ビット整数を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm_permutex2var_epi8

__m128i _mm_permutex2var_epi8(__m128i a, __m128i idx, __m128i b) 

CPUID フラグ: AVX512VBMI、AVX512VL

命令: vpermi2b

idx の対応するインデックスを使用して、ab の 8 ビット整数をシャッフルし、結果を返します。



_mm_mask_permutex2var_epi8

__m128i _mm_mask_permutex2var_epi8(__m128i a, __mmask16 k, __m128i idx, __m128i b) 

CPUID フラグ: AVX512VBMI、AVX512VL

命令: vpermt2b

idx の対応するインデックスを使用して、ab の 8 ビット整数をシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は a の要素がコピーされます)。



_mm_mask2_permutex2var_epi8

__m128i _mm_mask2_permutex2var_epi8(__m128i a, __m128i idx, __mmask16 k, __m128i b) 

CPUID フラグ: AVX512VBMI、AVX512VL

命令: vpermi2b

idx の対応するインデックスを使用して、ab の 8 ビット整数をシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は idx の要素がコピーされます)。



_mm_maskz_permutex2var_epi8

__m128i _mm_maskz_permutex2var_epi8(__mmask16 k, __m128i a, __m128i idx, __m128i b) 

CPUID フラグ: AVX512VBMI、AVX512VL

命令: vpermi2b、vpermt2b

idx の対応するインデックスを使用して、ab の 8 ビット整数をシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。。



_mm256_permutex2var_epi8

__m256i _mm256_permutex2var_epi8(__m256i a, __m256i idx, __m256i b) 

CPUID フラグ: AVX512VBMI、AVX512VL

命令: vpermi2b

idx の対応するインデックスを使用して、ab の 8 ビット整数を複数のレーンにわたってシャッフルし、結果を返します。



_mm256_mask_permutex2var_epi8

__m256i _mm256_mask_permutex2var_epi8(__m256i a, __mmask32 k, __m256i idx, __m256i b) 

CPUID フラグ: AVX512VBMI、AVX512VL

命令: vpermt2b

idx の対応するインデックスを使用して、ab の 8 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は a の要素がコピーされます)。



_mm256_mask2_permutex2var_epi8

__m256i _mm256_mask2_permutex2var_epi8(__m256i a, __m256i idx, __mmask32 k, __m256i b) 

CPUID フラグ: AVX512VBMI、AVX512VL

命令: vpermi2b

idx の対応するインデックスを使用して、ab の 8 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は idx の要素がコピーされます)。



_mm256_maskz_permutex2var_epi8

__m256i _mm256_maskz_permutex2var_epi8(__mmask32 k, __m256i a, __m256i idx, __m256i b) 

CPUID フラグ: AVX512VBMI、AVX512VL

命令: vpermi2b、vpermt2b

idx の対応するインデックスを使用して、ab の 8 ビット整数を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。



_mm512_permutex2var_epi8

__m512i _mm512_permutex2var_epi8(__m512i a, __m512i idx, __m512i b) 

CPUID フラグ: AVX512VBMI

命令: vpermi2b

idx の対応するインデックスを使用して、ab の 8 ビット整数を複数のレーンにわたってシャッフルし、結果を返します。



_mm512_mask_permutex2var_epi8

__m512i _mm512_mask_permutex2var_epi8(__m512i a, __mmask64 k, __m512i idx, __m512i b) 

CPUID フラグ: AVX512VBMI

命令: vpermt2b

idx の対応するインデックスを使用して、ab の 8 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は a の要素がコピーされます)。



_mm512_mask2_permutex2var_epi8

__m512i _mm512_mask2_permutex2var_epi8(__m512i a, __m512i idx, __mmask64 k, __m512i b) 

CPUID フラグ: AVX512VBMI

命令: vpermi2b

idx の対応するインデックスを使用して、ab の 8 ビット整数を複数のレーンにわたってシャッフルし、書き込みマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は idx の要素がコピーされます)。



_mm512_maskz_permutex2var_epi8

__m512i _mm512_maskz_permutex2var_epi8(__mmask64 k, __m512i a, __m512i idx, __m512i b) 

CPUID フラグ: AVX512VBMI

命令: vpermi2b、vpermt2b

idx の対応するインデックスを使用して、ab の 8 ビット整数を複数のレーンにわたってシャッフルし、ゼロマスク k を使用して結果を返します (マスクの対応するビットが設定されていない場合は要素が 0 に設定されます)。