/* tgeneric.c -- File for generic tests.

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 "mpc-tests.h"

/* Warning: unlike the MPFR macro (defined in mpfr-impl.h), this one returns

   true when b is singular */

#define MPFR_CAN_ROUND(b,err,prec,rnd)                                  \

  (mpfr_zero_p (b) || mpfr_inf_p (b)                                    \

   || mpfr_can_round (b, (long)mpfr_get_prec (b) - (err), (rnd),        \

                      GMP_RNDZ, (prec) + ((rnd)==GMP_RNDN)))

/* functions with one input, one output */

static void

tgeneric_cc (mpc_function *function, mpc_ptr op, mpc_ptr rop,

             mpc_ptr rop4, mpc_ptr rop4rnd, mpc_rnd_t rnd)

{

  known_signs_t ks = {1, 1};

  /* We compute the result with four times the precision and check whether the

     rounding is correct. Error reports in this part of the algorithm might

     still be wrong, though, since there are two consecutive roundings (but we

     try to avoid them).  */

  function->pointer.CC (rop4, op, rnd);

  function->pointer.CC (rop, op, rnd);

  /* can't use the mpfr_can_round function when argument is singular,

     use a custom macro instead. */

  if (MPFR_CAN_ROUND (mpc_realref (rop4), 1, MPC_PREC_RE (rop),

                      MPC_RND_RE (rnd))

      && MPFR_CAN_ROUND (mpc_imagref (rop4), 1, MPC_PREC_IM (rop),

                         MPC_RND_IM (rnd)))

    mpc_set (rop4rnd, rop4, rnd);

  else

    /* avoid double rounding error */

    return;

  if (same_mpc_value (rop, rop4rnd, ks))

    return;

  /* rounding failed */

  printf ("Rounding in %s might be incorrect for\n", function->name);

  MPC_OUT (op);

  printf ("with rounding mode (%s, %s)",

          mpfr_print_rnd_mode (MPC_RND_RE (rnd)),

          mpfr_print_rnd_mode (MPC_RND_IM (rnd)));

  printf ("\n%s                     gives ", function->name);

  MPC_OUT (rop);

  printf ("%s quadruple precision gives ", function->name);

  MPC_OUT (rop4);

  printf ("and is rounded to                  ");

  MPC_OUT (rop4rnd);

  exit (1);

}

static void

tgeneric_cc_c (mpc_function *function, mpc_ptr op, mpc_ptr rop1, mpc_ptr rop2,

   mpc_ptr rop14, mpc_ptr rop24, mpc_ptr rop14rnd, mpc_ptr rop24rnd,

   mpc_rnd_t rnd1, mpc_rnd_t rnd2)

{

   /* same as the previous function, but for mpc functions computing two

      results from one argument                                          */

   known_signs_t ks = {1, 1};

   function->pointer.CC_C (rop14, rop24, op, rnd1, rnd2);

   function->pointer.CC_C (rop1,  rop2,  op, rnd1, rnd2);

   if (   MPFR_CAN_ROUND (mpc_realref (rop14), 1, MPC_PREC_RE (rop1),

                          MPC_RND_RE (rnd1))

       && MPFR_CAN_ROUND (mpc_imagref (rop14), 1, MPC_PREC_IM (rop1),

                          MPC_RND_IM (rnd1))

       && MPFR_CAN_ROUND (mpc_realref (rop24), 1, MPC_PREC_RE (rop2),

                          MPC_RND_RE (rnd2))

       && MPFR_CAN_ROUND (mpc_imagref (rop24), 1, MPC_PREC_IM (rop2),

                          MPC_RND_IM (rnd2))) {

     mpc_set (rop14rnd, rop14, rnd1);

     mpc_set (rop24rnd, rop24, rnd2);

   }

   else

     return;

   if (!same_mpc_value (rop1, rop14rnd, ks)) {

      /* rounding failed for first result */

      printf ("Rounding might be incorrect for the first result of %s at\n", function->name);

      MPC_OUT (op);

      printf ("with rounding mode (%s, %s)",

          mpfr_print_rnd_mode (MPC_RND_RE (rnd1)),

          mpfr_print_rnd_mode (MPC_RND_IM (rnd1)));

      printf ("\n%s                     gives ", function->name);

      MPC_OUT (rop1);

      printf ("%s quadruple precision gives ", function->name);

      MPC_OUT (rop14);

      printf ("and is rounded to                  ");

      MPC_OUT (rop14rnd);

      exit (1);

   }

   else if (!same_mpc_value (rop2, rop24rnd, ks)) {

      /* rounding failed for second result */

      printf ("Rounding might be incorrect for the second result of %s at\n", function->name);

      MPC_OUT (op);

      printf ("with rounding mode (%s, %s)",

          mpfr_print_rnd_mode (MPC_RND_RE (rnd2)),

          mpfr_print_rnd_mode (MPC_RND_IM (rnd2)));

      printf ("\n%s                     gives ", function->name);

      MPC_OUT (rop2);

      printf ("%s quadruple precision gives ", function->name);

      MPC_OUT (rop24);

      printf ("and is rounded to                  ");

      MPC_OUT (rop24rnd);

      exit (1);

   }

}

