dist/tests/read_data.c

/* read_data,c -- Read data file and check function.

Copyright (C) 2008, 2009, 2010, 2011, 2012 INRIA

This file is part of GNU MPC.

GNU MPC is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the
Free Software Foundation; either version 3 of the License, or (at your
option) any later version.

GNU MPC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
more details.

You should have received a copy of the GNU Lesser General Public License
along with this program. If not, see http://www.gnu.org/licenses/ .
*/

#include <stdlib.h>
#include <string.h>
#include "mpc-tests.h"

char *pathname;
unsigned long line_number;
   /* file name with complete path and currently read line;
      kept globally to simplify parameter passing */
unsigned long test_line_number;
   /* start line of data test (which may extend over several lines) */
int nextchar;
   /* character appearing next in the file, may be EOF */

#define MPC_INEX_CMP(r, i, c)                                 \
  (((r) == TERNARY_NOT_CHECKED || (r) == MPC_INEX_RE(c))      \
   && ((i) == TERNARY_NOT_CHECKED || (i) == MPC_INEX_IM (c)))

#define MPFR_INEX_STR(inex)                     \
  (inex) == TERNARY_NOT_CHECKED ? "?"           \
    : (inex) == +1 ? "+1"                       \
    : (inex) == -1 ? "-1" : "0"

static const char *mpfr_rnd_mode [] =
  { "GMP_RNDN", "GMP_RNDZ", "GMP_RNDU", "GMP_RNDD" };

const char *rnd_mode[] =
  { "MPC_RNDNN", "MPC_RNDZN", "MPC_RNDUN", "MPC_RNDDN",
    "undefined", "undefined", "undefined", "undefined", "undefined",
    "undefined", "undefined", "undefined", "undefined", "undefined",
    "undefined", "undefined",
    "MPC_RNDNZ", "MPC_RNDZZ", "MPC_RNDUZ", "MPC_RNDDZ",
    "undefined", "undefined", "undefined", "undefined", "undefined",
    "undefined", "undefined", "undefined", "undefined", "undefined",
    "undefined", "undefined",
    "MPC_RNDNU", "MPC_RNDZU", "MPC_RNDUU", "MPC_RNDDU",
    "undefined", "undefined", "undefined", "undefined", "undefined",
    "undefined", "undefined", "undefined", "undefined", "undefined",
    "undefined", "undefined",
    "MPC_RNDND", "MPC_RNDZD", "MPC_RNDUD", "MPC_RNDDD",
    "undefined", "undefined", "undefined", "undefined", "undefined",
    "undefined", "undefined", "undefined", "undefined", "undefined",
    "undefined", "undefined",
  };

/* file functions */
FILE *
open_data_file (const char *file_name)
{
  FILE *fp;
  char *src_dir;
  char default_srcdir[] = ".";

  src_dir = getenv ("srcdir");
  if (src_dir == NULL)
    src_dir = default_srcdir;

  pathname = (char *) malloc ((strlen (src_dir)) + strlen (file_name) + 2);
  if (pathname == NULL)
    {
      printf ("Cannot allocate memory\n");
      exit (1);
    }
  sprintf (pathname, "%s/%s", src_dir, file_name);
  fp = fopen (pathname, "r");
  if (fp == NULL)
    {
      fprintf (stderr, "Unable to open %s\n", pathname);
      exit (1);
    }

  return fp;
}

void
close_data_file (FILE *fp)
{
  free (pathname);
  fclose (fp);
}

/* read primitives */
static void
skip_line (FILE *fp)
   /* skips characters until reaching '\n' or EOF; */
   /* '\n' is skipped as well                      */
{
   while (nextchar != EOF && nextchar != '\n')
     nextchar = getc (fp);
   if (nextchar != EOF)
     {
       line_number ++;
       nextchar = getc (fp);
     }
}

static void
skip_whitespace (FILE *fp)
   /* skips over whitespace if any until reaching EOF */
   /* or non-whitespace                               */
{
   while (isspace (nextchar))
     {
       if (nextchar == '\n')
         line_number ++;
       nextchar = getc (fp);
     }
}

void
skip_whitespace_comments (FILE *fp)
   /* skips over all whitespace and comments, if any */
{
   skip_whitespace (fp);
   while (nextchar == '#') {
      skip_line (fp);
      if (nextchar != EOF)
         skip_whitespace (fp);
   }
}


