Additional clean-up after r1416.

git-svn-id: svn://scm.gforge.inria.fr/svn/mpc/trunk@1419 211d60ee-9f03-0410-a15a-8952a2c7a4e4

2 files changed, 1 insertions, 1413 deletions

diff --git a/Makefile.vc b/Makefile.vc
index ee5a94c..0a9d099 100644
--- a/Makefile.vc
+++ b/Makefile.vc
@@ -99,7 +99,7 @@ ENDTESTCOMPILE=/LIBPATH:"$(DIRMPCTESTS)" libmpc.lib  /LIBPATH:"$(GMPDIR)\lib" li
 #generate the CPPLINKOBJECTS : goto src and execute
 # ls *.c | sed "s/\.c/\.obj/" | awk ' { printf("%s \\\n",$1); } '
 #generate the list for tests : goto tests and execute
-# ls t*.c | sed "s/\.c//" | grep -v tgeneric| grep -v comparisons | grep -v read_data | grep -v random | awk ' { printf("\t$(TESTCOMPILE)%s.c  $(MIDTESTCOMPILE)%s.exe $(ENDTESTCOMPILE)\n\tcd $(DIRMPCTESTS) && %s.exe && cd ..\n",$1,$1,$1,$1); } '
+# ls t*.c | sed "s/\.c//" | grep -v comparisons | grep -v read_data | grep -v random | awk ' { printf("\t$(TESTCOMPILE)%s.c  $(MIDTESTCOMPILE)%s.exe $(ENDTESTCOMPILE)\n\tcd $(DIRMPCTESTS) && %s.exe && cd ..\n",$1,$1,$1,$1); } '
 
 LIBRARYLIB = libmpc.lib
 