static void

tgeneric_fc (mpc_function *function, mpc_ptr op, mpfr_ptr rop,

             mpfr_ptr rop4, mpfr_ptr rop4rnd, mpfr_rnd_t rnd)

{

  function->pointer.FC (rop4, op, rnd);

  function->pointer.FC (rop, op, rnd);

  if (MPFR_CAN_ROUND (rop4, 1, mpfr_get_prec (rop), rnd))

    mpfr_set (rop4rnd, rop4, rnd);

  else

    return;

  if (same_mpfr_value (rop, rop4rnd, 1))

    return;

  printf ("Rounding in %s might be incorrect for\n", function->name);

  MPC_OUT (op);

  printf ("with rounding mode %s", mpfr_print_rnd_mode (rnd));

  printf ("\n%s                     gives ", function->name);

  MPFR_OUT (rop);

  printf ("%s quadruple precision gives ", function->name);

  MPFR_OUT (rop4);

  printf ("and is rounded to                  ");

  MPFR_OUT (rop4rnd);

  exit (1);

}

static void

tgeneric_cfc (mpc_function *function, mpfr_ptr op1, mpc_ptr op2,

              mpc_ptr rop, mpc_ptr rop4, mpc_ptr rop4rnd, mpc_rnd_t rnd)

{

  known_signs_t ks = {1, 1};

  function->pointer.CFC (rop4, op1, op2, rnd);

  function->pointer.CFC (rop, op1, op2, rnd);

  if (MPFR_CAN_ROUND (mpc_realref (rop4), 1, MPC_PREC_RE (rop),

                      MPC_RND_RE (rnd))

      && MPFR_CAN_ROUND (mpc_imagref (rop4), 1, MPC_PREC_IM (rop),

                         MPC_RND_IM (rnd)))

    mpc_set (rop4rnd, rop4, rnd);

  else

    return;

  if (same_mpc_value (rop, rop4rnd, ks))

    return;

  printf ("Rounding in %s might be incorrect for\n", function->name);

  MPFR_OUT (op1);

  MPC_OUT (op2);

  printf ("with rounding mode (%s, %s)",

          mpfr_print_rnd_mode (MPC_RND_RE (rnd)),

          mpfr_print_rnd_mode (MPC_RND_IM (rnd)));

  printf ("\n%s                     gives ", function->name);

  MPC_OUT (rop);

  printf ("%s quadruple precision gives ", function->name);

  MPC_OUT (rop4);

  printf ("and is rounded to                  ");

  MPC_OUT (rop4rnd);

  exit (1);

}

static void

tgeneric_ccf (mpc_function *function, mpc_ptr op1, mpfr_ptr op2,

              mpc_ptr rop, mpc_ptr rop4, mpc_ptr rop4rnd, mpc_rnd_t rnd)