size_t
read_string (FILE *fp, char **buffer_ptr, size_t buffer_length, const char *name)
{
  size_t pos;
  char *buffer;

  pos = 0;
  buffer = *buffer_ptr;

  if (nextchar == '"')
    nextchar = getc (fp);
  else
    goto error;

  while (nextchar != EOF && nextchar != '"')
    {
      if (nextchar == '\n')
        line_number ++;
      if (pos + 1 > buffer_length)
        {
          buffer = (char *) realloc (buffer, 2 * buffer_length);
          if (buffer == NULL)
            {
              printf ("Cannot allocate memory\n");
              exit (1);
            }
          buffer_length *= 2;
        }
      buffer[pos++] = (char) nextchar;
      nextchar = getc (fp);
    }

  if (nextchar != '"')
    goto error;

  if (pos + 1 > buffer_length)
    {
      buffer = (char *) realloc (buffer, buffer_length + 1);
      if (buffer == NULL)
        {
          printf ("Cannot allocate memory\n");
          exit (1);
        }
      buffer_length *= 2;
    }
  buffer[pos] = '\0';

  nextchar = getc (fp);
  skip_whitespace_comments (fp);

  *buffer_ptr = buffer;

  return buffer_length;

 error:
  printf ("Error: Unable to read %s in file '%s' line '%lu'\n",
          name, pathname, line_number);
  exit (1);
}

/* All following read routines skip over whitespace and comments; */
/* so after calling them, nextchar is either EOF or the beginning */
/* of a non-comment token.                                        */
void
read_ternary (FILE *fp, int* ternary)
{
  switch (nextchar)
    {
    case '!':
      *ternary = TERNARY_ERROR;
      break;
    case '?':
      *ternary = TERNARY_NOT_CHECKED;
      break;
    case '+':
      *ternary = +1;
      break;
    case '0':
      *ternary = 0;
      break;
    case '-':
      *ternary = -1;
      break;
    default:
      printf ("Error: Unexpected ternary value '%c' in file '%s' line %lu\n",
              nextchar, pathname, line_number);
      exit (1);
    }

  nextchar = getc (fp);
  skip_whitespace_comments (fp);
}

void
read_mpfr_rounding_mode (FILE *fp, mpfr_rnd_t* rnd)
{
  switch (nextchar)
    {
    case 'n': case 'N':
      *rnd = GMP_RNDN;
      break;
    case 'z': case 'Z':
      *rnd = GMP_RNDZ;
      break;
    case 'u': case 'U':
      *rnd = GMP_RNDU;
      break;
    case 'd': case 'D':
      *rnd = GMP_RNDD;
      break;
    default:
      printf ("Error: Unexpected rounding mode '%c' in file '%s' line %lu\n",
              nextchar, pathname, line_number);
      exit (1);
    }

    nextchar = getc (fp);
    if (nextchar != EOF && !isspace (nextchar)) {
      printf ("Error: Rounding mode not followed by white space in file "
              "'%s' line %lu\n",
              pathname, line_number);
      exit (1);
    }
    skip_whitespace_comments (fp);
}

void
read_mpc_rounding_mode (FILE *fp, mpc_rnd_t* rnd)
{
   mpfr_rnd_t re, im;
   read_mpfr_rounding_mode (fp, &re);
   read_mpfr_rounding_mode (fp, &im);
   *rnd = MPC_RND (re, im);
}

void
read_int (FILE *fp, int *nread, const char *name)
{
  int n = 0;

  if (nextchar == EOF)
    {
      printf ("Error: Unexpected EOF when reading int "
              "in file '%s' line %lu\n",
              pathname, line_number);
      exit (1);
    }
  ungetc (nextchar, fp);
  n = fscanf (fp, "%i", nread);
  if (ferror (fp) || n == 0 || n == EOF)
    {
      printf ("Error: Cannot read %s in file '%s' line %lu\n",
              name, pathname, line_number);
      exit (1);
    }
  nextchar = getc (fp);
  skip_whitespace_comments (fp);
}

static void
read_uint (FILE *fp, unsigned long int *ui)
{
  int n = 0;

  if (nextchar == EOF)
    {
      printf ("Error: Unexpected EOF when reading uint "
              "in file '%s' line %lu\n",
              pathname, line_number);
      exit (1);
    }
  ungetc (nextchar, fp);
  n = fscanf (fp, "%lu", ui);
  if (ferror (fp) || n == 0 || n == EOF)
    {
      printf ("Error: Cannot read uint in file '%s' line %lu\n",
              pathname, line_number);
      exit (1);
    }
  nextchar = getc (fp);
  skip_whitespace_comments (fp);
}