diff --git a/tests/tgeneric.c b/tests/tgeneric.c
deleted file mode 100644
index cf56997..0000000
--- a/tests/tgeneric.c
+++ /dev/null
@@ -1,1412 +0,0 @@
-/* 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),        \
-                      MPFR_RNDZ, (prec) + ((rnd)==MPFR_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, MPFR_RNDN);
-  function->pointer.FC (mpc_realref (x), x, MPFR_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, MPFR_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 MPFR_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 MPFR_RNDN:
-         return MPFR_RNDZ;
-      case MPFR_RNDZ:
-         return MPFR_RNDU;
-      case MPFR_RNDU:
-         return MPFR_RNDD;
-      default:
-         /* return invalid guard value in mpfr_rnd_t */
-#if MPFR_VERSION_MAJOR < 3
-         return MPFR_RNDNA;
-#else
-         return MPFR_RNDA; /* valid rounding type, but not (yet) used in mpc */
-#endif
-   }
-}
-
-static int
-is_valid_rnd_mode (mpfr_rnd_t curr)
-   /* returns 1 if curr is a valid rounding mode, and 0otherwise */
-{
-   if (   curr == MPFR_RNDN || curr == MPFR_RNDZ
-       || curr == MPFR_RNDU || curr == MPFR_RNDD)
-      return 1;
-   else
-      return 0;
-}
-
-/* tgeneric(prec_min, prec_max, step, exp_max) checks rounding with random
-   numbers:
-   - with precision ranging from prec_min to prec_max with an increment of
-   step,
-   - with exponent between -exp_max and exp_max.
-
-   It also checks parameter reuse (it is assumed here that either two mpc_t
-   variables are equal or they are different, in the sense that the real part
-   of one of them cannot be the imaginary part of the other). */
-void
-tgeneric (mpc_function function, mpfr_prec_t prec_min,
-          mpfr_prec_t prec_max, mpfr_prec_t step, mpfr_exp_t exp_max)
-{
-  unsigned long ul1 = 0, ul2 = 0;
-  long lo = 0;
-  int i = 0;
-  mpfr_t x1, x2, xxxx;
-  mpc_t  z1, z2, z3, z4, z5, zzzz, zzzz2;
-
-  mpfr_rnd_t rnd_re, rnd_im, rnd2_re, rnd2_im;
-  mpfr_prec_t prec;
-  mpfr_exp_t exp_min;
-  int special, special_cases;
-
-  mpc_init2 (z1, prec_max);
-  switch (function.type)
-    {
-    case C_CC:
-      mpc_init2 (z2, prec_max);
-      mpc_init2 (z3, prec_max);
-      mpc_init2 (z4, prec_max);
-      mpc_init2 (zzzz, 4*prec_max);
-      special_cases = 8;
-      break;
-    case CCCC:
-      mpc_init2 (z2, prec_max);
-      mpc_init2 (z3, prec_max);
-      mpc_init2 (z4, prec_max);
-      mpc_init2 (z5, prec_max);
-      mpc_init2 (zzzz, 4*prec_max);
-      special_cases = 8;
-      break;
-    case FC:
-      mpfr_init2 (x1, prec_max);
-      mpfr_init2 (x2, prec_max);
-      mpfr_init2 (xxxx, 4*prec_max);
-      mpc_init2 (z2, prec_max);
-      special_cases = 4;
-      break;
-    case CCF: case CFC:
-      mpfr_init2 (x1, prec_max);
-      mpc_init2 (z2, prec_max);
-      mpc_init2 (z3, prec_max);
-      mpc_init2 (zzzz, 4*prec_max);
-      special_cases = 6;
-      break;
-    case CCI: case CCS:
-    case CCU: case CUC:
-      mpc_init2 (z2, prec_max);
-      mpc_init2 (z3, prec_max);
-      mpc_init2 (zzzz, 4*prec_max);
-      special_cases = 5;
-      break;
-    case CUUC:
-      mpc_init2 (z2, prec_max);
-      mpc_init2 (z3, prec_max);
-      mpc_init2 (zzzz, 4*prec_max);
-      special_cases = 6;
-      break;
-    case CC_C:
-      mpc_init2 (z2, prec_max);
-      mpc_init2 (z3, prec_max);
-      mpc_init2 (z4, prec_max);
-      mpc_init2 (z5, prec_max);
-      mpc_init2 (zzzz, 4*prec_max);
-      mpc_init2 (zzzz2, 4*prec_max);
-      special_cases = 4;
-      break;
-    case CC:
-    default:
-      mpc_init2 (z2, prec_max);
-      mpc_init2 (z3, prec_max);
-      mpc_init2 (zzzz, 4*prec_max);
-      special_cases = 4;
-    }
-
-  exp_min = mpfr_get_emin ();
-  if (exp_max <= 0 || exp_max > mpfr_get_emax ())
-    exp_max = mpfr_get_emax();
-  if (-exp_max > exp_min)
-    exp_min = - exp_max;
-
-  if (step < 1)
-    step = 1;
-
-  for (prec = prec_min, special = 0;
-       prec <= prec_max || special <= special_cases;
-       prec+=step, special += (prec > prec_max ? 1 : 0)) {
-       /* In the end, test functions in special cases of purely real, purely
-          imaginary or infinite arguments. */
-
-      /* probability of one zero part in 256th (25 is almost 10%) */
-      const unsigned int zero_probability = special != 0 ? 0 : 25;
-
-      mpc_set_prec (z1, prec);
-      test_default_random (z1, exp_min, exp_max, 128, zero_probability);
-
-      switch (function.type)
-        {
-        case C_CC:
-          mpc_set_prec (z2, prec);
-          test_default_random (z2, exp_min, exp_max, 128, zero_probability);
-          mpc_set_prec (z3, prec);
-          mpc_set_prec (z4, prec);
-          mpc_set_prec (zzzz, 4*prec);
-          switch (special)
-            {
-            case 1:
-              mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
-              break;
-            case 2:
-              mpfr_set_inf (mpc_realref (z1), +1);
-              break;
-            case 3:
-              mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
-              break;
-            case 4:
-              mpfr_set_inf (mpc_imagref (z1), -1);
-              break;
-            case 5:
-              mpfr_set_ui (mpc_realref (z2), 0, MPFR_RNDN);
-              break;
-            case 6:
-              mpfr_set_inf (mpc_realref (z2), -1);
-              break;
-            case 7:
-              mpfr_set_ui (mpc_imagref (z2), 0, MPFR_RNDN);
-              break;
-            case 8:
-              mpfr_set_inf (mpc_imagref (z2), +1);
-              break;
-            }
-          break;
-        case CCCC:
-          mpc_set_prec (z2, prec);
-          test_default_random (z2, exp_min, exp_max, 128, zero_probability);
-          mpc_set_prec (z3, prec);
-          mpc_set_prec (z4, prec);
-          mpc_set_prec (z5, prec);
-          mpc_set_prec (zzzz, 4*prec);
-          switch (special)
-            {
-            case 1:
-              mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
-              break;
-            case 2:
-              mpfr_set_inf (mpc_realref (z1), +1);
-              break;
-            case 3:
-              mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
-              break;
-            case 4:
-              mpfr_set_inf (mpc_imagref (z1), -1);
-              break;
-            case 5:
-              mpfr_set_ui (mpc_realref (z2), 0, MPFR_RNDN);
-              break;
-            case 6:
-              mpfr_set_inf (mpc_realref (z2), -1);
-              break;
-            case 7:
-              mpfr_set_ui (mpc_imagref (z2), 0, MPFR_RNDN);
-              break;
-            case 8:
-              mpfr_set_inf (mpc_imagref (z2), +1);
-              break;
-            }
-          break;
-        case FC:
-          mpc_set_prec (z2, prec);
-          mpfr_set_prec (x1, prec);
-          mpfr_set_prec (x2, prec);
-          mpfr_set_prec (xxxx, 4*prec);
-          switch (special)
-            {
-            case 1:
-              mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
-              break;
-            case 2:
-              mpfr_set_inf (mpc_realref (z1), +1);
-              break;
-            case 3:
-              mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
-              break;
-            case 4:
-              mpfr_set_inf (mpc_imagref (z1), -1);
-              break;
-            }
-          break;
-        case CCU: case CUC:
-          mpc_set_prec (z2, 128);
-          do {
-            test_default_random (z2, 0, 64, 128, zero_probability);
-          } while (!mpfr_fits_ulong_p (mpc_realref (z2), MPFR_RNDN));
-          ul1 = mpfr_get_ui (mpc_realref(z2), MPFR_RNDN);
-          mpc_set_prec (z2, prec);
-          mpc_set_prec (z3, prec);
-          mpc_set_prec (zzzz, 4*prec);
-          switch (special)
-            {
-            case 1:
-              mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
-              break;
-            case 2:
-              mpfr_set_inf (mpc_realref (z1), +1);
-              break;
-            case 3:
-              mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
-              break;
-            case 4:
-              mpfr_set_inf (mpc_imagref (z1), -1);
-              break;
-            case 5:
-              ul1 = 0;
-              break;
-            }
-          break;
-        case CUUC:
-          mpc_set_prec (z2, 128);
-          do {
-            test_default_random (z2, 0, 64, 128, zero_probability);
-          } while (!mpfr_fits_ulong_p (mpc_realref (z2), MPFR_RNDN)
-                   ||!mpfr_fits_ulong_p (mpc_imagref (z2), MPFR_RNDN));
-          ul1 = mpfr_get_ui (mpc_realref(z2), MPFR_RNDN);
-          ul2 = mpfr_get_ui (mpc_imagref(z2), MPFR_RNDN);
-          mpc_set_prec (z2, prec);
-          mpc_set_prec (z3, prec);
-          mpc_set_prec (zzzz, 4*prec);
-          switch (special)
-            {
-            case 1:
-              mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
-              break;
-            case 2:
-              mpfr_set_inf (mpc_realref (z1), +1);
-              break;
-            case 3:
-              mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
-              break;
-            case 4:
-              mpfr_set_inf (mpc_imagref (z1), -1);
-              break;
-            case 5:
-              ul1 = 0;
-              break;
-            case 6:
-              ul2 = 0;
-              break;
-            }
-          break;
-        case CCS:
-          mpc_set_prec (z2, 128);
-          do {
-            test_default_random (z2, 0, 64, 128, zero_probability);
-          } while (!mpfr_fits_slong_p (mpc_realref (z2), MPFR_RNDN));
-          lo = mpfr_get_si (mpc_realref(z2), MPFR_RNDN);
-          mpc_set_prec (z2, prec);
-          mpc_set_prec (z3, prec);
-          mpc_set_prec (zzzz, 4*prec);
-          switch (special)
-            {
-            case 1:
-              mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
-              break;
-            case 2:
-              mpfr_set_inf (mpc_realref (z1), +1);
-              break;
-            case 3:
-              mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
-              break;
-            case 4:
-              mpfr_set_inf (mpc_imagref (z1), -1);
-              break;
-            case 5:
-              lo = 0;
-              break;
-            }
-          break;
-        case CCI:
-          mpc_set_prec (z2, 128);
-          do {
-            test_default_random (z2, 0, 64, 128, zero_probability);
-          } while (!mpfr_fits_slong_p (mpc_realref (z2), MPFR_RNDN));
-          i = (int)mpfr_get_si (mpc_realref(z2), MPFR_RNDN);
-          mpc_set_prec (z2, prec);
-          mpc_set_prec (z3, prec);
-          mpc_set_prec (zzzz, 4*prec);
-          switch (special)
-            {
-            case 1:
-              mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
-              break;
-            case 2:
-              mpfr_set_inf (mpc_realref (z1), +1);
-              break;
-            case 3:
-              mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
-              break;
-            case 4:
-              mpfr_set_inf (mpc_imagref (z1), -1);
-              break;
-            case 5:
-              i = 0;
-              break;
-            }
-          break;
-        case CCF: case CFC:
-          mpfr_set_prec (x1, prec);
-          mpfr_set (x1, mpc_realref (z1), MPFR_RNDN);
-          test_default_random (z1, exp_min, exp_max, 128, zero_probability);
-          mpc_set_prec (z2, prec);
-          mpc_set_prec (z3, prec);
-          mpc_set_prec (zzzz, 4*prec);
-          switch (special)
-            {
-            case 1:
-              mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
-              break;
-            case 2:
-              mpfr_set_inf (mpc_realref (z1), +1);
-              break;
-            case 3:
-              mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
-              break;
-            case 4:
-              mpfr_set_inf (mpc_imagref (z1), -1);
-              break;
-            case 5:
-              mpfr_set_ui (x1, 0, MPFR_RNDN);
-              break;
-            case 6:
-              mpfr_set_inf (x1, +1);
-              break;
-            }
-          break;
-        case CC_C:
-          mpc_set_prec (z2, prec);
-          mpc_set_prec (z3, prec);
-          mpc_set_prec (z4, prec);
-          mpc_set_prec (z5, prec);
-          mpc_set_prec (zzzz, 4*prec);
-          mpc_set_prec (zzzz2, 4*prec);
-          switch (special)
-            {
-            case 1:
-              mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
-              break;
-            case 2:
-              mpfr_set_inf (mpc_realref (z1), +1);
-              break;
-            case 3:
-              mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
-              break;
-            case 4:
-              mpfr_set_inf (mpc_imagref (z1), -1);
-              break;
-            }
-          break;
-        case CC:
-        default:
-          mpc_set_prec (z2, prec);
-          mpc_set_prec (z3, prec);
-          mpc_set_prec (zzzz, 4*prec);
-          switch (special)
-            {
-            case 1:
-              mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
-              break;
-            case 2:
-              mpfr_set_inf (mpc_realref (z1), +1);
-              break;
-            case 3:
-              mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
-              break;
-            case 4:
-              mpfr_set_inf (mpc_imagref (z1), -1);
-              break;
-            }
-        }
-
-      for (rnd_re = first_rnd_mode (); is_valid_rnd_mode (rnd_re); rnd_re = next_rnd_mode (rnd_re))
-        switch (function.type)
-          {
-          case C_CC:
-            for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
-              tgeneric_c_cc (&function, z1, z2, z3, zzzz, z4,
-			     MPC_RND (rnd_re, rnd_im));
-            reuse_c_cc (&function, z1, z2, z3, z4);
-            break;
-          case CCCC:
-            for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
-              tgeneric_cccc (&function, z1, z2, z3, z4, zzzz, z5,
-                            MPC_RND (rnd_re, rnd_im));
-            reuse_cccc (&function, z1, z2, z3, z4, z5);
-            break;
-          case FC:
-            tgeneric_fc (&function, z1, x1, xxxx, x2, rnd_re);
-            reuse_fc (&function, z1, z2, x1);
-            break;
-          case CC:
-            for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
-              tgeneric_cc (&function, z1, z2, zzzz, z3,
-                           MPC_RND (rnd_re, rnd_im));
-            reuse_cc (&function, z1, z2, z3);
-            break;
-          case CC_C:
-            for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
-               for (rnd2_re = first_rnd_mode (); is_valid_rnd_mode (rnd2_re); rnd2_re = next_rnd_mode (rnd2_re))
-                  for (rnd2_im = first_rnd_mode (); is_valid_rnd_mode (rnd2_im); rnd2_im = next_rnd_mode (rnd2_im))
-                     tgeneric_cc_c (&function, z1, z2, z3, zzzz, zzzz2, z4, z5,
-                           MPC_RND (rnd_re, rnd_im), MPC_RND (rnd2_re, rnd2_im));
-             reuse_cc_c (&function, z1, z2, z3, z4, z5);
-            break;
-          case CFC:
-            for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
-              tgeneric_cfc (&function, x1, z1, z2, zzzz, z3,
-                            MPC_RND (rnd_re, rnd_im));
-            reuse_cfc (&function, z1, x1, z2, z3);
-            break;
-          case CCF:
-            for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
-              tgeneric_ccf (&function, z1, x1, z2, zzzz, z3,
-                            MPC_RND (rnd_re, rnd_im));
-            reuse_ccf (&function, z1, x1, z2, z3);
-            break;
-          case CCU:
-            for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
-              tgeneric_ccu (&function, z1, ul1, z2, zzzz, z3,
-                            MPC_RND (rnd_re, rnd_im));
-            reuse_ccu (&function, z1, ul1, z2, z3);
-            break;
-          case CUC:
-            for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
-              tgeneric_cuc (&function, ul1, z1, z2, zzzz, z3,
-                            MPC_RND (rnd_re, rnd_im));
-            reuse_cuc (&function, ul1, z1, z2, z3);
-            break;
-          case CCS:
-            for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
-              tgeneric_ccs (&function, z1, lo, z2, zzzz, z3,
-                            MPC_RND (rnd_re, rnd_im));
-            reuse_ccs (&function, z1, lo, z2, z3);
-            break;
-          case CCI:
-            for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
-              tgeneric_cci (&function, z1, i, z2, zzzz, z3,
-                            MPC_RND (rnd_re, rnd_im));
-            reuse_cci (&function, z1, i, z2, z3);
-            break;
-          case CUUC:
-            for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
-              tgeneric_cuuc (&function, ul1, ul2, z1, z2, zzzz, z3,
-                             MPC_RND (rnd_re, rnd_im));
-            reuse_cuuc (&function, ul1, ul2, z1, z2, z3);
-            break;
-          default:
-            printf ("tgeneric not yet implemented for this kind of"
-                    "function\n");
-            exit (1);
-          }
-    }
-
-  mpc_clear (z1);
-  switch (function.type)
-    {
-    case C_CC:
-      mpc_clear (z2);
-      mpc_clear (z3);
-      mpc_clear (z4);
-      mpc_clear (zzzz);
-      break;
-    case CCCC:
-      mpc_clear (z2);
-      mpc_clear (z3);
-      mpc_clear (z4);
-      mpc_clear (z5);
-      mpc_clear (zzzz);
-      break;
-    case FC:
-      mpc_clear (z2);
-      mpfr_clear (x1);
-      mpfr_clear (x2);
-      mpfr_clear (xxxx);
-      break;
-    case CCF: case CFC:
-      mpfr_clear (x1);
-      mpc_clear (z2);
-      mpc_clear (z3);
-      mpc_clear (zzzz);
-      break;
-    case CC_C:
-      mpc_clear (z2);
-      mpc_clear (z3);
-      mpc_clear (z4);
-      mpc_clear (z5);
-      mpc_clear (zzzz);
-      mpc_clear (zzzz2);
-      break;
-    case CUUC:
-    case CCI: case CCS:
-    case CCU: case CUC:
-    case CC:
-    default:
-      mpc_clear (z2);
-      mpc_clear (z3);
-      mpc_clear (zzzz);
-    }
-}