{

  known_signs_t ks = {1, 1};

  function->pointer.CCF (rop4, op1, op2, rnd);

  function->pointer.CCF (rop, op1, op2, rnd);

  if (MPFR_CAN_ROUND (mpc_realref (rop4), 1, MPC_PREC_RE (rop),

                      MPC_RND_RE (rnd))

      && MPFR_CAN_ROUND (mpc_imagref (rop4), 1, MPC_PREC_IM (rop),

                         MPC_RND_IM (rnd)))

    mpc_set (rop4rnd, rop4, rnd);

  else

    return;

  if (same_mpc_value (rop, rop4rnd, ks))

    return;

  printf ("Rounding in %s might be incorrect for\n", function->name);

  MPC_OUT (op1);

  MPFR_OUT (op2);

  printf ("with rounding mode (%s, %s)",

          mpfr_print_rnd_mode (MPC_RND_RE (rnd)),

          mpfr_print_rnd_mode (MPC_RND_IM (rnd)));

  printf ("\n%s                     gives ", function->name);

  MPC_OUT (rop);

  printf ("%s quadruple precision gives ", function->name);

  MPC_OUT (rop4);

  printf ("and is rounded to                  ");

  MPC_OUT (rop4rnd);

  exit (1);

}

/* for functions with one mpc_t output, two mpc_t inputs */

static void

tgeneric_c_cc (mpc_function *function, mpc_ptr op1, mpc_ptr op2,

	       mpc_ptr rop, mpc_ptr rop4, mpc_ptr rop4rnd, mpc_rnd_t rnd)

{

  known_signs_t ks = {1, 1};

  /* We compute the result with four times the precision and check whether the

     rounding is correct. Error reports in this part of the algorithm might

     still be wrong, though, since there are two consecutive roundings (but we

     try to avoid them).  */

  function->pointer.C_CC (rop4, op1, op2, rnd);

  function->pointer.C_CC (rop, op1, op2, rnd);

  /* can't use mpfr_can_round when argument is singular */

  if (MPFR_CAN_ROUND (mpc_realref (rop4), 1, MPC_PREC_RE (rop),

                      MPC_RND_RE (rnd))

      && MPFR_CAN_ROUND (mpc_imagref (rop4), 1, MPC_PREC_IM (rop),

                         MPC_RND_IM (rnd)))

    mpc_set (rop4rnd, rop4, rnd);

  else

    /* avoid double rounding error */

    return;

  if (same_mpc_value (rop, rop4rnd, ks))

    return;

  /* rounding failed */

  printf ("Rounding in %s might be incorrect for\n", function->name);

  MPC_OUT (op1);

  MPC_OUT (op2);

  printf ("with rounding mode (%s, %s)",

          mpfr_print_rnd_mode (MPC_RND_RE (rnd)),

          mpfr_print_rnd_mode (MPC_RND_IM (rnd)));

  printf ("\n%s                     gives ", function->name);

  MPC_OUT (rop);

  printf ("%s quadruple precision gives ", function->name);

  MPC_OUT (rop4);

  printf ("and is rounded to                  ");

  MPC_OUT (rop4rnd);

  exit (1);

}

static void

tgeneric_cccc (mpc_function *function, mpc_ptr op1, mpc_ptr op2, mpc_ptr op3,

              mpc_ptr rop, mpc_ptr rop4, mpc_ptr rop4rnd, mpc_rnd_t rnd)

{

  known_signs_t ks = {1, 1};

  /* We compute the result with four times the precision and check whether the

     rounding is correct. Error reports in this part of the algorithm might

     still be wrong, though, since there are two consecutive roundings (but we

     try to avoid them).  */

  function->pointer.CCCC (rop4, op1, op2, op3, rnd);

  function->pointer.CCCC (rop, op1, op2, op3, rnd);

  /* can't use mpfr_can_round when argument is singular */

  if (MPFR_CAN_ROUND (mpc_realref (rop4), 1, MPC_PREC_RE (rop),

                      MPC_RND_RE (rnd))

      && MPFR_CAN_ROUND (mpc_imagref (rop4), 1, MPC_PREC_IM (rop),

                         MPC_RND_IM (rnd)))

    mpc_set (rop4rnd, rop4, rnd);

  else

    /* avoid double rounding error */

    return;

  if (same_mpc_value (rop, rop4rnd, ks))

    return;

  /* rounding failed */

  printf ("Rounding in %s might be incorrect for\n", function->name);

  MPC_OUT (op1);

  MPC_OUT (op2);

  MPC_OUT (op3);

  printf ("with rounding mode (%s, %s)",

          mpfr_print_rnd_mode (MPC_RND_RE (rnd)),

          mpfr_print_rnd_mode (MPC_RND_IM (rnd)));

  printf ("\n%s                     gives ", function->name);

  MPC_OUT (rop);

  printf ("%s quadruple precision gives ", function->name);

  MPC_OUT (rop4);

  printf ("and is rounded to                  ");

  MPC_OUT (rop4rnd);

  exit (1);

}

