b6004e573a5f980c002c14f770e6c9756aeb0450
[kopensolaris-gnu/glibc.git] / math / test-tgmath.c
1 /* Test compilation of tgmath macros.
2    Copyright (C) 2001 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by Jakub Jelinek <jakub@redhat.com> and
5    Ulrich Drepper <drepper@redhat.com>, 2001.
6
7    The GNU C Library is free software; you can redistribute it and/or
8    modify it under the terms of the GNU Library General Public License as
9    published by the Free Software Foundation; either version 2 of the
10    License, or (at your option) any later version.
11
12    The GNU C Library is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15    Library General Public License for more details.
16
17    You should have received a copy of the GNU Library General Public
18    License along with the GNU C Library; see the file COPYING.LIB.  If not,
19    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20    Boston, MA 02111-1307, USA.  */
21
22 #ifndef HAVE_MAIN
23 #undef __NO_MATH_INLINES
24 #define __NO_MATH_INLINES 1
25 #include <math.h>
26 #include <stdio.h>
27 #include <tgmath.h>
28
29 //#define DEBUG
30
31 static void compile_test (void);
32 static void compile_testf (void);
33 static void compile_testl (void);
34
35 float fx;
36 double dx;
37 long double lx;
38
39 int count_double;
40 int count_float;
41 int count_ldouble;
42
43 #define NCALLS     115
44 #define NCALLS_INT 4
45
46 int
47 main (void)
48 {
49   int result = 0;
50
51   count_float = count_double = count_ldouble = 0;
52   compile_test ();
53   if (count_float != 0)
54     {
55       puts ("float function called for double test");
56       result = 1;
57     }
58   if (count_ldouble != 0)
59     {
60       puts ("long double function called for double test");
61       result = 1;
62     }
63   if (count_double < NCALLS + NCALLS_INT)
64     {
65       printf ("double functions not called often enough (%d)\n",
66               count_double);
67       result = 1;
68     }
69   else if (count_double > NCALLS + NCALLS_INT)
70     {
71       printf ("double functions called too often (%d)\n",
72               count_double);
73       result = 1;
74     }
75
76   count_float = count_double = count_ldouble = 0;
77   compile_testf ();
78   if (count_double != 0)
79     {
80       puts ("double function called for float test");
81       result = 1;
82     }
83   if (count_ldouble != 0)
84     {
85       puts ("long double function called for float test");
86       result = 1;
87     }
88   if (count_float < NCALLS)
89     {
90       printf ("float functions not called often enough (%d)\n", count_float);
91       result = 1;
92     }
93   else if (count_float > NCALLS)
94     {
95       printf ("float functions called too often (%d)\n",
96               count_double);
97       result = 1;
98     }
99
100 #ifndef NO_LONG_DOUBLE
101   count_float = count_double = count_ldouble = 0;
102   compile_testl ();
103   if (count_float != 0)
104     {
105       puts ("float function called for long double test");
106       result = 1;
107     }
108   if (count_double != 0)
109     {
110       puts ("double function called for long double test");
111       result = 1;
112     }
113   if (count_ldouble < NCALLS)
114     {
115       printf ("long double functions not called often enough (%d)\n",
116               count_ldouble);
117       result = 1;
118     }
119   else if (count_ldouble > NCALLS)
120     {
121       printf ("long double functions called too often (%d)\n",
122               count_double);
123       result = 1;
124     }
125 #endif
126
127   return result;
128 }
129
130 /* Now generate the three functions.  */
131 #define HAVE_MAIN
132
133 #define F(name) name
134 #define TYPE double
135 #define TEST_INT 1
136 #define x dx
137 #define count count_double
138 #include "test-tgmath.c"
139
140 #define F(name) name##f
141 #define TYPE float
142 #define x fx
143 #define count count_float
144 #include "test-tgmath.c"
145
146 #ifndef NO_LONG_DOUBLE
147 #define F(name) name##l
148 #define TYPE long double
149 #define x lx
150 #define count count_ldouble
151 #include "test-tgmath.c"
152 #endif
153
154 #else
155
156 #ifdef DEBUG
157 #define P() puts (__FUNCTION__)
158 #else
159 #define P()
160 #endif
161
162 static void
163 F(compile_test) (void)
164 {
165   TYPE a, b, c;
166   int i;
167   long int j;
168   long long int k;
169
170   a = cos (cos (x));
171   b = acos (acos (a));
172   a = sin (sin (x));
173   b = asin (asin (a));
174   a = tan (tan (x));
175   b = atan (atan (a));
176   c = atan2 (atan2 (a, c), atan2 (b, x));
177   a = cosh (cosh (x));
178   b = acosh (acosh (a));
179   a = sinh (sinh (x));
180   b = asinh (asinh (a));
181   a = tanh (tanh (x));
182   b = atanh (atanh (a));
183   a = exp (exp (x));
184   b = log (log (a));
185   a = log10 (log10 (x));
186   b = ldexp (ldexp (a, 1), 5);
187   a = frexp (frexp (x, &i), &i);
188   b = expm1 (expm1 (a));
189   a = log1p (log1p (x));
190   b = logb (logb (a));
191   a = exp2 (exp2 (x));
192   b = log2 (log2 (a));
193   a = pow (pow (x, a), pow (c, b));
194   b = sqrt (sqrt (a));
195   a = hypot (hypot (x, b), hypot (c, a));
196   b = cbrt (cbrt (a));
197   a = ceil (ceil (x));
198   b = fabs (fabs (a));
199   a = floor (floor (x));
200   b = fmod (fmod (a, b), fmod (c, x));
201   a = nearbyint (nearbyint (x));
202   b = round (round (a));
203   a = trunc (trunc (x));
204   b = remquo (remquo (a, b, &i), remquo (c, x, &i), &i);
205   j = lrint (x) + lround (a);
206   k = llrint (b) + llround (c);
207   a = erf (erf (x));
208   b = erfc (erfc (a));
209   a = tgamma (tgamma (x));
210   b = lgamma (lgamma (a));
211   a = rint (rint (x));
212   b = nextafter (nextafter (a, b), nextafter (c, x));
213   a = nexttoward (nexttoward (x, a), c);
214   b = remainder (remainder (a, b), remainder (c, x));
215   a = scalb (scalb (x, a), (TYPE) (6));
216   k = scalbn (a, 7) + scalbln (c, 10l);
217   i = ilogb (x);
218   a = fdim (fdim (x, a), fdim (c, b));
219   b = fmax (fmax (a, x), fmax (c, b));
220   a = fmin (fmin (x, a), fmin (c, b));
221   b = fma (sin (a), sin (x), sin (c));
222
223 #ifdef TEST_INT
224   a = atan2 (i, b);
225   b = remquo (i, a, &i);
226   c = fma (i, b, i);
227   a = pow (i, c);
228 #endif
229 }
230 #undef x
231
232
233 TYPE
234 (F(cos)) (TYPE x)
235 {
236   ++count;
237   return x;
238 }
239
240 TYPE
241 (F(acos)) (TYPE x)
242 {
243   ++count;
244   P();
245   return x;
246 }
247
248 TYPE
249 (F(sin)) (TYPE x)
250 {
251   ++count;
252   P();
253   return x;
254 }
255
256 TYPE
257 (F(asin)) (TYPE x)
258 {
259   ++count;
260   P();
261   return x;
262 }
263
264 TYPE
265 (F(tan)) (TYPE x)
266 {
267   ++count;
268   P();
269   return x;
270 }
271
272 TYPE
273 (F(atan)) (TYPE x)
274 {
275   ++count;
276   P();
277   return x;
278 }
279
280 TYPE
281 (F(atan2)) (TYPE x, TYPE y)
282 {
283   ++count;
284   P();
285   return x + y;
286 }
287
288 TYPE
289 (F(cosh)) (TYPE x)
290 {
291   ++count;
292   P();
293   return x;
294 }
295
296 TYPE
297 (F(acosh)) (TYPE x)
298 {
299   ++count;
300   P();
301   return x;
302 }
303
304 TYPE
305 (F(sinh)) (TYPE x)
306 {
307   ++count;
308   P();
309   return x;
310 }
311
312 TYPE
313 (F(asinh)) (TYPE x)
314 {
315   ++count;
316   P();
317   return x;
318 }
319
320 TYPE
321 (F(tanh)) (TYPE x)
322 {
323   ++count;
324   P();
325   return x;
326 }
327
328 TYPE
329 (F(atanh)) (TYPE x)
330 {
331   ++count;
332   P();
333   return x;
334 }
335
336 TYPE
337 (F(exp)) (TYPE x)
338 {
339   ++count;
340   P();
341   return x;
342 }
343
344 TYPE
345 (F(log)) (TYPE x)
346 {
347   ++count;
348   P();
349   return x;
350 }
351
352 TYPE
353 (F(log10)) (TYPE x)
354 {
355   ++count;
356   P();
357   return x;
358 }
359
360 TYPE
361 (F(ldexp)) (TYPE x, int y)
362 {
363   ++count;
364   P();
365   return x;
366 }
367
368 TYPE
369 (F(frexp)) (TYPE x, int *y)
370 {
371   ++count;
372   P();
373   return x;
374 }
375
376 TYPE
377 (F(expm1)) (TYPE x)
378 {
379   ++count;
380   P();
381   return x;
382 }
383
384 TYPE
385 (F(log1p)) (TYPE x)
386 {
387   ++count;
388   P();
389   return x;
390 }
391
392 TYPE
393 (F(logb)) (TYPE x)
394 {
395   ++count;
396   P();
397   return x;
398 }
399
400 TYPE
401 (F(exp2)) (TYPE x)
402 {
403   ++count;
404   P();
405   return x;
406 }
407
408 TYPE
409 (F(log2)) (TYPE x)
410 {
411   ++count;
412   P();
413   return x;
414 }
415
416 TYPE
417 (F(pow)) (TYPE x, TYPE y)
418 {
419   ++count;
420   P();
421   return x + y;
422 }
423
424 TYPE
425 (F(sqrt)) (TYPE x)
426 {
427   ++count;
428   P();
429   return x;
430 }
431
432 TYPE
433 (F(hypot)) (TYPE x, TYPE y)
434 {
435   ++count;
436   P();
437   return x + y;
438 }
439
440 TYPE
441 (F(cbrt)) (TYPE x)
442 {
443   ++count;
444   P();
445   return x;
446 }
447
448 TYPE
449 (F(ceil)) (TYPE x)
450 {
451   ++count;
452   P();
453   return x;
454 }
455
456 TYPE
457 (F(fabs)) (TYPE x)
458 {
459   ++count;
460   P();
461   return x;
462 }
463
464 TYPE
465 (F(floor)) (TYPE x)
466 {
467   ++count;
468   P();
469   return x;
470 }
471
472 TYPE
473 (F(fmod)) (TYPE x, TYPE y)
474 {
475   ++count;
476   P();
477   return x + y;
478 }
479
480 TYPE
481 (F(nearbyint)) (TYPE x)
482 {
483   ++count;
484   P();
485   return x;
486 }
487
488 TYPE
489 (F(round)) (TYPE x)
490 {
491   ++count;
492   P();
493   return x;
494 }
495
496 TYPE
497 (F(trunc)) (TYPE x)
498 {
499   ++count;
500   P();
501   return x;
502 }
503
504 TYPE
505 (F(remquo)) (TYPE x, TYPE y, int *i)
506 {
507   ++count;
508   P();
509   return x + y;
510 }
511
512 long int
513 (F(lrint)) (TYPE x)
514 {
515   ++count;
516   P();
517   return x;
518 }
519
520 long int
521 (F(lround)) (TYPE x)
522 {
523   ++count;
524   P();
525   return x;
526 }
527
528 long long int
529 (F(llrint)) (TYPE x)
530 {
531   ++count;
532   P();
533   return x;
534 }
535
536 long long int
537 (F(llround)) (TYPE x)
538 {
539   ++count;
540   P();
541   return x;
542 }
543
544 TYPE
545 (F(erf)) (TYPE x)
546 {
547   ++count;
548   P();
549   return x;
550 }
551
552 TYPE
553 (F(erfc)) (TYPE x)
554 {
555   ++count;
556   P();
557   return x;
558 }
559
560 TYPE
561 (F(tgamma)) (TYPE x)
562 {
563   ++count;
564   P();
565   return x;
566 }
567
568 TYPE
569 (F(lgamma)) (TYPE x)
570 {
571   ++count;
572   P();
573   return x;
574 }
575
576 TYPE
577 (F(rint)) (TYPE x)
578 {
579   ++count;
580   P();
581   return x;
582 }
583
584 TYPE
585 (F(nextafter)) (TYPE x, TYPE y)
586 {
587   ++count;
588   P();
589   return x + y;
590 }
591
592 TYPE
593 (F(nexttoward)) (TYPE x, long double y)
594 {
595   ++count;
596   P();
597   return x;
598 }
599
600 TYPE
601 (F(remainder)) (TYPE x, TYPE y)
602 {
603   ++count;
604   P();
605   return x + y;
606 }
607
608 TYPE
609 (F(scalb)) (TYPE x, TYPE y)
610 {
611   ++count;
612   P();
613   return x + y;
614 }
615
616 TYPE
617 (F(scalbn)) (TYPE x, int y)
618 {
619   ++count;
620   P();
621   return x;
622 }
623
624 TYPE
625 (F(scalbln)) (TYPE x, long int y)
626 {
627   ++count;
628   P();
629   return x;
630 }
631
632 int
633 (F(ilogb)) (TYPE x)
634 {
635   ++count;
636   P();
637   return x;
638 }
639
640 TYPE
641 (F(fdim)) (TYPE x, TYPE y)
642 {
643   ++count;
644   P();
645   return x + y;
646 }
647
648 TYPE
649 (F(fmin)) (TYPE x, TYPE y)
650 {
651   ++count;
652   P();
653   return x + y;
654 }
655
656 TYPE
657 (F(fmax)) (TYPE x, TYPE y)
658 {
659   ++count;
660   P();
661   return x + y;
662 }
663
664 TYPE
665 (F(fma)) (TYPE x, TYPE y, TYPE z)
666 {
667   ++count;
668   P();
669   return x + y + z;
670 }
671
672 #undef F
673 #undef TYPE
674 #undef count
675 #undef TEST_INT
676 #endif