static void
read_sint (FILE *fp, long int *si)
{
  int n = 0;

  if (nextchar == EOF)
    {
      printf ("Error: Unexpected EOF when reading sint "
              "in file '%s' line %lu\n",
              pathname, line_number);
      exit (1);
    }
  ungetc (nextchar, fp);
  n = fscanf (fp, "%li", si);
  if (ferror (fp) || n == 0 || n == EOF)
    {
      printf ("Error: Cannot read sint in file '%s' line %lu\n",
              pathname, line_number);
      exit (1);
    }
  nextchar = getc (fp);
  skip_whitespace_comments (fp);
}

mpfr_prec_t
read_mpfr_prec (FILE *fp)
{
   unsigned long prec;
   int n;

   if (nextchar == EOF) {
      printf ("Error: Unexpected EOF when reading mpfr precision "
              "in file '%s' line %lu\n",
              pathname, line_number);
      exit (1);
   }
   ungetc (nextchar, fp);
   n = fscanf (fp, "%lu", &prec);
   if (ferror (fp)) /* then also n == EOF */
      perror ("Error when reading mpfr precision");
   if (n == 0 || n == EOF || prec < MPFR_PREC_MIN || prec > MPFR_PREC_MAX) {
      printf ("Error: Impossible mpfr precision in file '%s' line %lu\n",
              pathname, line_number);
      exit (1);
   }
   nextchar = getc (fp);
   skip_whitespace_comments (fp);
   return (mpfr_prec_t) prec;
}

static void
read_mpfr_mantissa (FILE *fp, mpfr_ptr x)
{
   if (nextchar == EOF) {
      printf ("Error: Unexpected EOF when reading mpfr mantissa "
              "in file '%s' line %lu\n",
              pathname, line_number);
      exit (1);
   }
   ungetc (nextchar, fp);
   if (mpfr_inp_str (x, fp, 0, GMP_RNDN) == 0) {
      printf ("Error: Impossible to read mpfr mantissa "
              "in file '%s' line %lu\n",
              pathname, line_number);
      exit (1);
   }
   nextchar = getc (fp);
   skip_whitespace_comments (fp);
}

void
read_mpfr (FILE *fp, mpfr_ptr x, int *known_sign)
{
   int sign;
   mpfr_set_prec (x, read_mpfr_prec (fp));
   sign = nextchar;
   read_mpfr_mantissa (fp, x);

   /* the sign always matters for regular values ('+' is implicit),
      but when no sign appears before 0 or Inf in the data file, it means
      that only absolute value must be checked. */
   if (known_sign != NULL)
     *known_sign =
       (!mpfr_zero_p (x) && !mpfr_inf_p (x))
       || sign == '+' || sign == '-';
}

void
read_mpc (FILE *fp, mpc_ptr z, known_signs_t *ks)
{
  read_mpfr (fp, mpc_realref (z), ks == NULL ? NULL : &ks->re);
  read_mpfr (fp, mpc_imagref (z), ks == NULL ? NULL : &ks->im);
}

static void
check_compatible (int inex, mpfr_t expected, mpfr_rnd_t rnd, const char *s)
{
  if ((rnd == GMP_RNDU && inex == -1) ||
      (rnd == GMP_RNDD && inex == +1) ||
      (rnd == GMP_RNDZ && !mpfr_signbit (expected) && inex == +1) ||
      (rnd == GMP_RNDZ && mpfr_signbit (expected) && inex == -1))
    {
      if (s != NULL)
        printf ("Incompatible ternary value '%c' (%s part) in file '%s' line %lu\n",
              (inex == 1) ? '+' : '-', s, pathname, test_line_number);
      else
        printf ("Incompatible ternary value '%c' in file '%s' line %lu\n",
              (inex == 1) ? '+' : '-', pathname, test_line_number);
    }
}

/* read lines of data */
static void
read_cc (FILE *fp, int *inex_re, int *inex_im, mpc_ptr expected,
         known_signs_t *signs, mpc_ptr op, mpc_rnd_t *rnd)
{
  test_line_number = line_number;
  read_ternary (fp, inex_re);
  read_ternary (fp, inex_im);
  read_mpc (fp, expected, signs);
  read_mpc (fp, op, NULL);
  read_mpc_rounding_mode (fp, rnd);
  check_compatible (*inex_re, mpc_realref(expected), MPC_RND_RE(*rnd), "real");
  check_compatible (*inex_im, mpc_imagref(expected), MPC_RND_IM(*rnd), "imag");
}

static void
read_fc (FILE *fp, int *inex, mpfr_ptr expected, int *sign, mpc_ptr op,
         mpfr_rnd_t *rnd)
{
  test_line_number = line_number;
  read_ternary (fp, inex);
  read_mpfr (fp, expected, sign);
  read_mpc (fp, op, NULL);
  read_mpfr_rounding_mode (fp, rnd);
  check_compatible (*inex, expected, *rnd, NULL);
}