static void

tgeneric_ccu (mpc_function *function, mpc_ptr op1, unsigned long int op2,

              mpc_ptr rop, mpc_ptr rop4, mpc_ptr rop4rnd, mpc_rnd_t rnd)

{

  known_signs_t ks = {1, 1};

  function->pointer.CCU (rop4, op1, op2, rnd);

  function->pointer.CCU (rop, op1, op2, rnd);

  if (MPFR_CAN_ROUND (mpc_realref (rop4), 1, MPC_PREC_RE (rop),

                      MPC_RND_RE (rnd))

      && MPFR_CAN_ROUND (mpc_imagref (rop4), 1, MPC_PREC_IM (rop),

                         MPC_RND_IM (rnd)))

    mpc_set (rop4rnd, rop4, rnd);

  else

    return;

  if (same_mpc_value (rop, rop4rnd, ks))

    return;

  printf ("Rounding in %s might be incorrect for\n", function->name);

  MPC_OUT (op1);

  printf ("op2=%lu\n", op2);

  printf ("with rounding mode (%s, %s)",

          mpfr_print_rnd_mode (MPC_RND_RE (rnd)),

          mpfr_print_rnd_mode (MPC_RND_IM (rnd)));

  printf ("\n%s                     gives ", function->name);

  MPC_OUT (rop);

  printf ("%s quadruple precision gives ", function->name);

  MPC_OUT (rop4);

  printf ("and is rounded to                  ");

  MPC_OUT (rop4rnd);

  exit (1);

}

static void

tgeneric_cuc (mpc_function *function, unsigned long int op1, mpc_ptr op2,

              mpc_ptr rop, mpc_ptr rop4, mpc_ptr rop4rnd, mpc_rnd_t rnd)

{

  known_signs_t ks = {1, 1};

  function->pointer.CUC (rop4, op1, op2, rnd);

  function->pointer.CUC (rop, op1, op2, rnd);

  if (MPFR_CAN_ROUND (mpc_realref (rop4), 1, MPC_PREC_RE (rop),

                      MPC_RND_RE (rnd))

      && MPFR_CAN_ROUND (mpc_imagref (rop4), 1, MPC_PREC_IM (rop),

                         MPC_RND_IM (rnd)))

    mpc_set (rop4rnd, rop4, rnd);

  else

    return;

  if (same_mpc_value (rop, rop4rnd, ks))

    return;

  printf ("Rounding in %s might be incorrect for\n", function->name);

  printf ("op1=%lu\n", op1);

  MPC_OUT (op2);

  printf ("with rounding mode (%s, %s)",

          mpfr_print_rnd_mode (MPC_RND_RE (rnd)),

          mpfr_print_rnd_mode (MPC_RND_IM (rnd)));

  printf ("\n%s                     gives ", function->name);

  MPC_OUT (rop);

  printf ("%s quadruple precision gives ", function->name);

  MPC_OUT (rop4);

  printf ("and is rounded to                  ");

  MPC_OUT (rop4rnd);

  exit (1);

}

static void

tgeneric_ccs (mpc_function *function, mpc_ptr op1, long int op2,

              mpc_ptr rop, mpc_ptr rop4, mpc_ptr rop4rnd, mpc_rnd_t rnd)

{

  known_signs_t ks = {1, 1};

  function->pointer.CCS (rop4, op1, op2, rnd);

  function->pointer.CCS (rop, op1, op2, rnd);

  if (MPFR_CAN_ROUND (mpc_realref (rop4), 1, MPC_PREC_RE (rop),

                      MPC_RND_RE (rnd))

      && MPFR_CAN_ROUND (mpc_imagref (rop4), 1, MPC_PREC_IM (rop),

                         MPC_RND_IM (rnd)))

    mpc_set (rop4rnd, rop4, rnd);

  else

    return;

  if (same_mpc_value (rop, rop4rnd, ks))

    return;

  printf ("Rounding in %s might be incorrect for\n", function->name);

  MPC_OUT (op1);

  printf ("op2=%ld\n", op2);

  printf ("with rounding mode (%s, %s)",

          mpfr_print_rnd_mode (MPC_RND_RE (rnd)),

          mpfr_print_rnd_mode (MPC_RND_IM (rnd)));

  printf ("\n%s                     gives ", function->name);

  MPC_OUT (rop);

  printf ("%s quadruple precision gives ", function->name);

  MPC_OUT (rop4);

  printf ("and is rounded to                  ");

  MPC_OUT (rop4rnd);

  exit (1);

}

