/*
 * This test was created to check the correctness
 * of the following intrinsics support:
 *      _mm_getexp_round_*()
 *      _mm_mask_getexp_round_*()
 *      _mm_maskz_getexp_round_*()
 *      _mm512_getexp_*()
 *      _mm512_getexp_round_*()
 *      _mm512_mask_getexp_*()
 *      _mm512_mask_getexp_round_*()
 *      _mm512_maskz_getexp_*()
 *      _mm512_maskz_getexp_round_*()
 */

#include "m512_test_util.h"
#include <math.h>
#include <memory.h>
#include <stdio.h>
#include <stdlib.h>

int show_op = 0;

static int NOINLINE check_ps(float val1[], float good[], int mask, int num_elem,
                             int zmask) {
  int i;
  int res = 1;

  for (i = 0; i < num_elem; i += 1) {
    if ((1 << i) & mask) {
      if (val1[i] != good[i]) {
        res = 0;
        printf("FAIL(%d): %f != %f\n", i, val1[i], good[i]);
      }
    } else if (zmask == 1) {
      if (val1[i] != 0) {
        res = 0;
        printf("FAIL(%d): %f != 0\n", i, val1[i]);
      }
    }
  }
  return (res);
}

static int NOINLINE check_ss(float val1[], float good[], float op2[], int mask,
                             int num_elem, int zmask) {
  int i = 0;
  int res = 1;

  // check first element
  if (0x1 & mask) {
    if (val1[i] != good[i]) {
      res = 0;
      printf("FAIL(%d): %f != %f\n", i, val1[i], good[i]);
    }
  } else if (zmask == 1) {
    if (val1[i] != 0) {
      res = 0;
      printf("FAIL(%d): %f != 0\n", i, val1[i]);
    }
  }

  // check other elements
  for (i = 1; i < num_elem; i += 1) {
    if (val1[i] != op2[i]) {
      res = 0;
      printf("FAIL(%d): %f != %f\n", i, val1[i], op2[i]);
    }
  }
  return (res);
}

static void NOINLINE print_f32_vec(char *pfx, float ivec[], int short_form) {
  if (pfx) {
    printf("%s: ", pfx);
  }
  if (!short_form) {
    printf("%10.4f %10.4f %10.4f %10.4f ", ivec[15], ivec[14], ivec[13],
           ivec[12]);
    printf("%10.4f %10.4f %10.4f %10.4f ", ivec[11], ivec[10], ivec[9],
           ivec[8]);
    printf("%10.4f %10.4f %10.4f %10.4f ", ivec[7], ivec[6], ivec[5], ivec[4]);
  }
  printf("%10.4f %10.4f %10.4f %10.4f\n", ivec[3], ivec[2], ivec[1], ivec[0]);
}

static void NOINLINE init_exp_f32(float ivalout[16], float ivalexp[16],
                                  float source[16]) {
  int i;
  float expected[] = {10.0, 7.0,  24.0, 5.0,  9.0, 2.0,  22.0, 6.0,
                      0.0,  21.0, 1.0,  18.0, 2.0, 22.0, 2.0,  16.0};

#pragma clang loop vectorize(disable)
  for (i = 0; i < 16; i += 1) {
    ivalout[i] = source[i];
    ivalexp[i] = floorf(log2(fabs((source[i]))));
    ivalexp[i] = expected[i];
  }
}

static int NOINLINE check_pd(double val1[], double good[], int mask,
                             int num_elem, int zmask) {
  int i;
  int res = 1;

  for (i = 0; i < num_elem; i += 1) {
    if ((1 << i) & mask) {
      if (val1[i] != good[i]) {
        res = 0;
        printf("FAIL(%d): %f != %f\n", i, val1[i], good[i]);
      }
    } else if (zmask == 1) {
      if (val1[i] != 0) {
        res = 0;
        printf("FAIL(%d): %f != 0\n", i, val1[i]);
      }
    }
  }
  return (res);
}

static int NOINLINE check_sd(double val1[], double good[], double op2[],
                             int mask, int num_elem, int zmask) {
  int i = 0;
  int res = 1;

  // check first element
  if (0x1 & mask) {
    if (val1[i] != good[i]) {
      res = 0;
      printf("FAIL(%d): %f != %f\n", i, val1[i], good[i]);
    }
  } else if (zmask == 1) {
    if (val1[i] != 0) {
      res = 0;
      printf("FAIL(%d): %f != 0\n", i, val1[i]);
    }
  }

  // check other elements
  for (i = 1; i < num_elem; i += 1) {
    if (val1[i] != op2[i]) {
      res = 0;
      printf("FAIL(%d): %f != %f\n", i, val1[i], op2[i]);
    }
  }
  return (res);
}