static void
read_ccc (FILE *fp, int *inex_re, int *inex_im, mpc_ptr expected,
          known_signs_t *signs, mpc_ptr op1, mpc_ptr op2, mpc_rnd_t *rnd)
{
  test_line_number = line_number;
  read_ternary (fp, inex_re);
  read_ternary (fp, inex_im);
  read_mpc (fp, expected, signs);
  read_mpc (fp, op1, NULL);
  read_mpc (fp, op2, NULL);
  read_mpc_rounding_mode (fp, rnd);
  check_compatible (*inex_re, mpc_realref(expected), MPC_RND_RE(*rnd), "real");
  check_compatible (*inex_im, mpc_imagref(expected), MPC_RND_IM(*rnd), "imag");
}

/* read lines of data for function with three mpc_t inputs and one mpc_t
   output like mpc_fma */
static void
read_cccc (FILE *fp, int *inex_re, int *inex_im, mpc_ptr expected,
	   known_signs_t *signs, mpc_ptr op1, mpc_ptr op2, mpc_ptr op3,
	   mpc_rnd_t *rnd)
{
  test_line_number = line_number;
  read_ternary (fp, inex_re);
  read_ternary (fp, inex_im);
  read_mpc (fp, expected, signs);
  read_mpc (fp, op1, NULL);
  read_mpc (fp, op2, NULL);
  read_mpc (fp, op3, NULL);
  read_mpc_rounding_mode (fp, rnd);
  check_compatible (*inex_re, mpc_realref(expected), MPC_RND_RE(*rnd), "real");
  check_compatible (*inex_im, mpc_imagref(expected), MPC_RND_IM(*rnd), "imag");
}

static void
read_cfc (FILE *fp, int *inex_re, int *inex_im, mpc_ptr expected,
          known_signs_t *signs, mpfr_ptr op1, mpc_ptr op2, mpc_rnd_t *rnd)
{
  test_line_number = line_number;
  read_ternary (fp, inex_re);
  read_ternary (fp, inex_im);
  read_mpc (fp, expected, signs);
  read_mpfr (fp, op1, NULL);
  read_mpc (fp, op2, NULL);
  read_mpc_rounding_mode (fp, rnd);
  check_compatible (*inex_re, mpc_realref(expected), MPC_RND_RE(*rnd), "real");
  check_compatible (*inex_im, mpc_imagref(expected), MPC_RND_IM(*rnd), "imag");
}

static void
read_ccf (FILE *fp, int *inex_re, int *inex_im, mpc_ptr expected,
          known_signs_t *signs, mpc_ptr op1, mpfr_ptr op2, mpc_rnd_t *rnd)
{
  test_line_number = line_number;
  read_ternary (fp, inex_re);
  read_ternary (fp, inex_im);
  read_mpc (fp, expected, signs);
  read_mpc (fp, op1, NULL);
  read_mpfr (fp, op2, NULL);
  read_mpc_rounding_mode (fp, rnd);
  check_compatible (*inex_re, mpc_realref(expected), MPC_RND_RE(*rnd), "real");
  check_compatible (*inex_im, mpc_imagref(expected), MPC_RND_IM(*rnd), "imag");
}

static void
read_ccu (FILE *fp, int *inex_re, int *inex_im, mpc_ptr expected,
          known_signs_t *signs, mpc_ptr op1, unsigned long int *op2, mpc_rnd_t *rnd)
{
  test_line_number = line_number;
  read_ternary (fp, inex_re);
  read_ternary (fp, inex_im);
  read_mpc (fp, expected, signs);
  read_mpc (fp, op1, NULL);
  read_uint (fp, op2);
  read_mpc_rounding_mode (fp, rnd);
  check_compatible (*inex_re, mpc_realref(expected), MPC_RND_RE(*rnd), "real");
  check_compatible (*inex_im, mpc_imagref(expected), MPC_RND_IM(*rnd), "imag");
}

static void
read_ccs (FILE *fp, int *inex_re, int *inex_im, mpc_ptr expected,
          known_signs_t *signs, mpc_ptr op1, long int *op2, mpc_rnd_t *rnd)
{
  test_line_number = line_number;
  read_ternary (fp, inex_re);
  read_ternary (fp, inex_im);
  read_mpc (fp, expected, signs);
  read_mpc (fp, op1, NULL);
  read_sint (fp, op2);
  read_mpc_rounding_mode (fp, rnd);
  check_compatible (*inex_re, mpc_realref(expected), MPC_RND_RE(*rnd), "real");
  check_compatible (*inex_im, mpc_imagref(expected), MPC_RND_IM(*rnd), "imag");
}