static void

tgeneric_cci (mpc_function *function, mpc_ptr op1, int op2,

              mpc_ptr rop, mpc_ptr rop4, mpc_ptr rop4rnd, mpc_rnd_t rnd)

{

  known_signs_t ks = {1, 1};

  function->pointer.CCI (rop4, op1, op2, rnd);

  function->pointer.CCI (rop, op1, op2, rnd);

  if (MPFR_CAN_ROUND (mpc_realref (rop4), 1, MPC_PREC_RE (rop),

                      MPC_RND_RE (rnd))

      && MPFR_CAN_ROUND (mpc_imagref (rop4), 1, MPC_PREC_IM (rop),

                         MPC_RND_IM (rnd)))

    mpc_set (rop4rnd, rop4, rnd);

  else

    return;

  if (same_mpc_value (rop, rop4rnd, ks))

    return;

  printf ("Rounding in %s might be incorrect for\n", function->name);

  MPC_OUT (op1);

  printf ("op2=%d\n", op2);

  printf ("with rounding mode (%s, %s)",

          mpfr_print_rnd_mode (MPC_RND_RE (rnd)),

          mpfr_print_rnd_mode (MPC_RND_IM (rnd)));

  printf ("\n%s                     gives ", function->name);

  MPC_OUT (rop);

  printf ("%s quadruple precision gives ", function->name);

  MPC_OUT (rop4);

  printf ("and is rounded to                  ");

  MPC_OUT (rop4rnd);

  exit (1);

}

static void

tgeneric_cuuc (mpc_function *function, unsigned long int op1,

               unsigned long int op2, mpc_ptr op3, mpc_ptr rop,

               mpc_ptr rop4, mpc_ptr rop4rnd, mpc_rnd_t rnd)

{

  known_signs_t ks = {1, 1};

  function->pointer.CUUC (rop4, op1, op2, op3, rnd);

  function->pointer.CUUC (rop, op1, op2, op3, rnd);

  if (MPFR_CAN_ROUND (mpc_realref (rop4), 1, MPC_PREC_RE (rop),

                      MPC_RND_RE (rnd))

      && MPFR_CAN_ROUND (mpc_imagref (rop4), 1, MPC_PREC_IM (rop),

                         MPC_RND_IM (rnd)))

    mpc_set (rop4rnd, rop4, rnd);

  else

    return;

  if (same_mpc_value (rop, rop4rnd, ks))

    return;

  printf ("Rounding in %s might be incorrect for\n", function->name);

  printf ("op1=%lu\n", op1);

  printf ("op2=%lu\n", op2);

  MPC_OUT (op3);

  printf ("with rounding mode (%s, %s)",

          mpfr_print_rnd_mode (MPC_RND_RE (rnd)),

          mpfr_print_rnd_mode (MPC_RND_IM (rnd)));

  printf ("\n%s                     gives ", function->name);

  MPC_OUT (rop);

  printf ("%s quadruple precision gives ", function->name);

  MPC_OUT (rop4);

  printf ("and is rounded to                  ");

  MPC_OUT (rop4rnd);

  exit (1);

}

/* Test parameter reuse: the function should not use its output parameter in

   internal computations. */

static void

reuse_cc (mpc_function* function, mpc_srcptr z, mpc_ptr got, mpc_ptr expected)

{

  known_signs_t ks = {1, 1};

  mpc_set (got, z, MPC_RNDNN); /* exact */

  function->pointer.CC (expected, z, MPC_RNDNN);

  function->pointer.CC (got, got, MPC_RNDNN);

  if (!same_mpc_value (got, expected, ks))

    {

      printf ("Reuse error for %s(z, z) for\n", function->name);

      MPC_OUT (z);

      MPC_OUT (expected);

      MPC_OUT (got);

      exit (1);

    }

}