static void NOINLINE print_f64_vec(char *pfx, double ivec[], int short_form) {
  if (pfx) {
    printf("%s: ", pfx);
  }
  if (!short_form) {
    printf("%10.4f %10.4f %10.4f %10.4f ", ivec[7], ivec[6], ivec[5], ivec[4]);
  }
  printf("%10.4f %10.4f %10.4f %10.4f\n", ivec[3], ivec[2], ivec[1], ivec[0]);
}

static void NOINLINE init_exp_f64(double ivalout[8], double ivalexp[8],
                                  double source[8]) {
  int i;
  double expected[] = {10.0, 7.0, 24.0, 5.0, 9.0, 2.0, 22.0, 19.0};

#pragma clang loop vectorize(disable)
  for (i = 0; i < 8; i += 1) {
    ivalout[i] = source[i];

    //  MS does not support log2() therefore we will use pre-calculated values.
    //        ivalexp[i] = floor(log2(fabs((source[i]))));
    ivalexp[i] = expected[i];
  }
}

#define CHECK_RESULT_PS(FUNC, RES, GOOD, OP, MMASK, NUMB, ZEROM)               \
  {                                                                            \
    int passed = 0;                                                            \
    passed = check_ps(RES.f32, GOOD.f32, MMASK, NUMB, ZEROM);                  \
    if (!passed) {                                                             \
      printf("FAIL " #FUNC "\n");                                              \
      n_errs++;                                                                \
    }                                                                          \
    if (!passed || show_op) {                                                  \
      print_f32_vec("Opand1", OP.f32, 0);                                      \
      print_f32_vec("Scalar", GOOD.f32, 0);                                    \
      print_f32_vec("Vector", RES.f32, 0);                                     \
    }                                                                          \
  }

#define CHECK_RESULT_SS(FUNC, RES, GOOD, OP1, OP2, MMASK, NUMB, ZEROM)         \
  {                                                                            \
    int passed = 0;                                                            \
    passed = check_ss(RES.f32, GOOD.f32, OP2.f32, MMASK, NUMB, ZEROM);         \
    if (!passed) {                                                             \
      printf("FAIL " #FUNC "\n");                                              \
      n_errs++;                                                                \
    }                                                                          \
    if (!passed || show_op) {                                                  \
      print_f32_vec("Opand1", OP1.f32, 1);                                     \
      print_f32_vec("Opand2", OP2.f32, 1);                                     \
      print_f32_vec("Scalar", GOOD.f32, 1);                                    \
      print_f32_vec("Vector", RES.f32, 1);                                     \
    }                                                                          \
  }

#define CHECK_RESULT_PD(FUNC, RES, GOOD, OP, MMASK, NUMB, ZEROM)               \
  {                                                                            \
    int passed = 0;                                                            \
    passed = check_pd(RES.f64, GOOD.f64, MMASK, NUMB, ZEROM);                  \
    if (!passed) {                                                             \
      printf("FAIL " #FUNC "\n");                                              \
      n_errs++;                                                                \
    }                                                                          \
    if (!passed || show_op) {                                                  \
      print_f64_vec("Opand1", OP.f64, 0);                                      \
      print_f64_vec("Scalar", GOOD.f64, 0);                                    \
      print_f64_vec("Vector", RES.f64, 0);                                     \
    }                                                                          \
  }

#define CHECK_RESULT_SD(FUNC, RES, GOOD, OP1, OP2, MMASK, NUMB, ZEROM)         \
  {                                                                            \
    int passed = 0;                                                            \
    passed = check_sd(RES.f64, GOOD.f64, OP2.f64, MMASK, NUMB, ZEROM);         \
    if (!passed) {                                                             \
      printf("FAIL " #FUNC "\n");                                              \
      n_errs++;                                                                \
    }                                                                          \
    if (!passed || show_op) {                                                  \
      print_f64_vec("Opand1", OP1.f64, 1);                                     \
      print_f64_vec("Opand2", OP2.f64, 1);                                     \
      print_f64_vec("Scalar", GOOD.f64, 1);                                    \
      print_f64_vec("Vector", RES.f64, 1);                                     \
    }                                                                          \
  }

static void NOINLINE getexp_float() {
  V512 v0, v1, v2, v3, v4;

  float init[] = {1111.11, -222.22,    33333333.33, -44.44,
                  555.55,  -6.66,      7777777.77,  -86.88,
                  -1.11,   2222222.22, -3.33,       444444.44,
                  -5.55,   6666666.66, -7.77,       88888.88};

  init_exp_f32(v1.f32, v2.f32, init);
  v4.zmm = _mm512_set1_ps(1.0);
  v0.zmm = _mm512_setzero_ps();

  v3.zmm = _mm512_getexp_ps(v1.zmm);
  CHECK_RESULT_PS(_mm512_getexp_ps, v3, v2, v1, 0xffff, 16, 0);

  v3.zmm = _mm512_mask_getexp_ps(v0.zmm, 0x1ff8, v1.zmm);
  CHECK_RESULT_PS(_mm512_mask_getexp_ps, v3, v2, v1, 0x1ff8, 16, 0);

  v3.zmm = _mm512_maskz_getexp_ps(0xf18f, v1.zmm);
  CHECK_RESULT_PS(_mm512_maskz_getexp_ps, v3, v2, v1, 0xf18f, 16, 1);

  v3.zmm = _mm512_getexp_round_ps(v1.zmm, _MM_FROUND_TO_NEAREST_INT |
                                              _MM_FROUND_NO_EXC);
  CHECK_RESULT_PS(_mm512_getexp_round_ps, v3, v2, v1, 0xffff, 16, 0);

  v3.zmm = _mm512_mask_getexp_round_ps(
      v0.zmm, 0x1ff8, v1.zmm, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
  CHECK_RESULT_PS(_mm512_mask_getexp_round_ps, v3, v2, v1, 0x1ff8, 16, 0);

  v3.zmm = _mm512_maskz_getexp_round_ps(
      0xf18f, v1.zmm, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
  CHECK_RESULT_PS(_mm512_maskz_getexp_round_ps, v3, v2, v1, 0xf18f, 16, 1);

  v3.xmm[0] = _mm_getexp_round_ss(
      v4.xmm[0], v1.xmm[0], _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
  CHECK_RESULT_SS(_mm_getexp_round_ss, v3, v2, v1, v4, 0x1, 4, 0);

  v3.xmm[0] =
      _mm_mask_getexp_round_ss(v0.xmm[0], 0x1, v4.xmm[0], v1.xmm[0],
                               _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
  CHECK_RESULT_SS(_mm_mask_getexp_round_ss, v3, v2, v1, v4, 0x1, 4, 0);

  v3.xmm[0] = _mm_maskz_getexp_round_ss(
      0x0, v4.xmm[0], v1.xmm[0], _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
  CHECK_RESULT_SS(_mm_maskz_getexp_round_ss, v3, v2, v1, v4, 0x0, 4, 1);
}

static void NOINLINE getexp_double() {
  V512 v0, v1, v2, v3, v4;

  double init[] = {1111.11, -222.22, 33333333.33, -44.44,
                   555.55,  -6.66,   7777777.77,  -888888.88};

  init_exp_f64(v1.f64, v2.f64, init);
  v4.zmmd = _mm512_set1_pd(1.0);
  v0.zmmd = _mm512_setzero_pd();

  v3.zmmd = _mm512_getexp_pd(v1.zmmd);
  CHECK_RESULT_PD(_mm512_getexp_pd, v3, v2, v1, 0xffff, 8, 0);

  v3.zmmd = _mm512_mask_getexp_pd(v0.zmmd, 0xf8, v1.zmmd);
  CHECK_RESULT_PD(_mm512_mask_getexp_pd, v3, v2, v1, 0xf8, 8, 0);

  v3.zmmd = _mm512_maskz_getexp_pd(0x8f, v1.zmmd);
  CHECK_RESULT_PD(_mm512_maskz_getexp_pd, v3, v2, v1, 0x8f, 8, 1);

  v3.zmmd = _mm512_getexp_round_pd(v1.zmmd, _MM_FROUND_TO_NEAREST_INT |
                                                _MM_FROUND_NO_EXC);
  CHECK_RESULT_PD(_mm512_getexp_round_pd, v3, v2, v1, 0xffff, 8, 0);

  v3.zmmd = _mm512_mask_getexp_round_pd(
      v0.zmmd, 0x1f, v1.zmmd, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
  CHECK_RESULT_PD(_mm512_mask_getexp_round_pd, v3, v2, v1, 0x1f, 8, 0);

  v3.zmmd = _mm512_maskz_getexp_round_pd(
      0xf1, v1.zmmd, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
  CHECK_RESULT_PD(_mm512_maskz_getexp_round_pd, v3, v2, v1, 0xf1, 8, 1);

  v3.xmmd[0] = _mm_getexp_round_sd(
      v4.xmmd[0], v1.xmmd[0], _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
  CHECK_RESULT_SD(_mm_getexp_round_sd, v3, v2, v1, v4, 0x1, 2, 0);

  v3.xmmd[0] =
      _mm_mask_getexp_round_sd(v0.xmmd[0], 0x1, v4.xmmd[0], v1.xmmd[0],
                               _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
  CHECK_RESULT_SD(_mm_mask_getexp_round_sd, v3, v2, v1, v4, 0x1, 2, 0);

  v3.xmmd[0] =
      _mm_maskz_getexp_round_sd(0x0, v4.xmmd[0], v1.xmmd[0],
                                _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
  CHECK_RESULT_SD(_mm_maskz_getexp_round_sd, v3, v2, v1, v4, 0x0, 2, 1);
}

int main() {
  getexp_float();
  getexp_double();

  if (n_errs != 0) {
    printf("FAILED\n");
    return 1;
  }

  printf("PASSED\n");
  return 0;
}