自学教程：C++ CALC函数代码示例

voidTEST (void){  int i, sign = 1;  UNION_TYPE (AVX512F_LEN, i_q) src1, src2;  MASK_TYPE res_ref, res1, res2;  MASK_TYPE mask = MASK_VALUE;  res1 = 0;  res2 = 0;  for (i = 0; i < SIZE; i++)    {      src1.a[i] = i * i * sign;      src2.a[i] = i + 20;      sign = -sign;    }  res1 = INTRINSIC (_testn_epi64_mask) (src1.x, src2.x);  res2 = INTRINSIC (_mask_testn_epi64_mask) (mask, src1.x, src2.x);  CALC (&res_ref, src1.a, src2.a);  if (res1 != res_ref)    abort ();  res_ref &= mask;  if (res2 != res_ref)    abort ();}

voidTEST (void){  UNION_TYPE (AVX512F_LEN, i_w) s1, s2, res1, res2, res3;  short res_ref[SIZE];  MASK_TYPE mask = MASK_VALUE;  int i;  int fail = 0;  for (i = 0; i < SIZE; i++)    {      s1.a[i] = i * 17 + i;      s2.a[i] = i * -17 + i * 2;      res2.a[i] = DEFAULT_VALUE;    }  res1.x = INTRINSIC (_maddubs_epi16) (s1.x, s2.x);  res2.x = INTRINSIC (_mask_maddubs_epi16) (res2.x, mask, s1.x, s2.x);  res3.x = INTRINSIC (_maskz_maddubs_epi16) (mask, s1.x, s2.x);  CALC(s1.a, s2.a, res_ref);  if (UNION_CHECK (AVX512F_LEN, i_w) (res1, res_ref))    abort ();  MASK_MERGE (i_w) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_w) (res2, res_ref))    abort ();  MASK_ZERO (i_w) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_w) (res3, res_ref))    abort ();}

voidTEST (void){  UNION_TYPE (AVX512F_LEN, i_b) s1, s2, res1, res2 ,res3;  MASK_TYPE mask = MASK_VALUE;  char res_ref[SIZE];  int i;  for (i = 0; i < SIZE; i++)    {      s1.a[i] = i + 15;      s2.a[i] = i + 14;      res2.a[i] = DEFAULT_VALUE;    }  res1.x = INTRINSIC (_avg_epu8) (s1.x, s2.x);  res2.x = INTRINSIC (_mask_avg_epu8) (res2.x, mask, s1.x, s2.x);  res3.x = INTRINSIC (_maskz_avg_epu8) (mask, s1.x, s2.x);  CALC (s1.a, s2.a, res_ref);  if (UNION_CHECK (AVX512F_LEN, i_b) (res1, res_ref))    abort ();  MASK_MERGE (i_b) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_b) (res2, res_ref))    abort ();  MASK_ZERO (i_b) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_b) (res3, res_ref))    abort ();}

static voidTEST (void){  UNION_TYPE (AVX512F_LEN, i_d) src1, src2, res1, res2, res3;  MASK_TYPE mask = MASK_VALUE;  int dst_ref[SIZE];  int i;  for (i = 0; i < SIZE; i++)    {      src1.a[i] = i + 50;      src2.a[i] = i + 100;    }  for (i = 0; i < SIZE; i++)    res2.a[i] = DEFAULT_VALUE;  res1.x = INTRINSIC (_mullo_epi32) (src1.x, src2.x);  res2.x = INTRINSIC (_mask_mullo_epi32) (res2.x, mask, src1.x, src2.x);  res3.x = INTRINSIC (_maskz_mullo_epi32) (mask, src1.x, src2.x);  CALC (src1.a, src2.a, dst_ref);  if (UNION_CHECK (AVX512F_LEN, i_d) (res1, dst_ref))    abort ();  MASK_MERGE (i_d) (dst_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_d) (res2, dst_ref))    abort ();  MASK_ZERO (i_d) (dst_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_d) (res3, dst_ref))    abort ();}