static void

reuse_cc_c (mpc_function* function, mpc_srcptr z, mpc_ptr got1, mpc_ptr got2,

            mpc_ptr exp1, mpc_ptr exp2)

{

   known_signs_t ks = {1, 1};

   function->pointer.CC_C (exp1, exp2, z, MPC_RNDNN, MPC_RNDNN);

   mpc_set (got1, z, MPC_RNDNN); /* exact */

   function->pointer.CC_C (got1, got2, got1, MPC_RNDNN, MPC_RNDNN);

   if (   !same_mpc_value (got1, exp1, ks)

       || !same_mpc_value (got2, exp2, ks)) {

      printf ("Reuse error in first result of %s for\n", function->name);

      MPC_OUT (z);

      MPC_OUT (exp1);

      MPC_OUT (got1);

      MPC_OUT (exp2);

      MPC_OUT (got2);

      exit (1);

   }

   mpc_set (got2, z, MPC_RNDNN); /* exact */

   function->pointer.CC_C (got1, got2, got2, MPC_RNDNN, MPC_RNDNN);

   if (   !same_mpc_value (got1, exp1, ks)

       || !same_mpc_value (got2, exp2, ks)) {

      printf ("Reuse error in second result of %s for\n", function->name);

      MPC_OUT (z);

      MPC_OUT (exp1);

      MPC_OUT (got1);

      MPC_OUT (exp2);

      MPC_OUT (got2);

      exit (1);

   }

}

static void

reuse_fc (mpc_function* function, mpc_ptr z, mpc_ptr x, mpfr_ptr expected)

{

  mpc_set (x, z, MPC_RNDNN); /* exact */

  function->pointer.FC (expected, z, GMP_RNDN);

  function->pointer.FC (mpc_realref (x), x, GMP_RNDN);

  if (!same_mpfr_value (mpc_realref (x), expected, 1))

    {

      mpfr_t got;

      got[0] = mpc_realref(x)[0]; /* display sensible name */

      printf ("Reuse error for %s(mpc_realref(z), z) for\n", function->name);

      MPC_OUT (z);

      MPFR_OUT (expected);

      MPFR_OUT (got);

      exit (1);

    }

  mpc_set (x, z, MPC_RNDNN); /* exact */

  function->pointer.FC (mpc_imagref (x), x, GMP_RNDN);

  if (!same_mpfr_value (mpc_imagref (x), expected, 1))

    {

      mpfr_t got;

      got[0] = mpc_imagref(x)[0]; /* display sensible name */

      printf ("Reuse error for %s(mpc_imagref(z), z) for \n", function->name);

      MPC_OUT (z);

      MPFR_OUT (expected);

      MPFR_OUT (got);

      exit (1);

    }

}

static void

reuse_cfc (mpc_function* function, mpc_srcptr z, mpfr_srcptr x, mpc_ptr got,

           mpc_ptr expected)

{

  known_signs_t ks = {1, 1};

  mpc_set (got, z, MPC_RNDNN); /* exact */

  function->pointer.CFC (expected, x, z, MPC_RNDNN);

  function->pointer.CFC (got, x, got, MPC_RNDNN);

  if (!same_mpc_value (got, expected, ks))

    {

      printf ("Reuse error for %s(z, x, z) for\n", function->name);

      MPFR_OUT (x);

      MPC_OUT (z);

      MPC_OUT (expected);

      MPC_OUT (got);

      exit (1);

    }

}

static void

reuse_ccf (mpc_function* function, mpc_srcptr z, mpfr_srcptr x, mpc_ptr got,

           mpc_ptr expected)

{

  known_signs_t ks = {1, 1};

  mpc_set (got, z, MPC_RNDNN); /* exact */

  function->pointer.CCF (expected, z, x, MPC_RNDNN);

  function->pointer.CCF (got, got, x, MPC_RNDNN);

  if (!same_mpc_value (got, expected, ks))

    {

      printf ("Reuse error for %s(z, z, x, RNDNN) for\n", function->name);

      MPC_OUT (z);

      MPFR_OUT (x);

      MPC_OUT (expected);

      MPC_OUT (got);

      exit (1);

    }

}

/* for functions with one mpc_t output, two mpc_t inputs */