/* set MPFR flags to random values */
static void
set_mpfr_flags (int counter)
{
  if (counter & 1)
    mpfr_set_underflow ();
  else
    mpfr_clear_underflow ();
  if (counter & 2)
    mpfr_set_overflow ();
  else
    mpfr_clear_overflow ();
  /* the divide-by-0 flag was added in MPFR 3.1.0 */
#ifdef mpfr_set_divby0
  if (counter & 4)
    mpfr_set_divby0 ();
  else
    mpfr_clear_divby0 ();
#endif
  if (counter & 8)
    mpfr_set_nanflag ();
  else
    mpfr_clear_nanflag ();
  if (counter & 16)
    mpfr_set_inexflag ();
  else
    mpfr_clear_inexflag ();
  if (counter & 32)
    mpfr_set_erangeflag ();
  else
    mpfr_clear_erangeflag ();
}

/* Check MPFR flags: we allow that some flags are set internally by MPC,
   for example if MPC does internal computations (using MPFR) which yield
   an overflow, even if the final MPC result fits in the exponent range.
   However we don't allow MPC to *clear* the MPFR flags */
static void
check_mpfr_flags (int counter)
{
  int old, neu;

  old = (counter & 1) != 0;
  neu = mpfr_underflow_p () != 0;
  if (old && (neu == 0))
    {
      printf ("Error, underflow flag has been modified from %d to %d\n",
              old, neu);
      exit (1);
    }
  old = (counter & 2) != 0;
  neu = mpfr_overflow_p () != 0;
  if (old && (neu == 0))
    {
      printf ("Error, overflow flag has been modified from %d to %d\n",
              old, neu);
      exit (1);
    }
#ifdef mpfr_divby0_p
  old = (counter & 4) != 0;
  neu = mpfr_divby0_p () != 0;
  if (old && (neu == 0))
    {
      printf ("Error, divby0 flag has been modified from %d to %d\n",
              old, neu);
      exit (1);
    }
#endif
  old = (counter & 8) != 0;
  neu = mpfr_nanflag_p () != 0;
  if (old && (neu == 0))
    {
      printf ("Error, nanflag flag has been modified from %d to %d\n",
              old, neu);
      exit (1);
    }
  old = (counter & 16) != 0;
  neu = mpfr_inexflag_p () != 0;
  if (old && (neu == 0))
    {
      printf ("Error, inexflag flag has been modified from %d to %d\n",
              old, neu);
      exit (1);
    }
  old = (counter & 32) != 0;
  neu = mpfr_erangeflag_p () != 0;
  if (old && (neu == 0))
    {
      printf ("Error, erangeflag flag has been modified from %d to %d\n",
              old, neu);
      exit (1);
    }
}

/* data_check (function, data_file_name) checks function results against
 precomputed data in a file.*/