void staticTEST (void){  int i, sign;  UNION_TYPE (AVX512F_LEN, i_d) src1, src2, res1, res2, res3;  MASK_TYPE mask = MASK_VALUE;  int res_ref[SIZE];  for (i = 0; i < SIZE; i++)    {      src1.a[i] =  i * sign;      src2.a[i] = (i + 2000) * sign;      sign = -sign;      res2.a[i] = DEFAULT_VALUE;    }  res1.x = INTRINSIC (_min_epi32) (src1.x, src2.x);  res2.x = INTRINSIC (_mask_min_epi32) (res2.x, mask, src1.x, src2.x);  res3.x = INTRINSIC (_maskz_min_epi32) (mask, src1.x, src2.x);  CALC (src1.a, src2.a, res_ref);  if (UNION_CHECK (AVX512F_LEN, i_d) (res1, res_ref))    abort ();  MASK_MERGE (i_d) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_d) (res2, res_ref))    abort ();  MASK_ZERO (i_d) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_d) (res3, res_ref))    abort ();}

voidTEST (void){  int i;  UNION_TYPE (AVX512F_LEN, i_q) src1, src2;  MASK_TYPE res1, res_ref, res2;  res1 = 0;  for (i = 0; i < SIZE / 2; i++)    {      src1.a[i * 2] = i;      src1.a[i * 2 + 1] = i * i;      src2.a[i * 2] = 2 * i;      src2.a[i * 2 + 1] = i * i;    }  res1 = INTRINSIC (_cmplt_epi64_mask) (src1.x, src2.x);  res2 = INTRINSIC (_mask_cmplt_epi64_mask) (MASK_VALUE, src1.x, src2.x);  CALC (&res_ref, src1.a, src2.a);  if (res1 != res_ref)    abort ();  res_ref &= MASK_VALUE;  if (res2 != res_ref)    abort ();}

voidTEST (void){  UNION_TYPE (AVX512F_LEN, d) s1, s2, res1, res2, res3;  MASK_TYPE mask = MASK_VALUE;  double res_ref[SIZE];  int i, sign = 1;  for (i = 0; i < SIZE; i++)    {      s1.a[i] = 234.567 * i * sign;      s2.a[i] = 100 * (i + 1);      res2.a[i] = DEFAULT_VALUE;      sign = -sign;    }  res1.x = INTRINSIC (_range_pd) (s1.x, s2.x, IMM);  res2.x = INTRINSIC (_mask_range_pd) (res2.x, mask, s1.x, s2.x, IMM);  res3.x = INTRINSIC (_maskz_range_pd) (mask, s1.x, s2.x, IMM);  CALC (s1.a, s2.a, res_ref);  if (UNION_CHECK (AVX512F_LEN, d) (res1, res_ref))    abort ();  MASK_MERGE (d) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, d) (res2, res_ref))    abort ();  MASK_ZERO (d) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, d) (res3, res_ref))    abort ();}

void staticTEST (void){  UNION_TYPE (AVX512F_LEN, d) s, res1, res2, res3;  MASK_TYPE mask = MASK_VALUE;  double res_ref[SIZE];  int i;  for (i = 0; i < SIZE; i++)    {      s.a[i] = i * 123.2 + 32.6;      res2.a[i] = DEFAULT_VALUE;    }  res1.x = INTRINSIC (_movedup_pd) (s.x);  res2.x = INTRINSIC (_mask_movedup_pd) (res2.x, mask, s.x);  res3.x = INTRINSIC (_maskz_movedup_pd) (mask, s.x);  CALC (s.a, res_ref);  if (UNION_CHECK (AVX512F_LEN, d) (res1, res_ref))    abort ();  MASK_MERGE (d) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, d) (res2, res_ref))    abort ();  MASK_ZERO (d) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, d) (res3, res_ref))    abort ();}