static void

reuse_c_cc (mpc_function* function, mpc_srcptr z, mpc_srcptr x,

           mpc_ptr got, mpc_ptr expected)

{

  known_signs_t ks = {1, 1};

  mpc_set (got, z, MPC_RNDNN); /* exact */

  function->pointer.C_CC (expected, z, x, MPC_RNDNN);

  function->pointer.C_CC (got, got, x, MPC_RNDNN);

  if (!same_mpc_value (got, expected, ks))

    {

      printf ("Reuse error for %s(z, z, x) for\n", function->name);

      MPC_OUT (z);

      MPC_OUT (x);

      MPC_OUT (expected);

      MPC_OUT (got);

      exit (1);

    }

  mpc_set (got, x, MPC_RNDNN); /* exact */

  function->pointer.C_CC (expected, z, x, MPC_RNDNN);

  function->pointer.C_CC (got, z, got, MPC_RNDNN);

  if (!same_mpc_value (got, expected, ks))

    {

      printf ("Reuse error for %s(x, z, x) for\n", function->name);

      MPC_OUT (z);

      MPC_OUT (x);

      MPC_OUT (expected);

      MPC_OUT (got);

      exit (1);

    }

  mpc_set (got, x, MPC_RNDNN); /* exact */

  function->pointer.C_CC (expected, x, x, MPC_RNDNN);

  function->pointer.C_CC (got, got, got, MPC_RNDNN);

  if (!same_mpc_value (got, expected, ks))

    {

      printf ("Reuse error for %s(x, x, x) for\n", function->name);

      MPC_OUT (x);

      MPC_OUT (expected);

      MPC_OUT (got);

      exit (1);

    }

}

static void

reuse_cccc (mpc_function* function, mpc_srcptr z, mpc_srcptr x, mpc_srcptr y,

	    mpc_ptr got, mpc_ptr expected)

{

  known_signs_t ks = {1, 1};

  mpc_set (got, z, MPC_RNDNN); /* exact */

  function->pointer.CCCC (expected, z, x, y, MPC_RNDNN);

  function->pointer.CCCC (got, got, x, y, MPC_RNDNN);

  if (!same_mpc_value (got, expected, ks))

    {

      printf ("Reuse error for %s(z, z, x, y) for\n", function->name);

      MPC_OUT (z);

      MPC_OUT (x);

      MPC_OUT (y);

      MPC_OUT (expected);

      MPC_OUT (got);

      exit (1);

    }

  mpc_set (got, x, MPC_RNDNN); /* exact */

  function->pointer.CCCC (expected, z, x, y, MPC_RNDNN);

  function->pointer.CCCC (got, z, got, y, MPC_RNDNN);

  if (!same_mpc_value (got, expected, ks))

    {

      printf ("Reuse error for %s(x, z, x, y) for\n", function->name);

      MPC_OUT (z);

      MPC_OUT (x);

      MPC_OUT (y);

      MPC_OUT (expected);

      MPC_OUT (got);

      exit (1);

    }

  mpc_set (got, y, MPC_RNDNN); /* exact */

  function->pointer.CCCC (expected, z, x, y, MPC_RNDNN);

  function->pointer.CCCC (got, z, x, got, MPC_RNDNN);

  if (!same_mpc_value (got, expected, ks))

    {

      printf ("Reuse error for %s(y, z, x, y) for\n", function->name);

      MPC_OUT (z);

      MPC_OUT (x);

      MPC_OUT (y);

      MPC_OUT (expected);

      MPC_OUT (got);

      exit (1);

    }

  mpc_set (got, x, MPC_RNDNN); /* exact */

  function->pointer.CCCC (expected, x, x, x, MPC_RNDNN);

  function->pointer.CCCC (got, got, got, got, MPC_RNDNN);

  if (!same_mpc_value (got, expected, ks))

    {

      printf ("Reuse error for %s(x, x, x, x) for\n", function->name);

      MPC_OUT (x);

      MPC_OUT (expected);

      MPC_OUT (got);

      exit (1);

    }

}

static void

reuse_ccu (mpc_function* function, mpc_srcptr z, unsigned long ul,

           mpc_ptr got, mpc_ptr expected)

