From a31089737187d014ffd015d292788bb4649d2355 Mon Sep 17 00:00:00 2001 From: thevenyp Date: Tue, 21 Jan 2014 10:21:47 +0000 Subject: Additional clean-up after r1416. git-svn-id: svn://scm.gforge.inria.fr/svn/mpc/trunk@1419 211d60ee-9f03-0410-a15a-8952a2c7a4e4 --- Makefile.vc | 2 +- tests/tgeneric.c | 1412 ------------------------------------------------------ 2 files changed, 1 insertion(+), 1413 deletions(-) delete mode 100644 tests/tgeneric.c 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); - } -} -- cgit v1.2.1