void staticTEST (void){  int i, sign;  UNION_TYPE (AVX512F_LEN, d) res1, res2, res3, src1, src2;  MASK_TYPE mask = MASK_VALUE;  double res_ref[SIZE];  sign = -1;  for (i = 0; i < SIZE; i++)    {      src1.a[i] = 1.5 + 34.67 * i * sign;      src2.a[i] = -22.17 * i * sign;      sign = sign * -1;    }  for (i = 0; i < SIZE; i++)    res2.a[i] = DEFAULT_VALUE;  res1.x = INTRINSIC (_max_pd) (src1.x, src2.x);  res2.x = INTRINSIC (_mask_max_pd) (res2.x, mask, src1.x, src2.x);  res3.x = INTRINSIC (_maskz_max_pd) (mask, src1.x, src2.x);  CALC (res_ref, src1.a, src2.a);  if (UNION_CHECK (AVX512F_LEN, d) (res1, res_ref))    abort ();  MASK_MERGE (d) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, d) (res2, res_ref))    abort ();  MASK_ZERO (d) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, d) (res3, res_ref))    abort ();}

voidTEST (void){  UNION_TYPE (AVX512F_LEN, d) s1, s2, res1, res2, res3;  MASK_TYPE mask = MASK_VALUE;  double res_ref[SIZE];  int i;  for (i = 0; i < SIZE; i++)    {      s1.a[i] = 13. * i;      s2.a[i] = 17. * i;      res2.a[i] = DEFAULT_VALUE;    }  res1.x = INTRINSIC (_and_pd) (s1.x, s2.x);  res2.x = INTRINSIC (_mask_and_pd) (res2.x, mask, s1.x, s2.x);  res3.x = INTRINSIC (_maskz_and_pd) (mask, s1.x, s2.x);  CALC (s1.a, s2.a, res_ref);  if (UNION_CHECK (AVX512F_LEN, d) (res1, res_ref))    abort ();  MASK_MERGE (d) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, d) (res2, res_ref))    abort ();  MASK_ZERO (d) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, d) (res3, res_ref))    abort ();}

voidTEST (void){  int i;  UNION_TYPE (AVX512F_LEN, i_w) res1, res2, res3, src1, src2;  MASK_TYPE mask = MASK_VALUE;  unsigned short res_ref[SIZE];  for (i = 0; i < SIZE; i++)    {      src1.a[i] = 2 + 7 * i % 291;      src2.a[i] = 3 + 11 * (i % 377) * i;    }  for (i = 0; i < SIZE; i++)    res2.a[i] = DEFAULT_VALUE;  res1.x = INTRINSIC (_subs_epu16) (src1.x, src2.x);  res2.x = INTRINSIC (_mask_subs_epu16) (res2.x, mask, src1.x, src2.x);  res3.x = INTRINSIC (_maskz_subs_epu16) (mask, src1.x, src2.x);  CALC (res_ref, src1.a, src2.a);  if (UNION_CHECK (AVX512F_LEN, i_w) (res1, res_ref))    abort ();  MASK_MERGE (i_w) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_w) (res2, res_ref))    abort ();  MASK_ZERO (i_w) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_w) (res3, res_ref))    abort ();}

voidTEST (void){  UNION_TYPE (AVX512F_LEN, d) s;  UNION_TYPE (AVX512F_LEN, i_q) res1, res2, res3;  MASK_TYPE mask = MASK_VALUE;  unsigned long long res_ref[SIZE];  int i;  for (i = 0; i < SIZE; i++)    {      s.a[i] = 123.456 * (i + 2000);      res2.a[i] = DEFAULT_VALUE;    }  res1.x = INTRINSIC (_cvttpd_epu64) (s.x);  res2.x = INTRINSIC (_mask_cvttpd_epu64) (res2.x, mask, s.x);  res3.x = INTRINSIC (_maskz_cvttpd_epu64) (mask, s.x);  CALC (s.a, res_ref);  if (UNION_CHECK (AVX512F_LEN, i_q) (res1, res_ref))    abort ();  MASK_MERGE (i_q) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_q) (res2, res_ref))    abort ();  MASK_ZERO (i_q) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_q) (res3, res_ref))    abort ();}

