1 /* Test compilation of tgmath macros.
2 Copyright (C) 2001-2023 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19 #ifndef HAVE_MAIN
20 #include <float.h>
21 #include <math.h>
22 #include <stdint.h>
23 #include <stdio.h>
24 #include <tgmath.h>
25
26 //#define DEBUG
27
28 static void compile_test (void);
29 static void compile_testf (void);
30 #if LDBL_MANT_DIG > DBL_MANT_DIG
31 static void compile_testl (void);
32 #endif
33
34 float fx;
35 double dx;
36 long double lx;
37 const float fy = 1.25;
38 const double dy = 1.25;
39 const long double ly = 1.25;
40 complex float fz;
41 complex double dz;
42 complex long double lz;
43
44 volatile int count_double;
45 volatile int count_float;
46 volatile int count_ldouble;
47 volatile int count_cdouble;
48 volatile int count_cfloat;
49 volatile int count_cldouble;
50
51 #define NCALLS 158
52 #define NCALLS_INT 4
53 #define NCCALLS 47
54
55 static int
56 do_test (void)
57 {
58 int result = 0;
59
60 count_float = count_double = count_ldouble = 0;
61 count_cfloat = count_cdouble = count_cldouble = 0;
62 compile_test ();
63 if (count_float != 0 || count_cfloat != 0)
64 {
65 puts ("float function called for double test");
66 result = 1;
67 }
68 if (count_ldouble != 0 || count_cldouble != 0)
69 {
70 puts ("long double function called for double test");
71 result = 1;
72 }
73 if (count_double < NCALLS + NCALLS_INT)
74 {
75 printf ("double functions not called often enough (%d)\n",
76 count_double);
77 result = 1;
78 }
79 else if (count_double > NCALLS + NCALLS_INT)
80 {
81 printf ("double functions called too often (%d)\n",
82 count_double);
83 result = 1;
84 }
85 if (count_cdouble < NCCALLS)
86 {
87 printf ("double complex functions not called often enough (%d)\n",
88 count_cdouble);
89 result = 1;
90 }
91 else if (count_cdouble > NCCALLS)
92 {
93 printf ("double complex functions called too often (%d)\n",
94 count_cdouble);
95 result = 1;
96 }
97
98 count_float = count_double = count_ldouble = 0;
99 count_cfloat = count_cdouble = count_cldouble = 0;
100 compile_testf ();
101 if (count_double != 0 || count_cdouble != 0)
102 {
103 puts ("double function called for float test");
104 result = 1;
105 }
106 if (count_ldouble != 0 || count_cldouble != 0)
107 {
108 puts ("long double function called for float test");
109 result = 1;
110 }
111 if (count_float < NCALLS)
112 {
113 printf ("float functions not called often enough (%d)\n", count_float);
114 result = 1;
115 }
116 else if (count_float > NCALLS)
117 {
118 printf ("float functions called too often (%d)\n",
119 count_double);
120 result = 1;
121 }
122 if (count_cfloat < NCCALLS)
123 {
124 printf ("float complex functions not called often enough (%d)\n",
125 count_cfloat);
126 result = 1;
127 }
128 else if (count_cfloat > NCCALLS)
129 {
130 printf ("float complex functions called too often (%d)\n",
131 count_cfloat);
132 result = 1;
133 }
134
135 #if LDBL_MANT_DIG > DBL_MANT_DIG
136 count_float = count_double = count_ldouble = 0;
137 count_cfloat = count_cdouble = count_cldouble = 0;
138 compile_testl ();
139 if (count_float != 0 || count_cfloat != 0)
140 {
141 puts ("float function called for long double test");
142 result = 1;
143 }
144 if (count_double != 0 || count_cdouble != 0)
145 {
146 puts ("double function called for long double test");
147 result = 1;
148 }
149 if (count_ldouble < NCALLS)
150 {
151 printf ("long double functions not called often enough (%d)\n",
152 count_ldouble);
153 result = 1;
154 }
155 else if (count_ldouble > NCALLS)
156 {
157 printf ("long double functions called too often (%d)\n",
158 count_double);
159 result = 1;
160 }
161 if (count_cldouble < NCCALLS)
162 {
163 printf ("long double complex functions not called often enough (%d)\n",
164 count_cldouble);
165 result = 1;
166 }
167 else if (count_cldouble > NCCALLS)
168 {
169 printf ("long double complex functions called too often (%d)\n",
170 count_cldouble);
171 result = 1;
172 }
173 #endif
174
175 return result;
176 }
177
178 /* Now generate the three functions. */
179 #define HAVE_MAIN
180
181 #define F(name) name
182 #define TYPE double
183 #define TEST_INT 1
184 #define x dx
185 #define y dy
186 #define z dz
187 #define count count_double
188 #define ccount count_cdouble
189 #include "test-tgmath.c"
190
191 #define F(name) name##f
192 #define TYPE float
193 #define x fx
194 #define y fy
195 #define z fz
196 #define count count_float
197 #define ccount count_cfloat
198 #include "test-tgmath.c"
199
200 #if LDBL_MANT_DIG > DBL_MANT_DIG
201 #define F(name) name##l
202 #define TYPE long double
203 #define x lx
204 #define y ly
205 #define z lz
206 #define count count_ldouble
207 #define ccount count_cldouble
208 #include "test-tgmath.c"
209 #endif
210
211 #define TEST_FUNCTION do_test ()
212 #include "../test-skeleton.c"
213
214 #else
215
216 #ifdef DEBUG
217 #define P() puts (__FUNCTION__)
218 #else
219 #define P()
220 #endif
221
222 static void
223 F(compile_test) (void)
224 {
225 TYPE a, b, c = 1.0;
226 complex TYPE d;
227 int i = 2;
228 int saved_count;
229 long int j;
230 long long int k;
231 intmax_t m;
232 uintmax_t um;
233
234 a = cos (cos (x));
235 b = acos (acos (a));
236 a = sin (sin (x));
237 b = asin (asin (a));
238 a = tan (tan (x));
239 b = atan (atan (a));
240 c = atan2 (atan2 (a, c), atan2 (b, x));
241 a = cosh (cosh (x));
242 b = acosh (acosh (a));
243 a = sinh (sinh (x));
244 b = asinh (asinh (a));
245 a = tanh (tanh (x));
246 b = atanh (atanh (a));
247 a = exp (exp (x));
248 b = log (log (a));
249 a = log10 (log10 (x));
250 b = ldexp (ldexp (a, 1), 5);
251 a = frexp (frexp (x, &i), &i);
252 b = expm1 (expm1 (a));
253 a = log1p (log1p (x));
254 b = logb (logb (a));
255 a = exp2 (exp2 (x));
256 a = exp10 (exp10 (x));
257 b = log2 (log2 (a));
258 a = pow (pow (x, a), pow (c, b));
259 b = sqrt (sqrt (a));
260 a = hypot (hypot (x, b), hypot (c, a));
261 b = cbrt (cbrt (a));
262 a = ceil (ceil (x));
263 b = fabs (fabs (a));
264 a = floor (floor (x));
265 b = fmod (fmod (a, b), fmod (c, x));
266 a = nearbyint (nearbyint (x));
267 b = round (round (a));
268 c = roundeven (roundeven (a));
269 a = trunc (trunc (x));
270 b = remquo (remquo (a, b, &i), remquo (c, x, &i), &i);
271 j = lrint (x) + lround (a);
272 k = llrint (b) + llround (c);
273 m = fromfp (a, FP_INT_UPWARD, 2) + fromfpx (b, FP_INT_DOWNWARD, 3);
274 um = ufromfp (c, FP_INT_TONEAREST, 4) + ufromfpx (a, FP_INT_TOWARDZERO, 5);
275 a = erf (erf (x));
276 b = erfc (erfc (a));
277 a = tgamma (tgamma (x));
278 b = lgamma (lgamma (a));
279 a = rint (rint (x));
280 b = nextafter (nextafter (a, b), nextafter (c, x));
281 a = nextdown (nextdown (a));
282 b = nexttoward (nexttoward (x, a), c);
283 a = nextup (nextup (a));
284 b = remainder (remainder (a, b), remainder (c, x));
285 a = scalb (scalb (x, a), (TYPE) (6));
286 k = scalbn (a, 7) + scalbln (c, 10l);
287 i = ilogb (x);
288 j = llogb (x);
289 a = fdim (fdim (x, a), fdim (c, b));
290 b = fmax (fmax (a, x), fmax (c, b));
291 a = fmin (fmin (x, a), fmin (c, b));
292 b = fmaxmag (fmaxmag (a, x), fmaxmag (c, b));
293 a = fminmag (fminmag (x, a), fminmag (c, b));
294 b = fmaximum (fmaximum (a, x), fmaximum (c, b));
295 a = fminimum (fminimum (x, a), fminimum (c, b));
296 b = fmaximum_num (fmaximum_num (a, x), fmaximum_num (c, b));
297 a = fminimum_num (fminimum_num (x, a), fminimum_num (c, b));
298 b = fmaximum_mag (fmaximum_mag (a, x), fmaximum_mag (c, b));
299 a = fminimum_mag (fminimum_mag (x, a), fminimum_mag (c, b));
300 b = fmaximum_mag_num (fmaximum_mag_num (a, x), fmaximum_mag_num (c, b));
301 a = fminimum_mag_num (fminimum_mag_num (x, a), fminimum_mag_num (c, b));
302 b = fma (sin (a), sin (x), sin (c));
303
304 #ifdef TEST_INT
305 a = atan2 (i, b);
306 b = remquo (i, a, &i);
307 c = fma (i, b, i);
308 a = pow (i, c);
309 #endif
310 x = a + b + c + i + j + k + m + um;
311
312 saved_count = count;
313 if (ccount != 0)
314 ccount = -10000;
315
316 d = cos (cos (z));
317 z = acos (acos (d));
318 d = sin (sin (z));
319 z = asin (asin (d));
320 d = tan (tan (z));
321 z = atan (atan (d));
322 d = cosh (cosh (z));
323 z = acosh (acosh (d));
324 d = sinh (sinh (z));
325 z = asinh (asinh (d));
326 d = tanh (tanh (z));
327 z = atanh (atanh (d));
328 d = exp (exp (z));
329 z = log (log (d));
330 d = sqrt (sqrt (z));
331 z = conj (conj (d));
332 d = fabs (conj (a));
333 z = pow (pow (a, d), pow (b, z));
334 d = cproj (cproj (z));
335 z += fabs (cproj (a));
336 a = carg (carg (z));
337 b = creal (creal (d));
338 c = cimag (cimag (z));
339 x += a + b + c + i + j + k;
340 z += d;
341
342 if (saved_count != count)
343 count = -10000;
344
345 if (0)
346 {
347 a = cos (y);
348 a = acos (y);
349 a = sin (y);
350 a = asin (y);
351 a = tan (y);
352 a = atan (y);
353 a = atan2 (y, y);
354 a = cosh (y);
355 a = acosh (y);
356 a = sinh (y);
357 a = asinh (y);
358 a = tanh (y);
359 a = atanh (y);
360 a = exp (y);
361 a = log (y);
362 a = log10 (y);
363 a = ldexp (y, 5);
364 a = frexp (y, &i);
365 a = expm1 (y);
366 a = log1p (y);
367 a = logb (y);
368 a = exp2 (y);
369 a = exp10 (y);
370 a = log2 (y);
371 a = pow (y, y);
372 a = sqrt (y);
373 a = hypot (y, y);
374 a = cbrt (y);
375 a = ceil (y);
376 a = fabs (y);
377 a = floor (y);
378 a = fmod (y, y);
379 a = nearbyint (y);
380 a = round (y);
381 a = roundeven (y);
382 a = trunc (y);
383 a = remquo (y, y, &i);
384 j = lrint (y) + lround (y);
385 k = llrint (y) + llround (y);
386 m = fromfp (y, FP_INT_UPWARD, 6) + fromfpx (y, FP_INT_DOWNWARD, 7);
387 um = (ufromfp (y, FP_INT_TONEAREST, 8)
388 + ufromfpx (y, FP_INT_TOWARDZERO, 9));
389 a = erf (y);
390 a = erfc (y);
391 a = tgamma (y);
392 a = lgamma (y);
393 a = rint (y);
394 a = nextafter (y, y);
395 a = nexttoward (y, y);
396 a = remainder (y, y);
397 a = scalb (y, (const TYPE) (6));
398 k = scalbn (y, 7) + scalbln (y, 10l);
399 i = ilogb (y);
400 j = llogb (y);
401 a = fdim (y, y);
402 a = fmax (y, y);
403 a = fmin (y, y);
404 a = fmaxmag (y, y);
405 a = fminmag (y, y);
406 a = fmaximum (y, y);
407 a = fminimum (y, y);
408 a = fmaximum_num (y, y);
409 a = fminimum_num (y, y);
410 a = fmaximum_mag (y, y);
411 a = fminimum_mag (y, y);
412 a = fmaximum_mag_num (y, y);
413 a = fminimum_mag_num (y, y);
414 a = fma (y, y, y);
415
416 #ifdef TEST_INT
417 a = atan2 (i, y);
418 a = remquo (i, y, &i);
419 a = fma (i, y, i);
420 a = pow (i, y);
421 #endif
422
423 d = cos ((const complex TYPE) z);
424 d = acos ((const complex TYPE) z);
425 d = sin ((const complex TYPE) z);
426 d = asin ((const complex TYPE) z);
427 d = tan ((const complex TYPE) z);
428 d = atan ((const complex TYPE) z);
429 d = cosh ((const complex TYPE) z);
430 d = acosh ((const complex TYPE) z);
431 d = sinh ((const complex TYPE) z);
432 d = asinh ((const complex TYPE) z);
433 d = tanh ((const complex TYPE) z);
434 d = atanh ((const complex TYPE) z);
435 d = exp ((const complex TYPE) z);
436 d = log ((const complex TYPE) z);
437 d = sqrt ((const complex TYPE) z);
438 d = pow ((const complex TYPE) z, (const complex TYPE) z);
439 d = fabs ((const complex TYPE) z);
440 d = carg ((const complex TYPE) z);
441 d = creal ((const complex TYPE) z);
442 d = cimag ((const complex TYPE) z);
443 d = conj ((const complex TYPE) z);
444 d = cproj ((const complex TYPE) z);
445 }
446 }
447 #undef x
448 #undef y
449 #undef z
450
451
452 TYPE
453 (F(cos)) (TYPE x)
454 {
455 ++count;
456 P ();
457 return x;
458 }
459
460 TYPE
461 (F(acos)) (TYPE x)
462 {
463 ++count;
464 P ();
465 return x;
466 }
467
468 TYPE
469 (F(sin)) (TYPE x)
470 {
471 ++count;
472 P ();
473 return x;
474 }
475
476 TYPE
477 (F(asin)) (TYPE x)
478 {
479 ++count;
480 P ();
481 return x;
482 }
483
484 TYPE
485 (F(tan)) (TYPE x)
486 {
487 ++count;
488 P ();
489 return x;
490 }
491
492 TYPE
493 (F(atan)) (TYPE x)
494 {
495 ++count;
496 P ();
497 return x;
498 }
499
500 TYPE
501 (F(atan2)) (TYPE x, TYPE y)
502 {
503 ++count;
504 P ();
505 return x + y;
506 }
507
508 TYPE
509 (F(cosh)) (TYPE x)
510 {
511 ++count;
512 P ();
513 return x;
514 }
515
516 TYPE
517 (F(acosh)) (TYPE x)
518 {
519 ++count;
520 P ();
521 return x;
522 }
523
524 TYPE
525 (F(sinh)) (TYPE x)
526 {
527 ++count;
528 P ();
529 return x;
530 }
531
532 TYPE
533 (F(asinh)) (TYPE x)
534 {
535 ++count;
536 P ();
537 return x;
538 }
539
540 TYPE
541 (F(tanh)) (TYPE x)
542 {
543 ++count;
544 P ();
545 return x;
546 }
547
548 TYPE
549 (F(atanh)) (TYPE x)
550 {
551 ++count;
552 P ();
553 return x;
554 }
555
556 TYPE
557 (F(exp)) (TYPE x)
558 {
559 ++count;
560 P ();
561 return x;
562 }
563
564 TYPE
565 (F(log)) (TYPE x)
566 {
567 ++count;
568 P ();
569 return x;
570 }
571
572 TYPE
573 (F(log10)) (TYPE x)
574 {
575 ++count;
576 P ();
577 return x;
578 }
579
580 TYPE
581 (F(ldexp)) (TYPE x, int y)
582 {
583 ++count;
584 P ();
585 return x + y;
586 }
587
588 TYPE
589 (F(frexp)) (TYPE x, int *y)
590 {
591 ++count;
592 P ();
593 return x + *y;
594 }
595
596 TYPE
597 (F(expm1)) (TYPE x)
598 {
599 ++count;
600 P ();
601 return x;
602 }
603
604 TYPE
605 (F(log1p)) (TYPE x)
606 {
607 ++count;
608 P ();
609 return x;
610 }
611
612 TYPE
613 (F(logb)) (TYPE x)
614 {
615 ++count;
616 P ();
617 return x;
618 }
619
620 TYPE
621 (F(exp10)) (TYPE x)
622 {
623 ++count;
624 P ();
625 return x;
626 }
627
628 TYPE
629 (F(exp2)) (TYPE x)
630 {
631 ++count;
632 P ();
633 return x;
634 }
635
636 TYPE
637 (F(log2)) (TYPE x)
638 {
639 ++count;
640 P ();
641 return x;
642 }
643
644 TYPE
645 (F(pow)) (TYPE x, TYPE y)
646 {
647 ++count;
648 P ();
649 return x + y;
650 }
651
652 TYPE
653 (F(sqrt)) (TYPE x)
654 {
655 ++count;
656 P ();
657 return x;
658 }
659
660 TYPE
661 (F(hypot)) (TYPE x, TYPE y)
662 {
663 ++count;
664 P ();
665 return x + y;
666 }
667
668 TYPE
669 (F(cbrt)) (TYPE x)
670 {
671 ++count;
672 P ();
673 return x;
674 }
675
676 TYPE
677 (F(ceil)) (TYPE x)
678 {
679 ++count;
680 P ();
681 return x;
682 }
683
684 TYPE
685 (F(fabs)) (TYPE x)
686 {
687 ++count;
688 P ();
689 return x;
690 }
691
692 TYPE
693 (F(floor)) (TYPE x)
694 {
695 ++count;
696 P ();
697 return x;
698 }
699
700 TYPE
701 (F(fmod)) (TYPE x, TYPE y)
702 {
703 ++count;
704 P ();
705 return x + y;
706 }
707
708 TYPE
709 (F(nearbyint)) (TYPE x)
710 {
711 ++count;
712 P ();
713 return x;
714 }
715
716 TYPE
717 (F(round)) (TYPE x)
718 {
719 ++count;
720 P ();
721 return x;
722 }
723
724 TYPE
725 (F(roundeven)) (TYPE x)
726 {
727 ++count;
728 P ();
729 return x;
730 }
731
732 TYPE
733 (F(trunc)) (TYPE x)
734 {
735 ++count;
736 P ();
737 return x;
738 }
739
740 TYPE
741 (F(remquo)) (TYPE x, TYPE y, int *i)
742 {
743 ++count;
744 P ();
745 return x + y + *i;
746 }
747
748 long int
749 (F(lrint)) (TYPE x)
750 {
751 ++count;
752 P ();
753 return x;
754 }
755
756 long int
757 (F(lround)) (TYPE x)
758 {
759 ++count;
760 P ();
761 return x;
762 }
763
764 long long int
765 (F(llrint)) (TYPE x)
766 {
767 ++count;
768 P ();
769 return x;
770 }
771
772 long long int
773 (F(llround)) (TYPE x)
774 {
775 ++count;
776 P ();
777 return x;
778 }
779
780 intmax_t
781 (F(fromfp)) (TYPE x, int round, unsigned int width)
782 {
783 ++count;
784 P ();
785 return x;
786 }
787
788 intmax_t
789 (F(fromfpx)) (TYPE x, int round, unsigned int width)
790 {
791 ++count;
792 P ();
793 return x;
794 }
795
796 uintmax_t
797 (F(ufromfp)) (TYPE x, int round, unsigned int width)
798 {
799 ++count;
800 P ();
801 return x;
802 }
803
804 uintmax_t
805 (F(ufromfpx)) (TYPE x, int round, unsigned int width)
806 {
807 ++count;
808 P ();
809 return x;
810 }
811
812 TYPE
813 (F(erf)) (TYPE x)
814 {
815 ++count;
816 P ();
817 return x;
818 }
819
820 TYPE
821 (F(erfc)) (TYPE x)
822 {
823 ++count;
824 P ();
825 return x;
826 }
827
828 TYPE
829 (F(tgamma)) (TYPE x)
830 {
831 ++count;
832 P ();
833 return x;
834 }
835
836 TYPE
837 (F(lgamma)) (TYPE x)
838 {
839 ++count;
840 P ();
841 return x;
842 }
843
844 TYPE
845 (F(rint)) (TYPE x)
846 {
847 ++count;
848 P ();
849 return x;
850 }
851
852 TYPE
853 (F(nextafter)) (TYPE x, TYPE y)
854 {
855 ++count;
856 P ();
857 return x + y;
858 }
859
860 TYPE
861 (F(nextdown)) (TYPE x)
862 {
863 ++count;
864 P ();
865 return x;
866 }
867
868 TYPE
869 (F(nexttoward)) (TYPE x, long double y)
870 {
871 ++count;
872 P ();
873 return x + y;
874 }
875
876 TYPE
877 (F(nextup)) (TYPE x)
878 {
879 ++count;
880 P ();
881 return x;
882 }
883
884 TYPE
885 (F(remainder)) (TYPE x, TYPE y)
886 {
887 ++count;
888 P ();
889 return x + y;
890 }
891
892 TYPE
893 (F(scalb)) (TYPE x, TYPE y)
894 {
895 ++count;
896 P ();
897 return x + y;
898 }
899
900 TYPE
901 (F(scalbn)) (TYPE x, int y)
902 {
903 ++count;
904 P ();
905 return x + y;
906 }
907
908 TYPE
909 (F(scalbln)) (TYPE x, long int y)
910 {
911 ++count;
912 P ();
913 return x + y;
914 }
915
916 int
917 (F(ilogb)) (TYPE x)
918 {
919 ++count;
920 P ();
921 return x;
922 }
923
924 long int
925 (F(llogb)) (TYPE x)
926 {
927 ++count;
928 P ();
929 return x;
930 }
931
932 TYPE
933 (F(fdim)) (TYPE x, TYPE y)
934 {
935 ++count;
936 P ();
937 return x + y;
938 }
939
940 TYPE
941 (F(fmin)) (TYPE x, TYPE y)
942 {
943 ++count;
944 P ();
945 return x + y;
946 }
947
948 TYPE
949 (F(fmax)) (TYPE x, TYPE y)
950 {
951 ++count;
952 P ();
953 return x + y;
954 }
955
956 TYPE
957 (F(fminmag)) (TYPE x, TYPE y)
958 {
959 ++count;
960 P ();
961 return x + y;
962 }
963
964 TYPE
965 (F(fmaxmag)) (TYPE x, TYPE y)
966 {
967 ++count;
968 P ();
969 return x + y;
970 }
971
972 TYPE
973 (F(fminimum)) (TYPE x, TYPE y)
974 {
975 ++count;
976 P ();
977 return x + y;
978 }
979
980 TYPE
981 (F(fmaximum)) (TYPE x, TYPE y)
982 {
983 ++count;
984 P ();
985 return x + y;
986 }
987
988 TYPE
989 (F(fminimum_num)) (TYPE x, TYPE y)
990 {
991 ++count;
992 P ();
993 return x + y;
994 }
995
996 TYPE
997 (F(fmaximum_num)) (TYPE x, TYPE y)
998 {
999 ++count;
1000 P ();
1001 return x + y;
1002 }
1003
1004 TYPE
1005 (F(fminimum_mag)) (TYPE x, TYPE y)
1006 {
1007 ++count;
1008 P ();
1009 return x + y;
1010 }
1011
1012 TYPE
1013 (F(fmaximum_mag)) (TYPE x, TYPE y)
1014 {
1015 ++count;
1016 P ();
1017 return x + y;
1018 }
1019
1020 TYPE
1021 (F(fminimum_mag_num)) (TYPE x, TYPE y)
1022 {
1023 ++count;
1024 P ();
1025 return x + y;
1026 }
1027
1028 TYPE
1029 (F(fmaximum_mag_num)) (TYPE x, TYPE y)
1030 {
1031 ++count;
1032 P ();
1033 return x + y;
1034 }
1035
1036 TYPE
1037 (F(fma)) (TYPE x, TYPE y, TYPE z)
1038 {
1039 ++count;
1040 P ();
1041 return x + y + z;
1042 }
1043
1044 complex TYPE
1045 (F(cacos)) (complex TYPE x)
1046 {
1047 ++ccount;
1048 P ();
1049 return x;
1050 }
1051
1052 complex TYPE
1053 (F(casin)) (complex TYPE x)
1054 {
1055 ++ccount;
1056 P ();
1057 return x;
1058 }
1059
1060 complex TYPE
1061 (F(catan)) (complex TYPE x)
1062 {
1063 ++ccount;
1064 P ();
1065 return x;
1066 }
1067
1068 complex TYPE
1069 (F(ccos)) (complex TYPE x)
1070 {
1071 ++ccount;
1072 P ();
1073 return x;
1074 }
1075
1076 complex TYPE
1077 (F(csin)) (complex TYPE x)
1078 {
1079 ++ccount;
1080 P ();
1081 return x;
1082 }
1083
1084 complex TYPE
1085 (F(ctan)) (complex TYPE x)
1086 {
1087 ++ccount;
1088 P ();
1089 return x;
1090 }
1091
1092 complex TYPE
1093 (F(cacosh)) (complex TYPE x)
1094 {
1095 ++ccount;
1096 P ();
1097 return x;
1098 }
1099
1100 complex TYPE
1101 (F(casinh)) (complex TYPE x)
1102 {
1103 ++ccount;
1104 P ();
1105 return x;
1106 }
1107
1108 complex TYPE
1109 (F(catanh)) (complex TYPE x)
1110 {
1111 ++ccount;
1112 P ();
1113 return x;
1114 }
1115
1116 complex TYPE
1117 (F(ccosh)) (complex TYPE x)
1118 {
1119 ++ccount;
1120 P ();
1121 return x;
1122 }
1123
1124 complex TYPE
1125 (F(csinh)) (complex TYPE x)
1126 {
1127 ++ccount;
1128 P ();
1129 return x;
1130 }
1131
1132 complex TYPE
1133 (F(ctanh)) (complex TYPE x)
1134 {
1135 ++ccount;
1136 P ();
1137 return x;
1138 }
1139
1140 complex TYPE
1141 (F(cexp)) (complex TYPE x)
1142 {
1143 ++ccount;
1144 P ();
1145 return x;
1146 }
1147
1148 complex TYPE
1149 (F(clog)) (complex TYPE x)
1150 {
1151 ++ccount;
1152 P ();
1153 return x;
1154 }
1155
1156 complex TYPE
1157 (F(csqrt)) (complex TYPE x)
1158 {
1159 ++ccount;
1160 P ();
1161 return x;
1162 }
1163
1164 complex TYPE
1165 (F(cpow)) (complex TYPE x, complex TYPE y)
1166 {
1167 ++ccount;
1168 P ();
1169 return x + y;
1170 }
1171
1172 TYPE
1173 (F(cabs)) (complex TYPE x)
1174 {
1175 ++ccount;
1176 P ();
1177 return x;
1178 }
1179
1180 TYPE
1181 (F(carg)) (complex TYPE x)
1182 {
1183 ++ccount;
1184 P ();
1185 return x;
1186 }
1187
1188 TYPE
1189 (F(creal)) (complex TYPE x)
1190 {
1191 ++ccount;
1192 P ();
1193 return __real__ x;
1194 }
1195
1196 TYPE
1197 (F(cimag)) (complex TYPE x)
1198 {
1199 ++ccount;
1200 P ();
1201 return __imag__ x;
1202 }
1203
1204 complex TYPE
1205 (F(conj)) (complex TYPE x)
1206 {
1207 ++ccount;
1208 P ();
1209 return x;
1210 }
1211
1212 complex TYPE
1213 (F(cproj)) (complex TYPE x)
1214 {
1215 ++ccount;
1216 P ();
1217 return x;
1218 }
1219
1220 #undef F
1221 #undef TYPE
1222 #undef count
1223 #undef ccount
1224 #undef TEST_INT
1225 #endif