{

  known_signs_t ks = {1, 1};

  mpc_set (got, z, MPC_RNDNN); /* exact */

  function->pointer.CCU (expected, z, ul, MPC_RNDNN);

  function->pointer.CCU (got, got, ul, MPC_RNDNN);

  if (!same_mpc_value (got, expected, ks))

    {

      printf ("Reuse error for %s(z, z, n) for\n", function->name);

      MPC_OUT (z);

      printf ("n=%lu\n", ul);

      MPC_OUT (expected);

      MPC_OUT (got);

      exit (1);

    }

}

static void

reuse_cuc (mpc_function* function, unsigned long ul, mpc_srcptr z,

           mpc_ptr got, mpc_ptr expected)

{

  known_signs_t ks = {1, 1};

  mpc_set (got, z, MPC_RNDNN); /* exact */

  function->pointer.CUC (expected, ul, z,MPC_RNDNN);

  function->pointer.CUC (got, ul, got, MPC_RNDNN);

  if (!same_mpc_value (got, expected, ks))

    {

      printf ("Reuse error for %s(z, n, z) for\n", function->name);

      printf ("n=%lu\n", ul);

      MPC_OUT (z);

      MPC_OUT (expected);

      MPC_OUT (got);

      exit (1);

    }

}

static void

reuse_ccs (mpc_function* function, mpc_srcptr z, long lo,

           mpc_ptr got, mpc_ptr expected)

{

  known_signs_t ks = {1, 1};

  mpc_set (got, z, MPC_RNDNN); /* exact */

  function->pointer.CCS (expected, z, lo, MPC_RNDNN);

  function->pointer.CCS (got, got, lo, MPC_RNDNN);

  if (!same_mpc_value (got, expected, ks))

    {

      printf ("Reuse error for %s(z, z, n) for\n", function->name);

      MPC_OUT (z);

      printf ("n=%ld\n", lo);

      MPC_OUT (expected);

      MPC_OUT (got);

      exit (1);

    }

}

static void

reuse_cci (mpc_function* function, mpc_srcptr z, int i,

           mpc_ptr got, mpc_ptr expected)

{

  known_signs_t ks = {1, 1};

  mpc_set (got, z, MPC_RNDNN); /* exact */

  function->pointer.CCI (expected, z, i, MPC_RNDNN);

  function->pointer.CCI (got, got, i, MPC_RNDNN);

  if (!same_mpc_value (got, expected, ks))

    {

      printf ("Reuse error for %s(z, z, n) for\n", function->name);

      MPC_OUT (z);

      printf ("n=%d\n", i);

      MPC_OUT (expected);

      MPC_OUT (got);

      exit (1);

    }

}

static void

reuse_cuuc (mpc_function* function, unsigned long ul1, unsigned long ul2,

            mpc_srcptr z, mpc_ptr got, mpc_ptr expected)

{

  known_signs_t ks = {1, 1};

  mpc_set (got, z, MPC_RNDNN); /* exact */

  function->pointer.CUUC (expected, ul1, ul2, z,MPC_RNDNN);

  function->pointer.CUUC (got, ul1, ul2, got, MPC_RNDNN);

  if (!same_mpc_value (got, expected, ks))

    {

      printf ("Reuse error for %s(z, m, n, z) for\n", function->name);

      printf ("m=%lu\n", ul1);

      printf ("n=%lu\n", ul2);

      MPC_OUT (z);

      MPC_OUT (expected);

      MPC_OUT (got);

      exit (1);

    }

}

/* helper functions for iterating over mpfr rounding modes */

static mpfr_rnd_t

first_rnd_mode (void)

{

   return GMP_RNDN;

}

static mpfr_rnd_t

next_rnd_mode (mpfr_rnd_t curr)

   /* assumes that all rounding modes are non-negative, and returns -1

      when curr is the last rounding mode                              */

{

   switch (curr) {

      case GMP_RNDN:

         return GMP_RNDZ;

      case GMP_RNDZ:

         return GMP_RNDU;

      case GMP_RNDU:

         return GMP_RNDD;

      default:

         /* return invalid guard value in mpfr_rnd_t */

#if MPFR_VERSION_MAJOR < 3

         return GMP_RNDNA;

#else

         return MPFR_RNDA; /* valid rounding type, but not (yet) used in mpc */

#endif