static voidTEST (void){  int ck[SIZE];  int i;  UNION_TYPE (AVX512F_LEN, i_d) s, d, dm, dz;  MASK_TYPE mask = MASK_VALUE;  for (i = 0; i < SIZE; i++)    {      s.a[i] = i * 7 + (i << 15) + 356;      d.a[i] = DEFAULT_VALUE;      dm.a[i] = DEFAULT_VALUE;      dz.a[i] = DEFAULT_VALUE;    }  CALC (s.a, ck);  d.x = INTRINSIC (_abs_epi32) (s.x);  dz.x = INTRINSIC (_maskz_abs_epi32) (mask, s.x);  dm.x = INTRINSIC (_mask_abs_epi32) (dm.x, mask, s.x);  if (UNION_CHECK (AVX512F_LEN, i_d) (d, ck))    abort ();  MASK_MERGE (i_d) (ck, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_d) (dm, ck))    abort ();  MASK_ZERO (i_d) (ck, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_d) (dz, ck))    abort ();}

voidTEST (void){  UNION_TYPE (AVX512F_LEN, i_d) res1, res2, res3, src, src0;  MASK_TYPE mask = MASK_VALUE;  TYPE res_ref[SIZE];  src.x = INTRINSIC (_set1_epi8) (0x3D);  int i;  for (i = 0; i < SIZE; i++)  {    res_ref[i] = CALC (src.a[i]);    src0.a[i] = DEFAULT_VALUE;  }  res1.x = INTRINSIC (_popcnt_epi32)       (src.x);  res2.x = INTRINSIC (_mask_popcnt_epi32)  (src.x, mask, src0.x);  res3.x = INTRINSIC (_maskz_popcnt_epi32) (mask, src.x);  if (UNION_CHECK (AVX512F_LEN, i_d) (res1, res_ref))    abort ();  MASK_MERGE (i_d) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_d) (res2, res_ref))    abort ();  MASK_ZERO (i_d) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_d) (res3, res_ref))    abort ();}

voidTEST (void){  int i, sign;  UNION_TYPE (AVX512F_LEN, i_d) res1, res2, res3;  UNION_TYPE (256, i_d) src;  MASK_TYPE mask = SIZE | 123;  int res_ref[SIZE];  sign = -1;  for (i = 0; i < 8; i++)    {      src.a[i] = 34 * i * sign;      sign = sign * -1;    }  for (i = 0; i < SIZE; i++)    res2.a[i] = DEFAULT_VALUE;  res1.x = INTRINSIC (_broadcast_i32x8) (src.x);  res2.x = INTRINSIC (_mask_broadcast_i32x8) (res2.x, mask, src.x);  res3.x = INTRINSIC (_maskz_broadcast_i32x8) (mask, src.x);  CALC (res_ref, src.a);  if (UNION_CHECK (AVX512F_LEN, i_d) (res1, res_ref))    abort ();  MASK_MERGE (i_d) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_d) (res2, res_ref))    abort ();  MASK_ZERO (i_d) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_d) (res3, res_ref))    abort ();}

voidTEST (void){  int i;  UNION_TYPE (AVX512F_LEN, i_ud) src1, src2, res1, res2, res3;  MASK_TYPE mask = MASK_VALUE;  unsigned res_ref[SIZE];  for (i = 0; i < SIZE; i++)    {      src1.a[i] = i * i;      src2.a[i] = i + 20;      res2.a[i] = DEFAULT_VALUE;    }  res1.x = INTRINSIC (_min_epu32) (src1.x, src2.x);  res2.x = INTRINSIC (_mask_min_epu32) (res2.x, mask, src1.x, src2.x);  res3.x = INTRINSIC (_maskz_min_epu32) (mask, src1.x, src2.x);  CALC (src1.a, src2.a, res_ref);  if (UNION_CHECK (AVX512F_LEN, i_ud) (res1, res_ref))    abort ();  MASK_MERGE (i_ud) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_ud) (res2, res_ref))    abort ();  MASK_ZERO (i_ud) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_ud) (res3, res_ref))    abort ();}

