diff options
Diffstat (limited to 'REORG.TODO/math/test-tgmath.c')
| -rw-r--r-- | REORG.TODO/math/test-tgmath.c | 1158 |
1 files changed, 1158 insertions, 0 deletions
diff --git a/REORG.TODO/math/test-tgmath.c b/REORG.TODO/math/test-tgmath.c new file mode 100644 index 0000000000..b38138b764 --- /dev/null +++ b/REORG.TODO/math/test-tgmath.c @@ -0,0 +1,1158 @@ +/* Test compilation of tgmath macros. + Copyright (C) 2001-2017 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Jakub Jelinek <jakub@redhat.com> and + Ulrich Drepper <drepper@redhat.com>, 2001. + + The GNU C Library 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 2.1 of the License, or (at your option) any later version. + + The GNU C Library 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 the GNU C Library; if not, see + <http://www.gnu.org/licenses/>. */ + +#ifndef HAVE_MAIN +#undef __NO_MATH_INLINES +#define __NO_MATH_INLINES 1 +#include <math.h> +#include <stdint.h> +#include <stdio.h> +#include <tgmath.h> + +//#define DEBUG + +static void compile_test (void); +static void compile_testf (void); +#ifndef NO_LONG_DOUBLE +static void compile_testl (void); +#endif + +float fx; +double dx; +long double lx; +const float fy = 1.25; +const double dy = 1.25; +const long double ly = 1.25; +complex float fz; +complex double dz; +complex long double lz; + +int count_double; +int count_float; +int count_ldouble; +int count_cdouble; +int count_cfloat; +int count_cldouble; + +#define NCALLS 138 +#define NCALLS_INT 4 +#define NCCALLS 47 + +static int +do_test (void) +{ + int result = 0; + + count_float = count_double = count_ldouble = 0; + count_cfloat = count_cdouble = count_cldouble = 0; + compile_test (); + if (count_float != 0 || count_cfloat != 0) + { + puts ("float function called for double test"); + result = 1; + } + if (count_ldouble != 0 || count_cldouble != 0) + { + puts ("long double function called for double test"); + result = 1; + } + if (count_double < NCALLS + NCALLS_INT) + { + printf ("double functions not called often enough (%d)\n", + count_double); + result = 1; + } + else if (count_double > NCALLS + NCALLS_INT) + { + printf ("double functions called too often (%d)\n", + count_double); + result = 1; + } + if (count_cdouble < NCCALLS) + { + printf ("double complex functions not called often enough (%d)\n", + count_cdouble); + result = 1; + } + else if (count_cdouble > NCCALLS) + { + printf ("double complex functions called too often (%d)\n", + count_cdouble); + result = 1; + } + + count_float = count_double = count_ldouble = 0; + count_cfloat = count_cdouble = count_cldouble = 0; + compile_testf (); + if (count_double != 0 || count_cdouble != 0) + { + puts ("double function called for float test"); + result = 1; + } + if (count_ldouble != 0 || count_cldouble != 0) + { + puts ("long double function called for float test"); + result = 1; + } + if (count_float < NCALLS) + { + printf ("float functions not called often enough (%d)\n", count_float); + result = 1; + } + else if (count_float > NCALLS) + { + printf ("float functions called too often (%d)\n", + count_double); + result = 1; + } + if (count_cfloat < NCCALLS) + { + printf ("float complex functions not called often enough (%d)\n", + count_cfloat); + result = 1; + } + else if (count_cfloat > NCCALLS) + { + printf ("float complex functions called too often (%d)\n", + count_cfloat); + result = 1; + } + +#ifndef NO_LONG_DOUBLE + count_float = count_double = count_ldouble = 0; + count_cfloat = count_cdouble = count_cldouble = 0; + compile_testl (); + if (count_float != 0 || count_cfloat != 0) + { + puts ("float function called for long double test"); + result = 1; + } + if (count_double != 0 || count_cdouble != 0) + { + puts ("double function called for long double test"); + result = 1; + } + if (count_ldouble < NCALLS) + { + printf ("long double functions not called often enough (%d)\n", + count_ldouble); + result = 1; + } + else if (count_ldouble > NCALLS) + { + printf ("long double functions called too often (%d)\n", + count_double); + result = 1; + } + if (count_cldouble < NCCALLS) + { + printf ("long double complex functions not called often enough (%d)\n", + count_cldouble); + result = 1; + } + else if (count_cldouble > NCCALLS) + { + printf ("long double complex functions called too often (%d)\n", + count_cldouble); + result = 1; + } +#endif + + return result; +} + +/* Now generate the three functions. */ +#define HAVE_MAIN + +#define F(name) name +#define TYPE double +#define TEST_INT 1 +#define x dx +#define y dy +#define z dz +#define count count_double +#define ccount count_cdouble +#include "test-tgmath.c" + +#define F(name) name##f +#define TYPE float +#define x fx +#define y fy +#define z fz +#define count count_float +#define ccount count_cfloat +#include "test-tgmath.c" + +#ifndef NO_LONG_DOUBLE +#define F(name) name##l +#define TYPE long double +#define x lx +#define y ly +#define z lz +#define count count_ldouble +#define ccount count_cldouble +#include "test-tgmath.c" +#endif + +#define TEST_FUNCTION do_test () +#include "../test-skeleton.c" + +#else + +#ifdef DEBUG +#define P() puts (__FUNCTION__) +#else +#define P() +#endif + +static void +F(compile_test) (void) +{ + TYPE a, b, c = 1.0; + complex TYPE d; + int i = 2; + int saved_count; + long int j; + long long int k; + intmax_t m; + uintmax_t um; + + a = cos (cos (x)); + b = acos (acos (a)); + a = sin (sin (x)); + b = asin (asin (a)); + a = tan (tan (x)); + b = atan (atan (a)); + c = atan2 (atan2 (a, c), atan2 (b, x)); + a = cosh (cosh (x)); + b = acosh (acosh (a)); + a = sinh (sinh (x)); + b = asinh (asinh (a)); + a = tanh (tanh (x)); + b = atanh (atanh (a)); + a = exp (exp (x)); + b = log (log (a)); + a = log10 (log10 (x)); + b = ldexp (ldexp (a, 1), 5); + a = frexp (frexp (x, &i), &i); + b = expm1 (expm1 (a)); + a = log1p (log1p (x)); + b = logb (logb (a)); + a = exp2 (exp2 (x)); + b = log2 (log2 (a)); + a = pow (pow (x, a), pow (c, b)); + b = sqrt (sqrt (a)); + a = hypot (hypot (x, b), hypot (c, a)); + b = cbrt (cbrt (a)); + a = ceil (ceil (x)); + b = fabs (fabs (a)); + a = floor (floor (x)); + b = fmod (fmod (a, b), fmod (c, x)); + a = nearbyint (nearbyint (x)); + b = round (round (a)); + c = roundeven (roundeven (a)); + a = trunc (trunc (x)); + b = remquo (remquo (a, b, &i), remquo (c, x, &i), &i); + j = lrint (x) + lround (a); + k = llrint (b) + llround (c); + m = fromfp (a, FP_INT_UPWARD, 2) + fromfpx (b, FP_INT_DOWNWARD, 3); + um = ufromfp (c, FP_INT_TONEAREST, 4) + ufromfpx (a, FP_INT_TOWARDZERO, 5); + a = erf (erf (x)); + b = erfc (erfc (a)); + a = tgamma (tgamma (x)); + b = lgamma (lgamma (a)); + a = rint (rint (x)); + b = nextafter (nextafter (a, b), nextafter (c, x)); + a = nextdown (nextdown (a)); + b = nexttoward (nexttoward (x, a), c); + a = nextup (nextup (a)); + b = remainder (remainder (a, b), remainder (c, x)); + a = scalb (scalb (x, a), (TYPE) (6)); + k = scalbn (a, 7) + scalbln (c, 10l); + i = ilogb (x); + j = llogb (x); + a = fdim (fdim (x, a), fdim (c, b)); + b = fmax (fmax (a, x), fmax (c, b)); + a = fmin (fmin (x, a), fmin (c, b)); + b = fmaxmag (fmaxmag (a, x), fmaxmag (c, b)); + a = fminmag (fminmag (x, a), fminmag (c, b)); + b = fma (sin (a), sin (x), sin (c)); + a = totalorder (totalorder (x, b), totalorder (c, x)); + b = totalordermag (totalordermag (x, a), totalordermag (c, x)); + +#ifdef TEST_INT + a = atan2 (i, b); + b = remquo (i, a, &i); + c = fma (i, b, i); + a = pow (i, c); +#endif + x = a + b + c + i + j + k + m + um; + + saved_count = count; + if (ccount != 0) + ccount = -10000; + + d = cos (cos (z)); + z = acos (acos (d)); + d = sin (sin (z)); + z = asin (asin (d)); + d = tan (tan (z)); + z = atan (atan (d)); + d = cosh (cosh (z)); + z = acosh (acosh (d)); + d = sinh (sinh (z)); + z = asinh (asinh (d)); + d = tanh (tanh (z)); + z = atanh (atanh (d)); + d = exp (exp (z)); + z = log (log (d)); + d = sqrt (sqrt (z)); + z = conj (conj (d)); + d = fabs (conj (a)); + z = pow (pow (a, d), pow (b, z)); + d = cproj (cproj (z)); + z += fabs (cproj (a)); + a = carg (carg (z)); + b = creal (creal (d)); + c = cimag (cimag (z)); + x += a + b + c + i + j + k; + z += d; + + if (saved_count != count) + count = -10000; + + if (0) + { + a = cos (y); + a = acos (y); + a = sin (y); + a = asin (y); + a = tan (y); + a = atan (y); + a = atan2 (y, y); + a = cosh (y); + a = acosh (y); + a = sinh (y); + a = asinh (y); + a = tanh (y); + a = atanh (y); + a = exp (y); + a = log (y); + a = log10 (y); + a = ldexp (y, 5); + a = frexp (y, &i); + a = expm1 (y); + a = log1p (y); + a = logb (y); + a = exp2 (y); + a = log2 (y); + a = pow (y, y); + a = sqrt (y); + a = hypot (y, y); + a = cbrt (y); + a = ceil (y); + a = fabs (y); + a = floor (y); + a = fmod (y, y); + a = nearbyint (y); + a = round (y); + a = roundeven (y); + a = trunc (y); + a = remquo (y, y, &i); + j = lrint (y) + lround (y); + k = llrint (y) + llround (y); + m = fromfp (y, FP_INT_UPWARD, 6) + fromfpx (y, FP_INT_DOWNWARD, 7); + um = (ufromfp (y, FP_INT_TONEAREST, 8) + + ufromfpx (y, FP_INT_TOWARDZERO, 9)); + a = erf (y); + a = erfc (y); + a = tgamma (y); + a = lgamma (y); + a = rint (y); + a = nextafter (y, y); + a = nexttoward (y, y); + a = remainder (y, y); + a = scalb (y, (const TYPE) (6)); + k = scalbn (y, 7) + scalbln (y, 10l); + i = ilogb (y); + j = llogb (y); + a = fdim (y, y); + a = fmax (y, y); + a = fmin (y, y); + a = fmaxmag (y, y); + a = fminmag (y, y); + a = fma (y, y, y); + a = totalorder (y, y); + a = totalordermag (y, y); + +#ifdef TEST_INT + a = atan2 (i, y); + a = remquo (i, y, &i); + a = fma (i, y, i); + a = pow (i, y); +#endif + + d = cos ((const complex TYPE) z); + d = acos ((const complex TYPE) z); + d = sin ((const complex TYPE) z); + d = asin ((const complex TYPE) z); + d = tan ((const complex TYPE) z); + d = atan ((const complex TYPE) z); + d = cosh ((const complex TYPE) z); + d = acosh ((const complex TYPE) z); + d = sinh ((const complex TYPE) z); + d = asinh ((const complex TYPE) z); + d = tanh ((const complex TYPE) z); + d = atanh ((const complex TYPE) z); + d = exp ((const complex TYPE) z); + d = log ((const complex TYPE) z); + d = sqrt ((const complex TYPE) z); + d = pow ((const complex TYPE) z, (const complex TYPE) z); + d = fabs ((const complex TYPE) z); + d = carg ((const complex TYPE) z); + d = creal ((const complex TYPE) z); + d = cimag ((const complex TYPE) z); + d = conj ((const complex TYPE) z); + d = cproj ((const complex TYPE) z); + } +} +#undef x +#undef y +#undef z + + +TYPE +(F(cos)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(acos)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(sin)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(asin)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(tan)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(atan)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(atan2)) (TYPE x, TYPE y) +{ + ++count; + P (); + return x + y; +} + +TYPE +(F(cosh)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(acosh)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(sinh)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(asinh)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(tanh)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(atanh)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(exp)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(log)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(log10)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(ldexp)) (TYPE x, int y) +{ + ++count; + P (); + return x + y; +} + +TYPE +(F(frexp)) (TYPE x, int *y) +{ + ++count; + P (); + return x + *y; +} + +TYPE +(F(expm1)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(log1p)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(logb)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(exp2)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(log2)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(pow)) (TYPE x, TYPE y) +{ + ++count; + P (); + return x + y; +} + +TYPE +(F(sqrt)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(hypot)) (TYPE x, TYPE y) +{ + ++count; + P (); + return x + y; +} + +TYPE +(F(cbrt)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(ceil)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(fabs)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(floor)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(fmod)) (TYPE x, TYPE y) +{ + ++count; + P (); + return x + y; +} + +TYPE +(F(nearbyint)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(round)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(roundeven)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(trunc)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(remquo)) (TYPE x, TYPE y, int *i) +{ + ++count; + P (); + return x + y + *i; +} + +long int +(F(lrint)) (TYPE x) +{ + ++count; + P (); + return x; +} + +long int +(F(lround)) (TYPE x) +{ + ++count; + P (); + return x; +} + +long long int +(F(llrint)) (TYPE x) +{ + ++count; + P (); + return x; +} + +long long int +(F(llround)) (TYPE x) +{ + ++count; + P (); + return x; +} + +intmax_t +(F(fromfp)) (TYPE x, int round, unsigned int width) +{ + ++count; + P (); + return x; +} + +intmax_t +(F(fromfpx)) (TYPE x, int round, unsigned int width) +{ + ++count; + P (); + return x; +} + +uintmax_t +(F(ufromfp)) (TYPE x, int round, unsigned int width) +{ + ++count; + P (); + return x; +} + +uintmax_t +(F(ufromfpx)) (TYPE x, int round, unsigned int width) +{ + ++count; + P (); + return x; +} + +TYPE +(F(erf)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(erfc)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(tgamma)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(lgamma)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(rint)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(nextafter)) (TYPE x, TYPE y) +{ + ++count; + P (); + return x + y; +} + +TYPE +(F(nextdown)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(nexttoward)) (TYPE x, long double y) +{ + ++count; + P (); + return x + y; +} + +TYPE +(F(nextup)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(remainder)) (TYPE x, TYPE y) +{ + ++count; + P (); + return x + y; +} + +TYPE +(F(scalb)) (TYPE x, TYPE y) +{ + ++count; + P (); + return x + y; +} + +TYPE +(F(scalbn)) (TYPE x, int y) +{ + ++count; + P (); + return x + y; +} + +TYPE +(F(scalbln)) (TYPE x, long int y) +{ + ++count; + P (); + return x + y; +} + +int +(F(ilogb)) (TYPE x) +{ + ++count; + P (); + return x; +} + +long int +(F(llogb)) (TYPE x) +{ + ++count; + P (); + return x; +} + +TYPE +(F(fdim)) (TYPE x, TYPE y) +{ + ++count; + P (); + return x + y; +} + +TYPE +(F(fmin)) (TYPE x, TYPE y) +{ + ++count; + P (); + return x + y; +} + +TYPE +(F(fmax)) (TYPE x, TYPE y) +{ + ++count; + P (); + return x + y; +} + +TYPE +(F(fminmag)) (TYPE x, TYPE y) +{ + ++count; + P (); + return x + y; +} + +TYPE +(F(fmaxmag)) (TYPE x, TYPE y) +{ + ++count; + P (); + return x + y; +} + +TYPE +(F(fma)) (TYPE x, TYPE y, TYPE z) +{ + ++count; + P (); + return x + y + z; +} + +int +(F(totalorder)) (TYPE x, TYPE y) +{ + ++count; + P (); + return x + y; +} + +int +(F(totalordermag)) (TYPE x, TYPE y) +{ + ++count; + P (); + return x + y; +} + +complex TYPE +(F(cacos)) (complex TYPE x) +{ + ++ccount; + P (); + return x; +} + +complex TYPE +(F(casin)) (complex TYPE x) +{ + ++ccount; + P (); + return x; +} + +complex TYPE +(F(catan)) (complex TYPE x) +{ + ++ccount; + P (); + return x; +} + +complex TYPE +(F(ccos)) (complex TYPE x) +{ + ++ccount; + P (); + return x; +} + +complex TYPE +(F(csin)) (complex TYPE x) +{ + ++ccount; + P (); + return x; +} + +complex TYPE +(F(ctan)) (complex TYPE x) +{ + ++ccount; + P (); + return x; +} + +complex TYPE +(F(cacosh)) (complex TYPE x) +{ + ++ccount; + P (); + return x; +} + +complex TYPE +(F(casinh)) (complex TYPE x) +{ + ++ccount; + P (); + return x; +} + +complex TYPE +(F(catanh)) (complex TYPE x) +{ + ++ccount; + P (); + return x; +} + +complex TYPE +(F(ccosh)) (complex TYPE x) +{ + ++ccount; + P (); + return x; +} + +complex TYPE +(F(csinh)) (complex TYPE x) +{ + ++ccount; + P (); + return x; +} + +complex TYPE +(F(ctanh)) (complex TYPE x) +{ + ++ccount; + P (); + return x; +} + +complex TYPE +(F(cexp)) (complex TYPE x) +{ + ++ccount; + P (); + return x; +} + +complex TYPE +(F(clog)) (complex TYPE x) +{ + ++ccount; + P (); + return x; +} + +complex TYPE +(F(csqrt)) (complex TYPE x) +{ + ++ccount; + P (); + return x; +} + +complex TYPE +(F(cpow)) (complex TYPE x, complex TYPE y) +{ + ++ccount; + P (); + return x + y; +} + +TYPE +(F(cabs)) (complex TYPE x) +{ + ++ccount; + P (); + return x; +} + +TYPE +(F(carg)) (complex TYPE x) +{ + ++ccount; + P (); + return x; +} + +TYPE +(F(creal)) (complex TYPE x) +{ + ++ccount; + P (); + return __real__ x; +} + +TYPE +(F(cimag)) (complex TYPE x) +{ + ++ccount; + P (); + return __imag__ x; +} + +complex TYPE +(F(conj)) (complex TYPE x) +{ + ++ccount; + P (); + return x; +} + +complex TYPE +(F(cproj)) (complex TYPE x) +{ + ++ccount; + P (); + return x; +} + +#undef F +#undef TYPE +#undef count +#undef ccount +#undef TEST_INT +#endif |