void
data_check (mpc_function function, const char *file_name)
{
  FILE *fp;

  int inex_re;
  mpfr_t x1, x2;
  mpfr_rnd_t mpfr_rnd = GMP_RNDN;
  int sign_real;

  int inex_im;
  mpc_t z1, z2, z3, z4, z5;
  mpc_rnd_t rnd = MPC_RNDNN;

  unsigned long int ui;
  long int si;

  known_signs_t signs;
  int inex = 0;

  static int rand_counter = 0;

  fp = open_data_file (file_name);

  /* 1. init needed variables */
  mpc_init2 (z1, 2);
  switch (function.type)
    {
    case FC:
      mpfr_init (x1);
      mpfr_init (x2);
      break;
    case CC: case CCU: case CCS:
      mpc_init2 (z2, 2);
      mpc_init2 (z3, 2);
      break;
    case C_CC:
      mpc_init2 (z2, 2);
      mpc_init2 (z3, 2);
      mpc_init2 (z4, 2);
      break;
    case CCCC:
      mpc_init2 (z2, 2);
      mpc_init2 (z3, 2);
      mpc_init2 (z4, 2);
      mpc_init2 (z5, 2);
      break;
    case CFC: case CCF:
      mpfr_init (x1);
      mpc_init2 (z2, 2);
      mpc_init2 (z3, 2);
      break;
    default:
      ;
    }

  /* 2. read data file */
  line_number = 1;
  nextchar = getc (fp);
  skip_whitespace_comments (fp);
  while (nextchar != EOF) {
      set_mpfr_flags (rand_counter);

      /* for each kind of function prototype: */
      /* 3.1 read a line of data: expected result, parameters, rounding mode */
      /* 3.2 compute function at the same precision as the expected result */
      /* 3.3 compare this result with the expected one */
      switch (function.type)
        {
        case FC: /* example mpc_norm */
          read_fc (fp, &inex_re, x1, &sign_real, z1, &mpfr_rnd);
          mpfr_set_prec (x2, mpfr_get_prec (x1));
          inex = function.pointer.FC (x2, z1, mpfr_rnd);
          if ((inex_re != TERNARY_NOT_CHECKED && inex_re != inex)
              || !same_mpfr_value (x1, x2, sign_real))
            {
              mpfr_t got, expected;
              mpc_t op;
              op[0] = z1[0];
              got[0] = x2[0];
              expected[0] = x1[0];
              printf ("%s(op) failed (%s:%lu)\nwith rounding mode %s\n",
                      function.name, file_name, test_line_number,
                      mpfr_rnd_mode[mpfr_rnd]);
              if (inex_re != TERNARY_NOT_CHECKED && inex_re != inex)
                printf("ternary value: got %s, expected %s\n",
                       MPFR_INEX_STR (inex), MPFR_INEX_STR (inex_re));
              MPC_OUT (op);
              printf ("     ");
              MPFR_OUT (got);
              MPFR_OUT (expected);

              exit (1);
            }
          break;

        case CC: /* example mpc_log */
          read_cc (fp, &inex_re, &inex_im, z1, &signs, z2, &rnd);
          mpfr_set_prec (mpc_realref (z3), MPC_PREC_RE (z1));
          mpfr_set_prec (mpc_imagref (z3), MPC_PREC_IM (z1));
          inex = function.pointer.CC (z3, z2, rnd);
          if (!MPC_INEX_CMP (inex_re, inex_im, inex)
              || !same_mpc_value (z3, z1, signs))
            {
              mpc_t op, got, expected; /* display sensible variable names */
              op[0] = z2[0];
              expected[0]= z1[0];
              got[0] = z3[0];
              printf ("%s(op) failed (line %lu)\nwith rounding mode %s\n",
                      function.name, test_line_number, rnd_mode[rnd]);
              if (!MPC_INEX_CMP (inex_re, inex_im, inex))
                printf("ternary value: got %s, expected (%s, %s)\n",
                       MPC_INEX_STR (inex),
                       MPFR_INEX_STR (inex_re), MPFR_INEX_STR (inex_im));
              MPC_OUT (op);
              printf ("     ");
              MPC_OUT (got);
              MPC_OUT (expected);

              exit (1);
            }
          break;

        case C_CC: /* example mpc_mul */
          read_ccc (fp, &inex_re, &inex_im, z1, &signs, z2, z3, &rnd);
          mpfr_set_prec (mpc_realref(z4), MPC_PREC_RE (z1));
          mpfr_set_prec (mpc_imagref(z4), MPC_PREC_IM (z1));
          inex = function.pointer.C_CC (z4, z2, z3, rnd);
          if (!MPC_INEX_CMP (inex_re, inex_im, inex)
              || !same_mpc_value (z4, z1, signs))
            {
              /* display sensible variable names */
              mpc_t op1, op2, got, expected;
              op1[0] = z2[0];
              op2[0] = z3[0];
              expected[0]= z1[0];
              got[0] = z4[0];
              printf ("%s(op) failed (line %lu)\nwith rounding mode %s\n",
                      function.name, test_line_number, rnd_mode[rnd]);
              if (!MPC_INEX_CMP (inex_re, inex_im, inex))
                printf("ternary value: got %s, expected (%s, %s)\n",
                       MPC_INEX_STR (inex),
                       MPFR_INEX_STR (inex_re), MPFR_INEX_STR (inex_im));
              MPC_OUT (op1);
              MPC_OUT (op2);
              printf ("     ");
              MPC_OUT (got);
              MPC_OUT (expected);

              exit (1);
            }
          if (function.properties & FUNC_PROP_SYMETRIC)
            {
              inex = function.pointer.C_CC (z4, z3, z2, rnd);
              if (!MPC_INEX_CMP (inex_re, inex_im, inex)
              || !same_mpc_value (z4, z1, signs))
                {
                  /* display sensible variable names */
                  mpc_t op1, op2, got, expected;
                  op1[0] = z3[0];
                  op2[0] = z2[0];
                  expected[0]= z1[0];
                  got[0] = z4[0];
                  printf ("%s(op) failed (line %lu/symetric test)\n"
                          "with rounding mode %s\n",
                          function.name, test_line_number, rnd_mode[rnd]);
                  if (!MPC_INEX_CMP (inex_re, inex_im, inex))
                    printf("ternary value: got %s, expected (%s, %s)\n",
                           MPC_INEX_STR (inex),
                           MPFR_INEX_STR (inex_re), MPFR_INEX_STR (inex_im));
                  MPC_OUT (op1);
                  MPC_OUT (op2);
                  printf ("     ");
                  MPC_OUT (got);
                  MPC_OUT (expected);

                  exit (1);
                }
            }
          break;

        case CCCC: /* example mpc_fma */
          read_cccc (fp, &inex_re, &inex_im, z1, &signs, z2, z3, z4, &rnd);
	  /* z1 is the expected value, z2, z3, z4 are the inputs, and z5 is
	     the computed value */
          mpfr_set_prec (mpc_realref(z5), MPC_PREC_RE (z1));
          mpfr_set_prec (mpc_imagref(z5), MPC_PREC_IM (z1));
          inex = function.pointer.CCCC (z5, z2, z3, z4, rnd);
          if (!MPC_INEX_CMP (inex_re, inex_im, inex)
              || !same_mpc_value (z5, z1, signs))
            {
              /* display sensible variable names */
              mpc_t op1, op2, op3, got, expected;
              op1[0] = z2[0];
              op2[0] = z3[0];
              op3[0] = z4[0];
              expected[0]= z1[0];
              got[0] = z5[0];
              printf ("%s(op) failed (line %lu)\nwith rounding mode %s\n",
                      function.name, test_line_number, rnd_mode[rnd]);
              if (!MPC_INEX_CMP (inex_re, inex_im, inex))
                printf("ternary value: got %s, expected (%s, %s)\n",
                       MPC_INEX_STR (inex),
                       MPFR_INEX_STR (inex_re), MPFR_INEX_STR (inex_im));
              MPC_OUT (op1);
              MPC_OUT (op2);
              MPC_OUT (op3);
              printf ("     ");
              MPC_OUT (got);
              MPC_OUT (expected);

              exit (1);
            }
          if (function.properties & FUNC_PROP_SYMETRIC)
            {
              inex = function.pointer.CCCC (z5, z3, z2, z4, rnd);
              if (!MPC_INEX_CMP (inex_re, inex_im, inex)
              || !same_mpc_value (z5, z1, signs))
                {
                  /* display sensible variable names */
                  mpc_t op1, op2, op3, got, expected;
                  op1[0] = z3[0];
                  op2[0] = z2[0];
		  op3[0] = z4[0];
                  expected[0]= z1[0];
                  got[0] = z5[0];
                  printf ("%s(op) failed (line %lu/symetric test)\n"
                          "with rounding mode %s\n",
                          function.name, test_line_number, rnd_mode[rnd]);
                  if (!MPC_INEX_CMP (inex_re, inex_im, inex))
                    printf("ternary value: got %s, expected (%s, %s)\n",
                           MPC_INEX_STR (inex),
                           MPFR_INEX_STR (inex_re), MPFR_INEX_STR (inex_im));
                  MPC_OUT (op1);
                  MPC_OUT (op2);
		  MPC_OUT (op3);
                  printf ("     ");
                  MPC_OUT (got);
                  MPC_OUT (expected);

                  exit (1);
                }
            }
          break;

        case CFC: /* example mpc_fr_div */
          read_cfc (fp, &inex_re, &inex_im, z1, &signs, x1, z2, &rnd);
          mpfr_set_prec (mpc_realref(z3), MPC_PREC_RE (z1));
          mpfr_set_prec (mpc_imagref(z3), MPC_PREC_IM (z1));
          inex = function.pointer.CFC (z3, x1, z2, rnd);
          if (!MPC_INEX_CMP (inex_re, inex_im, inex)
              || !same_mpc_value (z3, z1, signs))
            {
              /* display sensible variable names */
              mpc_t op2, got, expected;
              mpfr_t op1;
              op1[0] = x1[0];
              op2[0] = z2[0];
              expected[0]= z1[0];
              got[0] = z3[0];
              printf ("%s(op) failed (line %lu)\nwith rounding mode %s\n",
                      function.name, test_line_number, rnd_mode[rnd]);
              if (!MPC_INEX_CMP (inex_re, inex_im, inex))
                printf("ternary value: got %s, expected (%s, %s)\n",
                       MPC_INEX_STR (inex),
                       MPFR_INEX_STR (inex_re), MPFR_INEX_STR (inex_im));
              MPFR_OUT (op1);
              MPC_OUT (op2);
              printf ("     ");
              MPC_OUT (got);
              MPC_OUT (expected);

              exit (1);
            }
          break;

        case CCF: /* example mpc_mul_fr */
          read_ccf (fp, &inex_re, &inex_im, z1, &signs, z2, x1, &rnd);
          mpfr_set_prec (mpc_realref(z3), MPC_PREC_RE (z1));
          mpfr_set_prec (mpc_imagref(z3), MPC_PREC_IM (z1));
          inex = function.pointer.CCF (z3, z2, x1, rnd);
          if (!MPC_INEX_CMP (inex_re, inex_im, inex)
              || !same_mpc_value (z3, z1, signs))
            {
              /* display sensible variable names */
              mpc_t op1, got, expected;
              mpfr_t op2;
              op1[0] = z2[0];
              op2[0] = x1[0];
              expected[0]= z1[0];
              got[0] = z3[0];
              printf ("%s(op) failed (line %lu)\nwith rounding mode %s\n",
                      function.name, test_line_number, rnd_mode[rnd]);
              if (!MPC_INEX_CMP (inex_re, inex_im, inex))
                printf("ternary value: got %s, expected (%s, %s)\n",
                       MPC_INEX_STR (inex),
                       MPFR_INEX_STR (inex_re), MPFR_INEX_STR (inex_im));
              MPC_OUT (op1);
              MPFR_OUT (op2);
              printf ("     ");
              MPC_OUT (got);
              MPC_OUT (expected);

              exit (1);
            }
          break;

        case CCU: /* example mpc_pow_ui */
          read_ccu (fp, &inex_re, &inex_im, z1, &signs, z2, &ui, &rnd);
          mpfr_set_prec (mpc_realref(z3), MPC_PREC_RE (z1));
          mpfr_set_prec (mpc_imagref(z3), MPC_PREC_IM (z1));
          inex = function.pointer.CCU (z3, z2, ui, rnd);
          if (!MPC_INEX_CMP (inex_re, inex_im, inex)
              || !same_mpc_value (z3, z1, signs))
            {
              /* display sensible variable names */
              mpc_t op1, got, expected;
              op1[0] = z2[0];
              expected[0]= z1[0];
              got[0] = z3[0];
              printf ("%s(op) failed (line %lu)\nwith rounding mode %s\n",
                      function.name, test_line_number, rnd_mode[rnd]);
              if (!MPC_INEX_CMP (inex_re, inex_im, inex))
                printf("ternary value: got %s, expected (%s, %s)\n",
                       MPC_INEX_STR (inex),
                       MPFR_INEX_STR (inex_re), MPFR_INEX_STR (inex_im));
              MPC_OUT (op1);
              printf ("op2 %lu\n     ", ui);
              MPC_OUT (got);
              MPC_OUT (expected);

              exit (1);
            }
          break;

        case CCS: /* example mpc_pow_si */
          read_ccs (fp, &inex_re, &inex_im, z1, &signs, z2, &si, &rnd);
          mpfr_set_prec (mpc_realref(z3), MPC_PREC_RE (z1));
          mpfr_set_prec (mpc_imagref(z3), MPC_PREC_IM (z1));
          inex = function.pointer.CCS (z3, z2, si, rnd);
          if (!MPC_INEX_CMP (inex_re, inex_im, inex)
              || !same_mpc_value (z3, z1, signs))
            {
              /* display sensible variable names */
              mpc_t op1, got, expected;
              op1[0] = z2[0];
              expected[0]= z1[0];
              got[0] = z3[0];
              printf ("%s(op) failed (line %lu)\nwith rounding mode %s\n",
                      function.name, test_line_number, rnd_mode[rnd]);
              if (!MPC_INEX_CMP (inex_re, inex_im, inex))
                printf("ternary value: got %s, expected (%s, %s)\n",
                       MPC_INEX_STR (inex),
                       MPFR_INEX_STR (inex_re), MPFR_INEX_STR (inex_im));
              MPC_OUT (op1);
              printf ("op2 %li\n     ", si);
              MPC_OUT (got);
              MPC_OUT (expected);

              exit (1);
            }
          break;

        default:
          printf ("Unhandled function prototype %i in 'data_check'\n", function.type);
          exit (1);
        }

      /* check MPFR flags were not modified */
      check_mpfr_flags (rand_counter);
      rand_counter ++;
    }

  /* 3. Clear used variables */
  mpc_clear (z1);
  switch (function.type)
    {
    case FC:
      mpfr_clear (x1);
      mpfr_clear (x2);
      break;
    case CC: case CCU: case CCS:
      mpc_clear (z2);
      mpc_clear (z3);
      break;
    case C_CC:
      mpc_clear (z2);
      mpc_clear (z3);
      mpc_clear (z4);
      break;
    case CCCC:
      mpc_clear (z2);
      mpc_clear (z3);
      mpc_clear (z4);
      mpc_clear (z5);
      break;
    case CFC: case CCF:
      mpfr_clear (x1);
      mpc_clear (z2);
      mpc_clear (z3);
      break;
    default:
      ;
    }

  close_data_file (fp);
}