void staticTEST (void){  UNION_TYPE (AVX512F_LEN, i_q) res1, res2, res3, s1, s2;  MASK_TYPE mask = MASK_VALUE;  long long res_ref[SIZE];  int i;  for (i = 0; i < SIZE; i++)    {      s1.a[i] = 2 * i;      s2.a[i] = i;      res2.a[i] = DEFAULT_VALUE;    }  res1.x = INTRINSIC (_alignr_epi64) (s1.x, s2.x, N);  res2.x = INTRINSIC (_mask_alignr_epi64) (res2.x, mask, s1.x, s2.x, N);  res3.x = INTRINSIC (_maskz_alignr_epi64) (mask, s1.x, s2.x, N);  CALC (s1.a, s2.a, res_ref);  if (UNION_CHECK (AVX512F_LEN, i_q) (res1, res_ref))      abort ();  MASK_MERGE (i_q) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_q) (res2, res_ref))      abort ();  MASK_ZERO (i_q) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_q) (res3, res_ref))      abort ();}

voidTEST (void){  UNION_TYPE (AVX512F_LEN, i_w) s1, s2, res1, res2, res3;  MASK_TYPE mask = MASK_VALUE;  short res_ref[SIZE];  int i, sign = 1;  for (i = 0; i < SIZE; i++)    {      s1.a[i] = i * sign;      s2.a[i] = i >> 2;      res2.a[i] = DEFAULT_VALUE;      sign = -sign;    }  res1.x = INTRINSIC (_srlv_epi16) (s1.x, s2.x);  res2.x = INTRINSIC (_mask_srlv_epi16) (res2.x, mask, s1.x, s2.x);  res3.x = INTRINSIC (_maskz_srlv_epi16) (mask, s1.x, s2.x);  CALC (s1.a, s2.a, res_ref);  if (UNION_CHECK (AVX512F_LEN, i_w) (res1, res_ref))    abort ();  MASK_MERGE (i_w) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_w) (res2, res_ref))    abort ();  MASK_ZERO (i_w) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_w) (res3, res_ref))    abort ();}

voidTEST (void){  int i, j;  UNION_TYPE (AVX512F_LEN, i_b) s1, s2, res, ind;  char res_ref[SIZE];  MASK_TYPE mask = MASK_VALUE;  for (i = 0; i < NUM; i++)    {      for (j = 0; j < SIZE; j++)	{	  ind.a[j] = DEFAULT_VALUE;	  s1.a[j] = i * 2 * j + 1;	  s2.a[j] = i * 2 * j;	  res.a[j] = DEFAULT_VALUE;	}      CALC (res_ref, s1.a, ind.a, s2.a);      res.x =	INTRINSIC (_mask2_permutex2var_epi8) (s1.x, ind.x, mask,					       s2.x);      MASK_MERGE (i_b) (res_ref, mask, SIZE);      if (UNION_CHECK (AVX512F_LEN, i_b) (res, res_ref))	abort ();    }}

voidTEST (void){  int i, sign;  UNION_TYPE (AVX512F_LEN, d) res1, res2, res3;  UNION_TYPE (128, d) src;  MASK_TYPE mask = MASK_VALUE;  double res_ref[SIZE];  sign = -1;  for (i = 0; i < 2; i++)    {      src.a[i] = 1.5 + 34.67 * i * sign;      sign = sign * -1;    }  for (i = 0; i < SIZE; i++)    res2.a[i] = DEFAULT_VALUE;  res1.x = INTRINSIC (_broadcastsd_pd) (src.x);  res2.x = INTRINSIC (_mask_broadcastsd_pd) (res2.x, mask, src.x);  res3.x = INTRINSIC (_maskz_broadcastsd_pd) (mask, src.x);  CALC (res_ref, src.a);  if (UNION_CHECK (AVX512F_LEN, d) (res1, res_ref))    abort ();  MASK_MERGE (d) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, d) (res2, res_ref))    abort ();  MASK_ZERO (d) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, d) (res3, res_ref))    abort ();}

voidTEST (void){  int i;  UNION_TYPE (AVX512F_LEN, i_b) src1, src2;  MASK_TYPE res_ref, res1, res2;  MASK_TYPE mask = MASK_VALUE;  for (i = 0; i < SIZE / 2; i++)    {      src1.a[i * 2] = i;      src1.a[i * 2 + 1] = i * i;      src2.a[i * 2] = 2 * i;      src2.a[i * 2 + 1] = i * i;    }  res1 = INTRINSIC (_cmple_epi8_mask) (src1.x, src2.x);  res2 = INTRINSIC (_mask_cmple_epi8_mask) (mask, src1.x, src2.x);  CALC (&res_ref, src1.a, src2.a);  if (res_ref != res1)    abort ();  res_ref &= mask;  if (res_ref != res2)    abort ();}

static voidTEST (void){  UNION_TYPE (AVX512F_LEN, d) s;  UNION_TYPE (AVX512F_LEN_HALF, i_d) res1, res2, res3;  MASK_TYPE mask = MASK_VALUE;  int res_ref[DST_SIZE] = { 0 };  int i, sign = 1;  for (i = 0; i < SRC_SIZE; i++)    {      s.a[i] = 123.456 * (i + 2000) * sign;      sign = -sign;    }  for (i = 0; i < DST_SIZE; i++)    res2.a[i] = DEFAULT_VALUE;  res1.x = INTRINSIC (_cvtpd_epi32) (s.x);  res2.x = INTRINSIC (_mask_cvtpd_epi32) (res2.x, mask, s.x);  res3.x = INTRINSIC (_maskz_cvtpd_epi32) (mask, s.x);  CALC (s.a, res_ref);  if (UNION_CHECK (AVX512F_LEN_HALF, i_d) (res1, res_ref))    abort ();  MASK_MERGE (i_d) (res_ref, mask, SRC_SIZE);  if (UNION_CHECK (AVX512F_LEN_HALF, i_d) (res2, res_ref))    abort ();  MASK_ZERO (i_d) (res_ref, mask, SRC_SIZE);  if (UNION_CHECK (AVX512F_LEN_HALF, i_d) (res3, res_ref))    abort ();}

void staticTEST (void){  int i;  UNION_TYPE (AVX512F_LEN, i_d) s1, s2, res, ind;  int res_ref[SIZE];  MASK_TYPE mask = MASK_VALUE;  for (i = 0; i < SIZE; i++)    {      ind.a[i] = DEFAULT_VALUE;      s1.a[i] = 34 * i + 1;      s2.a[i] = 34 * i;      res.a[i] = DEFAULT_VALUE;    }  CALC (res_ref, s1.a, ind.a, s2.a);  res.x =    INTRINSIC (_mask2_permutex2var_epi32) (s1.x, ind.x, mask, s2.x);  MASK_MERGE (i_d) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_d) (res, res_ref))    abort ();}

voidTEST (void){  UNION_TYPE (AVX512F_LEN, d) s, res1, res2, res3;  MASK_TYPE mask = MASK_VALUE;  double res_ref[SIZE];  int i, sign = 1;  for (i = 0; i < SIZE; i++)    {      s.a[i] = 123.456 * (i + 2000) * sign;      res2.a[i] = DEFAULT_VALUE;      sign = -sign;    }  res1.x = INTRINSIC (_rcp14_pd) (s.x);  res2.x = INTRINSIC (_mask_rcp14_pd) (res2.x, mask, s.x);  res3.x = INTRINSIC (_maskz_rcp14_pd) (mask, s.x);  CALC (s.a, res_ref);  if (UNION_ROUGH_CHECK (AVX512F_LEN, d) (res1, res_ref, 0.0001))    abort ();  MASK_MERGE (d) (res_ref, mask, SIZE);  if (UNION_ROUGH_CHECK (AVX512F_LEN, d) (res2, res_ref, 0.0001))    abort ();  MASK_ZERO (d) (res_ref, mask, SIZE);  if (UNION_ROUGH_CHECK (AVX512F_LEN, d) (res3, res_ref, 0.0001))    abort ();}

voidTEST (void){  int i, sign;  UNION_TYPE (AVX512F_LEN_HALF, i_b) res1, res2, res3;  UNION_TYPE (AVX512F_LEN, i_w) src;  MASK_TYPE mask = MASK_VALUE;  char res_ref[32];  sign = -1;  for (i = 0; i < SIZE; i++)    {      src.a[i] = 1 + 34 * i * sign;      sign = sign * -1;      res2.a[i] = DEFAULT_VALUE;    }  res1.x = INTRINSIC (_cvtsepi16_epi8) (src.x);  res2.x = INTRINSIC (_mask_cvtsepi16_epi8) (res2.x, mask, src.x);  res3.x = INTRINSIC (_maskz_cvtsepi16_epi8) (mask, src.x);  CALC (res_ref, src.a);  if (UNION_CHECK (AVX512F_LEN_HALF, i_b) (res1, res_ref))    abort ();  MASK_MERGE (i_b) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN_HALF, i_b) (res2, res_ref))    abort ();  MASK_ZERO (i_b) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN_HALF, i_b) (res3, res_ref))    abort ();}

static voidTEST (void){  union128i_w s;  UNION_TYPE (AVX512F_LEN, i_q) res1, res2, res3;  MASK_TYPE mask = MASK_VALUE;  long long int res_ref[SIZE];  int i;  for (i = 0; i < SIZE; i++)    {      s.a[i] = 2000 * i;      res2.a[i] = DEFAULT_VALUE;    }  res1.x = INTRINSIC (_cvtepu16_epi64) (s.x);  res2.x = INTRINSIC (_mask_cvtepu16_epi64) (res2.x, mask, s.x);  res3.x = INTRINSIC (_maskz_cvtepu16_epi64) (mask, s.x);  CALC (s.a, res_ref);  if (UNION_CHECK (AVX512F_LEN, i_q) (res1, res_ref))    abort ();  MASK_MERGE (i_q) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_q) (res2, res_ref))    abort ();  MASK_ZERO (i_q) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_q) (res3, res_ref))    abort ();}

static voidTEST (void){  UNION_TYPE (AVX512F_LEN, i_q) s, res1, res2, res3;  long long res_ref[SIZE];  MASK_TYPE mask = MASK_VALUE;  int i;  for (i = 0; i < SIZE; i++)    {      s.a[i] = 12345678 * (i % 5);      res1.a[i] = DEFAULT_VALUE;      res2.a[i] = DEFAULT_VALUE;      res3.a[i] = DEFAULT_VALUE;    }  res1.x = INTRINSIC (_conflict_epi64) (s.x);  res2.x = INTRINSIC (_mask_conflict_epi64) (res2.x, mask, s.x);  res3.x = INTRINSIC (_maskz_conflict_epi64) (mask, s.x);  CALC (s.a, res_ref);  if (UNION_CHECK (AVX512F_LEN, i_q) (res1, res_ref))    abort ();  MASK_MERGE (i_q) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_q) (res2, res_ref))    abort ();  MASK_ZERO (i_q) (res_ref, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_q) (res3, res_ref))    abort ();}

voidTEST (void){  UNION_TYPE (AVX512F_LEN, d) s1, res2, res3, res4, res5;  MASK_TYPE mask = MASK_VALUE;  double s2[SIZE];  double res_ref1[SIZE];  double res_ref2[SIZE];  double res_ref3[SIZE];  int i, sign = 1;  for (i = 0; i < SIZE; i++)    {      s1.a[i] = 123.456 * (i + 200) * sign;      s2[i] = 789.012 * (i + 300) * sign;      res2.a[i] = DEFAULT_VALUE;      res4.a[i] = DEFAULT_VALUE;      sign = -sign;    }  res2.x = INTRINSIC (_mask_expand_pd) (res2.x, mask, s1.x);  res3.x = INTRINSIC (_maskz_expand_pd) (mask, s1.x);  res4.x = INTRINSIC (_mask_expandloadu_pd) (res4.x, mask, s2);  res5.x = INTRINSIC (_maskz_expandloadu_pd) (mask, s2);  /* no mask is the same as all ones mask.  */  CALC (s1.a, res_ref1, MASK_ALL_ONES);  CALC (s1.a, res_ref2, mask);  CALC (s2, res_ref3, mask);  MASK_MERGE (d) (res_ref2, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, d) (res2, res_ref2))    abort ();  MASK_ZERO (d) (res_ref2, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, d) (res3, res_ref2))    abort ();  MASK_MERGE (d) (res_ref3, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, d) (res4, res_ref3))    abort ();  MASK_ZERO (d) (res_ref3, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, d) (res5, res_ref3))    abort ();}

static voidTEST (void){  UNION_TYPE (AVX512F_LEN, d) s1, s2, s3, res1, res2, res3, res4;  MASK_TYPE mask = MASK_VALUE;  double res_ref1[SIZE];  double res_ref2[SIZE];  int i, sign = 1;  for (i = 0; i < SIZE; i++)    {      s1.a[i] = DEFAULT_VALUE;      s2.a[i] = 56.78 * (i + 1) * sign;      s3.a[i] = 90.12 * (i + 2) * sign;      sign = -sign;    }#if AVX512F_LEN == 512  res1.x = INTRINSIC (_fnmadd_pd) (s1.x, s2.x, s3.x);#endif  res2.x = INTRINSIC (_mask_fnmadd_pd) (s1.x, mask, s2.x, s3.x);  res3.x = INTRINSIC (_mask3_fnmadd_pd) (s2.x, s3.x, s1.x, mask);  res4.x = INTRINSIC (_maskz_fnmadd_pd) (mask, s1.x, s2.x, s3.x);  CALC (s1.a, s2.a, s3.a, res_ref1);  CALC (s2.a, s3.a, s1.a, res_ref2);#if AVX512F_LEN == 512  if (UNION_ROUGH_CHECK (AVX512F_LEN, d) (res1, res_ref1, 0.0001))    abort ();#endif  MASK_MERGE (d) (res_ref1, mask, SIZE);  if (UNION_ROUGH_CHECK (AVX512F_LEN, d) (res2, res_ref1, 0.0001))    abort ();  MASK_MERGE (d) (res_ref2, mask, SIZE);  if (UNION_ROUGH_CHECK (AVX512F_LEN, d) (res3, res_ref2, 0.0001))    abort ();  MASK_ZERO (d) (res_ref1, mask, SIZE);  if (UNION_ROUGH_CHECK (AVX512F_LEN, d) (res4, res_ref1, 0.0001))    abort ();}

static voidTEST (void){  UNION_TYPE (AVX512F_LEN, i_d) s1, res1, res2, res3, res4;  MASK_TYPE mask = MASK_VALUE;  int s2[SIZE];  int res_ref1[SIZE];  int res_ref2[SIZE];  int i, sign = 1;  for (i = 0; i < SIZE; i++)    {      s1.a[i] = 12345 * (i + 200) * sign;      s2[i] = 67890 * (i + 300) * sign;      res1.a[i] = DEFAULT_VALUE;      res3.a[i] = DEFAULT_VALUE;      sign = -sign;    }  res1.x = INTRINSIC (_mask_expand_epi32) (res1.x, mask, s1.x);  res2.x = INTRINSIC (_maskz_expand_epi32) (mask, s1.x);  res3.x = INTRINSIC (_mask_expandloadu_epi32) (res3.x, mask, s2);  res4.x = INTRINSIC (_maskz_expandloadu_epi32) (mask, s2);  CALC (s1.a, res_ref1, mask);  CALC (s2, res_ref2, mask);  MASK_MERGE (i_d) (res_ref1, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_d) (res1, res_ref1))    abort ();  MASK_ZERO (i_d) (res_ref1, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_d) (res2, res_ref1))    abort ();  MASK_MERGE (i_d) (res_ref2, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_d) (res3, res_ref2))    abort ();  MASK_ZERO (i_d) (res_ref2, mask, SIZE);  if (UNION_CHECK (AVX512F_LEN, i_d) (res4, res_ref2))    abort ();}