1//===----------------------------------------------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is dual licensed under the MIT and the University of Illinois Open
6// Source Licenses. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10// <cmath>
11
12#include <cmath>
13#include <limits>
14#include <type_traits>
15#include <cassert>
16
17#include "test_macros.h"
18#include "hexfloat.h"
19
20// convertible to int/float/double/etc
21template <class T, int N=0>
22struct Value {
23    operator T () { return T(N); }
24};
25
26// See PR21083
27// Ambiguous is a user-defined type that defines its own overloads of cmath
28// functions. When the std overloads are candidates too (by using or adl),
29// they should not interfere.
30struct Ambiguous : std::true_type { // ADL
31    operator float () { return 0.f; }
32    operator double () { return 0.; }
33};
34Ambiguous abs(Ambiguous){ return Ambiguous(); }
35Ambiguous acos(Ambiguous){ return Ambiguous(); }
36Ambiguous asin(Ambiguous){ return Ambiguous(); }
37Ambiguous atan(Ambiguous){ return Ambiguous(); }
38Ambiguous atan2(Ambiguous, Ambiguous){ return Ambiguous(); }
39Ambiguous ceil(Ambiguous){ return Ambiguous(); }
40Ambiguous cos(Ambiguous){ return Ambiguous(); }
41Ambiguous cosh(Ambiguous){ return Ambiguous(); }
42Ambiguous exp(Ambiguous){ return Ambiguous(); }
43Ambiguous fabs(Ambiguous){ return Ambiguous(); }
44Ambiguous floor(Ambiguous){ return Ambiguous(); }
45Ambiguous fmod(Ambiguous, Ambiguous){ return Ambiguous(); }
46Ambiguous frexp(Ambiguous, int*){ return Ambiguous(); }
47Ambiguous ldexp(Ambiguous, int){ return Ambiguous(); }
48Ambiguous log(Ambiguous){ return Ambiguous(); }
49Ambiguous log10(Ambiguous){ return Ambiguous(); }
50Ambiguous modf(Ambiguous, Ambiguous*){ return Ambiguous(); }
51Ambiguous pow(Ambiguous, Ambiguous){ return Ambiguous(); }
52Ambiguous sin(Ambiguous){ return Ambiguous(); }
53Ambiguous sinh(Ambiguous){ return Ambiguous(); }
54Ambiguous sqrt(Ambiguous){ return Ambiguous(); }
55Ambiguous tan(Ambiguous){ return Ambiguous(); }
56Ambiguous tanh(Ambiguous){ return Ambiguous(); }
57Ambiguous signbit(Ambiguous){ return Ambiguous(); }
58Ambiguous fpclassify(Ambiguous){ return Ambiguous(); }
59Ambiguous isfinite(Ambiguous){ return Ambiguous(); }
60Ambiguous isnormal(Ambiguous){ return Ambiguous(); }
61Ambiguous isgreater(Ambiguous, Ambiguous){ return Ambiguous(); }
62Ambiguous isgreaterequal(Ambiguous, Ambiguous){ return Ambiguous(); }
63Ambiguous isless(Ambiguous, Ambiguous){ return Ambiguous(); }
64Ambiguous islessequal(Ambiguous, Ambiguous){ return Ambiguous(); }
65Ambiguous islessgreater(Ambiguous, Ambiguous){ return Ambiguous(); }
66Ambiguous isunordered(Ambiguous, Ambiguous){ return Ambiguous(); }
67Ambiguous acosh(Ambiguous){ return Ambiguous(); }
68Ambiguous asinh(Ambiguous){ return Ambiguous(); }
69Ambiguous atanh(Ambiguous){ return Ambiguous(); }
70Ambiguous cbrt(Ambiguous){ return Ambiguous(); }
71Ambiguous copysign(Ambiguous, Ambiguous){ return Ambiguous(); }
72Ambiguous erf(Ambiguous){ return Ambiguous(); }
73Ambiguous erfc(Ambiguous){ return Ambiguous(); }
74Ambiguous exp2(Ambiguous){ return Ambiguous(); }
75Ambiguous expm1(Ambiguous){ return Ambiguous(); }
76Ambiguous fdim(Ambiguous, Ambiguous){ return Ambiguous(); }
77Ambiguous fma(Ambiguous, Ambiguous, Ambiguous){ return Ambiguous(); }
78Ambiguous fmax(Ambiguous, Ambiguous){ return Ambiguous(); }
79Ambiguous fmin(Ambiguous, Ambiguous){ return Ambiguous(); }
80Ambiguous hypot(Ambiguous, Ambiguous){ return Ambiguous(); }
81Ambiguous hypot(Ambiguous, Ambiguous, Ambiguous){ return Ambiguous(); }
82Ambiguous ilogb(Ambiguous){ return Ambiguous(); }
83Ambiguous lgamma(Ambiguous){ return Ambiguous(); }
84Ambiguous llrint(Ambiguous){ return Ambiguous(); }
85Ambiguous llround(Ambiguous){ return Ambiguous(); }
86Ambiguous log1p(Ambiguous){ return Ambiguous(); }
87Ambiguous log2(Ambiguous){ return Ambiguous(); }
88Ambiguous logb(Ambiguous){ return Ambiguous(); }
89Ambiguous lrint(Ambiguous){ return Ambiguous(); }
90Ambiguous lround(Ambiguous){ return Ambiguous(); }
91Ambiguous nearbyint(Ambiguous){ return Ambiguous(); }
92Ambiguous nextafter(Ambiguous, Ambiguous){ return Ambiguous(); }
93Ambiguous nexttoward(Ambiguous, Ambiguous){ return Ambiguous(); }
94Ambiguous remainder(Ambiguous, Ambiguous){ return Ambiguous(); }
95Ambiguous remquo(Ambiguous, Ambiguous, int*){ return Ambiguous(); }
96Ambiguous rint(Ambiguous){ return Ambiguous(); }
97Ambiguous round(Ambiguous){ return Ambiguous(); }
98Ambiguous scalbln(Ambiguous, Ambiguous){ return Ambiguous(); }
99Ambiguous scalbn(Ambiguous, Ambiguous){ return Ambiguous(); }
100Ambiguous tgamma(Ambiguous){ return Ambiguous(); }
101Ambiguous trunc(Ambiguous){ return Ambiguous(); }
102
103void test_abs()
104{
105    static_assert((std::is_same<decltype(std::abs((float)0)), float>::value), "");
106    static_assert((std::is_same<decltype(std::abs((double)0)), double>::value), "");
107    static_assert((std::is_same<decltype(std::abs((long double)0)), long double>::value), "");
108    static_assert((std::is_same<decltype(abs(Ambiguous())), Ambiguous>::value), "");
109    assert(std::abs(-1.) == 1);
110}
111
112void test_acos()
113{
114    static_assert((std::is_same<decltype(std::acos((float)0)), float>::value), "");
115    static_assert((std::is_same<decltype(std::acos((bool)0)), double>::value), "");
116    static_assert((std::is_same<decltype(std::acos((unsigned short)0)), double>::value), "");
117    static_assert((std::is_same<decltype(std::acos((int)0)), double>::value), "");
118    static_assert((std::is_same<decltype(std::acos((unsigned int)0)), double>::value), "");
119    static_assert((std::is_same<decltype(std::acos((long)0)), double>::value), "");
120    static_assert((std::is_same<decltype(std::acos((unsigned long)0)), double>::value), "");
121    static_assert((std::is_same<decltype(std::acos((long long)0)), double>::value), "");
122    static_assert((std::is_same<decltype(std::acos((unsigned long long)0)), double>::value), "");
123    static_assert((std::is_same<decltype(std::acos((double)0)), double>::value), "");
124    static_assert((std::is_same<decltype(std::acos((long double)0)), long double>::value), "");
125    static_assert((std::is_same<decltype(std::acosf(0)), float>::value), "");
126    static_assert((std::is_same<decltype(std::acosl(0)), long double>::value), "");
127    static_assert((std::is_same<decltype(acos(Ambiguous())), Ambiguous>::value), "");
128    assert(std::acos(1) == 0);
129}
130
131void test_asin()
132{
133    static_assert((std::is_same<decltype(std::asin((float)0)), float>::value), "");
134    static_assert((std::is_same<decltype(std::asin((bool)0)), double>::value), "");
135    static_assert((std::is_same<decltype(std::asin((unsigned short)0)), double>::value), "");
136    static_assert((std::is_same<decltype(std::asin((int)0)), double>::value), "");
137    static_assert((std::is_same<decltype(std::asin((unsigned int)0)), double>::value), "");
138    static_assert((std::is_same<decltype(std::asin((long)0)), double>::value), "");
139    static_assert((std::is_same<decltype(std::asin((unsigned long)0)), double>::value), "");
140    static_assert((std::is_same<decltype(std::asin((long long)0)), double>::value), "");
141    static_assert((std::is_same<decltype(std::asin((unsigned long long)0)), double>::value), "");
142    static_assert((std::is_same<decltype(std::asin((double)0)), double>::value), "");
143    static_assert((std::is_same<decltype(std::asin((long double)0)), long double>::value), "");
144    static_assert((std::is_same<decltype(std::asinf(0)), float>::value), "");
145    static_assert((std::is_same<decltype(std::asinl(0)), long double>::value), "");
146    static_assert((std::is_same<decltype(asin(Ambiguous())), Ambiguous>::value), "");
147    assert(std::asin(0) == 0);
148}
149
150void test_atan()
151{
152    static_assert((std::is_same<decltype(std::atan((float)0)), float>::value), "");
153    static_assert((std::is_same<decltype(std::atan((bool)0)), double>::value), "");
154    static_assert((std::is_same<decltype(std::atan((unsigned short)0)), double>::value), "");
155    static_assert((std::is_same<decltype(std::atan((int)0)), double>::value), "");
156    static_assert((std::is_same<decltype(std::atan((unsigned int)0)), double>::value), "");
157    static_assert((std::is_same<decltype(std::atan((long)0)), double>::value), "");
158    static_assert((std::is_same<decltype(std::atan((unsigned long)0)), double>::value), "");
159    static_assert((std::is_same<decltype(std::atan((long long)0)), double>::value), "");
160    static_assert((std::is_same<decltype(std::atan((unsigned long long)0)), double>::value), "");
161    static_assert((std::is_same<decltype(std::atan((double)0)), double>::value), "");
162    static_assert((std::is_same<decltype(std::atan((long double)0)), long double>::value), "");
163    static_assert((std::is_same<decltype(std::atanf(0)), float>::value), "");
164    static_assert((std::is_same<decltype(std::atanl(0)), long double>::value), "");
165    static_assert((std::is_same<decltype(atan(Ambiguous())), Ambiguous>::value), "");
166    assert(std::atan(0) == 0);
167}
168
169void test_atan2()
170{
171    static_assert((std::is_same<decltype(std::atan2((float)0, (float)0)), float>::value), "");
172    static_assert((std::is_same<decltype(std::atan2((bool)0, (float)0)), double>::value), "");
173    static_assert((std::is_same<decltype(std::atan2((unsigned short)0, (double)0)), double>::value), "");
174    static_assert((std::is_same<decltype(std::atan2((int)0, (long double)0)), long double>::value), "");
175    static_assert((std::is_same<decltype(std::atan2((float)0, (unsigned int)0)), double>::value), "");
176    static_assert((std::is_same<decltype(std::atan2((double)0, (long)0)), double>::value), "");
177    static_assert((std::is_same<decltype(std::atan2((long double)0, (unsigned long)0)), long double>::value), "");
178    static_assert((std::is_same<decltype(std::atan2((int)0, (long long)0)), double>::value), "");
179    static_assert((std::is_same<decltype(std::atan2((int)0, (unsigned long long)0)), double>::value), "");
180    static_assert((std::is_same<decltype(std::atan2((double)0, (double)0)), double>::value), "");
181    static_assert((std::is_same<decltype(std::atan2((long double)0, (long double)0)), long double>::value), "");
182    static_assert((std::is_same<decltype(std::atan2((float)0, (double)0)), double>::value), "");
183    static_assert((std::is_same<decltype(std::atan2((float)0, (long double)0)), long double>::value), "");
184    static_assert((std::is_same<decltype(std::atan2((double)0, (long double)0)), long double>::value), "");
185    static_assert((std::is_same<decltype(std::atan2f(0,0)), float>::value), "");
186    static_assert((std::is_same<decltype(std::atan2l(0,0)), long double>::value), "");
187    static_assert((std::is_same<decltype(std::atan2((int)0, (int)0)), double>::value), "");
188    static_assert((std::is_same<decltype(atan2(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
189    assert(std::atan2(0,1) == 0);
190}
191
192void test_ceil()
193{
194    static_assert((std::is_same<decltype(std::ceil((float)0)), float>::value), "");
195    static_assert((std::is_same<decltype(std::ceil((bool)0)), double>::value), "");
196    static_assert((std::is_same<decltype(std::ceil((unsigned short)0)), double>::value), "");
197    static_assert((std::is_same<decltype(std::ceil((int)0)), double>::value), "");
198    static_assert((std::is_same<decltype(std::ceil((unsigned int)0)), double>::value), "");
199    static_assert((std::is_same<decltype(std::ceil((long)0)), double>::value), "");
200    static_assert((std::is_same<decltype(std::ceil((unsigned long)0)), double>::value), "");
201    static_assert((std::is_same<decltype(std::ceil((long long)0)), double>::value), "");
202    static_assert((std::is_same<decltype(std::ceil((unsigned long long)0)), double>::value), "");
203    static_assert((std::is_same<decltype(std::ceil((double)0)), double>::value), "");
204    static_assert((std::is_same<decltype(std::ceil((long double)0)), long double>::value), "");
205    static_assert((std::is_same<decltype(std::ceilf(0)), float>::value), "");
206    static_assert((std::is_same<decltype(std::ceill(0)), long double>::value), "");
207    static_assert((std::is_same<decltype(ceil(Ambiguous())), Ambiguous>::value), "");
208    assert(std::ceil(0) == 0);
209}
210
211void test_cos()
212{
213    static_assert((std::is_same<decltype(std::cos((float)0)), float>::value), "");
214    static_assert((std::is_same<decltype(std::cos((bool)0)), double>::value), "");
215    static_assert((std::is_same<decltype(std::cos((unsigned short)0)), double>::value), "");
216    static_assert((std::is_same<decltype(std::cos((int)0)), double>::value), "");
217    static_assert((std::is_same<decltype(std::cos((unsigned int)0)), double>::value), "");
218    static_assert((std::is_same<decltype(std::cos((long)0)), double>::value), "");
219    static_assert((std::is_same<decltype(std::cos((unsigned long)0)), double>::value), "");
220    static_assert((std::is_same<decltype(std::cos((long long)0)), double>::value), "");
221    static_assert((std::is_same<decltype(std::cos((unsigned long long)0)), double>::value), "");
222    static_assert((std::is_same<decltype(std::cos((double)0)), double>::value), "");
223    static_assert((std::is_same<decltype(std::cos((long double)0)), long double>::value), "");
224    static_assert((std::is_same<decltype(std::cosf(0)), float>::value), "");
225    static_assert((std::is_same<decltype(std::cosl(0)), long double>::value), "");
226    static_assert((std::is_same<decltype(cos(Ambiguous())), Ambiguous>::value), "");
227    assert(std::cos(0) == 1);
228}
229
230void test_cosh()
231{
232    static_assert((std::is_same<decltype(std::cosh((float)0)), float>::value), "");
233    static_assert((std::is_same<decltype(std::cosh((bool)0)), double>::value), "");
234    static_assert((std::is_same<decltype(std::cosh((unsigned short)0)), double>::value), "");
235    static_assert((std::is_same<decltype(std::cosh((int)0)), double>::value), "");
236    static_assert((std::is_same<decltype(std::cosh((unsigned int)0)), double>::value), "");
237    static_assert((std::is_same<decltype(std::cosh((long)0)), double>::value), "");
238    static_assert((std::is_same<decltype(std::cosh((unsigned long)0)), double>::value), "");
239    static_assert((std::is_same<decltype(std::cosh((long long)0)), double>::value), "");
240    static_assert((std::is_same<decltype(std::cosh((unsigned long long)0)), double>::value), "");
241    static_assert((std::is_same<decltype(std::cosh((double)0)), double>::value), "");
242    static_assert((std::is_same<decltype(std::cosh((long double)0)), long double>::value), "");
243    static_assert((std::is_same<decltype(std::coshf(0)), float>::value), "");
244    static_assert((std::is_same<decltype(std::coshl(0)), long double>::value), "");
245    static_assert((std::is_same<decltype(cosh(Ambiguous())), Ambiguous>::value), "");
246    assert(std::cosh(0) == 1);
247}
248
249void test_exp()
250{
251    static_assert((std::is_same<decltype(std::exp((float)0)), float>::value), "");
252    static_assert((std::is_same<decltype(std::exp((bool)0)), double>::value), "");
253    static_assert((std::is_same<decltype(std::exp((unsigned short)0)), double>::value), "");
254    static_assert((std::is_same<decltype(std::exp((int)0)), double>::value), "");
255    static_assert((std::is_same<decltype(std::exp((unsigned int)0)), double>::value), "");
256    static_assert((std::is_same<decltype(std::exp((long)0)), double>::value), "");
257    static_assert((std::is_same<decltype(std::exp((unsigned long)0)), double>::value), "");
258    static_assert((std::is_same<decltype(std::exp((long long)0)), double>::value), "");
259    static_assert((std::is_same<decltype(std::exp((unsigned long long)0)), double>::value), "");
260    static_assert((std::is_same<decltype(std::exp((double)0)), double>::value), "");
261    static_assert((std::is_same<decltype(std::exp((long double)0)), long double>::value), "");
262    static_assert((std::is_same<decltype(std::expf(0)), float>::value), "");
263    static_assert((std::is_same<decltype(std::expl(0)), long double>::value), "");
264    static_assert((std::is_same<decltype(exp(Ambiguous())), Ambiguous>::value), "");
265    assert(std::exp(0) == 1);
266}
267
268void test_fabs()
269{
270    static_assert((std::is_same<decltype(std::fabs((float)0)), float>::value), "");
271    static_assert((std::is_same<decltype(std::fabs((bool)0)), double>::value), "");
272    static_assert((std::is_same<decltype(std::fabs((unsigned short)0)), double>::value), "");
273    static_assert((std::is_same<decltype(std::fabs((int)0)), double>::value), "");
274    static_assert((std::is_same<decltype(std::fabs((unsigned int)0)), double>::value), "");
275    static_assert((std::is_same<decltype(std::fabs((long)0)), double>::value), "");
276    static_assert((std::is_same<decltype(std::fabs((unsigned long)0)), double>::value), "");
277    static_assert((std::is_same<decltype(std::fabs((long long)0)), double>::value), "");
278    static_assert((std::is_same<decltype(std::fabs((unsigned long long)0)), double>::value), "");
279    static_assert((std::is_same<decltype(std::fabs((double)0)), double>::value), "");
280    static_assert((std::is_same<decltype(std::fabs((long double)0)), long double>::value), "");
281    static_assert((std::is_same<decltype(std::fabsf(0.0f)), float>::value), "");
282    static_assert((std::is_same<decltype(std::fabsl(0.0L)), long double>::value), "");
283    static_assert((std::is_same<decltype(fabs(Ambiguous())), Ambiguous>::value), "");
284    assert(std::fabs(-1) == 1);
285}
286
287void test_floor()
288{
289    static_assert((std::is_same<decltype(std::floor((float)0)), float>::value), "");
290    static_assert((std::is_same<decltype(std::floor((bool)0)), double>::value), "");
291    static_assert((std::is_same<decltype(std::floor((unsigned short)0)), double>::value), "");
292    static_assert((std::is_same<decltype(std::floor((int)0)), double>::value), "");
293    static_assert((std::is_same<decltype(std::floor((unsigned int)0)), double>::value), "");
294    static_assert((std::is_same<decltype(std::floor((long)0)), double>::value), "");
295    static_assert((std::is_same<decltype(std::floor((unsigned long)0)), double>::value), "");
296    static_assert((std::is_same<decltype(std::floor((long long)0)), double>::value), "");
297    static_assert((std::is_same<decltype(std::floor((unsigned long long)0)), double>::value), "");
298    static_assert((std::is_same<decltype(std::floor((double)0)), double>::value), "");
299    static_assert((std::is_same<decltype(std::floor((long double)0)), long double>::value), "");
300    static_assert((std::is_same<decltype(std::floorf(0)), float>::value), "");
301    static_assert((std::is_same<decltype(std::floorl(0)), long double>::value), "");
302    static_assert((std::is_same<decltype(floor(Ambiguous())), Ambiguous>::value), "");
303    assert(std::floor(1) == 1);
304}
305
306void test_fmod()
307{
308    static_assert((std::is_same<decltype(std::fmod((float)0, (float)0)), float>::value), "");
309    static_assert((std::is_same<decltype(std::fmod((bool)0, (float)0)), double>::value), "");
310    static_assert((std::is_same<decltype(std::fmod((unsigned short)0, (double)0)), double>::value), "");
311    static_assert((std::is_same<decltype(std::fmod((int)0, (long double)0)), long double>::value), "");
312    static_assert((std::is_same<decltype(std::fmod((float)0, (unsigned int)0)), double>::value), "");
313    static_assert((std::is_same<decltype(std::fmod((double)0, (long)0)), double>::value), "");
314    static_assert((std::is_same<decltype(std::fmod((long double)0, (unsigned long)0)), long double>::value), "");
315    static_assert((std::is_same<decltype(std::fmod((int)0, (long long)0)), double>::value), "");
316    static_assert((std::is_same<decltype(std::fmod((int)0, (unsigned long long)0)), double>::value), "");
317    static_assert((std::is_same<decltype(std::fmod((double)0, (double)0)), double>::value), "");
318    static_assert((std::is_same<decltype(std::fmod((long double)0, (long double)0)), long double>::value), "");
319    static_assert((std::is_same<decltype(std::fmod((float)0, (double)0)), double>::value), "");
320    static_assert((std::is_same<decltype(std::fmod((float)0, (long double)0)), long double>::value), "");
321    static_assert((std::is_same<decltype(std::fmod((double)0, (long double)0)), long double>::value), "");
322    static_assert((std::is_same<decltype(std::fmodf(0,0)), float>::value), "");
323    static_assert((std::is_same<decltype(std::fmodl(0,0)), long double>::value), "");
324    static_assert((std::is_same<decltype(std::fmod((int)0, (int)0)), double>::value), "");
325    static_assert((std::is_same<decltype(fmod(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
326    assert(std::fmod(1.5,1) == .5);
327}
328
329void test_frexp()
330{
331    int ip;
332    static_assert((std::is_same<decltype(std::frexp((float)0, &ip)), float>::value), "");
333    static_assert((std::is_same<decltype(std::frexp((bool)0, &ip)), double>::value), "");
334    static_assert((std::is_same<decltype(std::frexp((unsigned short)0, &ip)), double>::value), "");
335    static_assert((std::is_same<decltype(std::frexp((int)0, &ip)), double>::value), "");
336    static_assert((std::is_same<decltype(std::frexp((unsigned int)0, &ip)), double>::value), "");
337    static_assert((std::is_same<decltype(std::frexp((long)0, &ip)), double>::value), "");
338    static_assert((std::is_same<decltype(std::frexp((unsigned long)0, &ip)), double>::value), "");
339    static_assert((std::is_same<decltype(std::frexp((long long)0, &ip)), double>::value), "");
340    static_assert((std::is_same<decltype(std::frexp((unsigned long long)0, &ip)), double>::value), "");
341    static_assert((std::is_same<decltype(std::frexp((double)0, &ip)), double>::value), "");
342    static_assert((std::is_same<decltype(std::frexp((long double)0, &ip)), long double>::value), "");
343    static_assert((std::is_same<decltype(std::frexpf(0, &ip)), float>::value), "");
344    static_assert((std::is_same<decltype(std::frexpl(0, &ip)), long double>::value), "");
345    static_assert((std::is_same<decltype(frexp(Ambiguous(), &ip)), Ambiguous>::value), "");
346    assert(std::frexp(0, &ip) == 0);
347}
348
349void test_ldexp()
350{
351    int ip = 1;
352    static_assert((std::is_same<decltype(std::ldexp((float)0, ip)), float>::value), "");
353    static_assert((std::is_same<decltype(std::ldexp((bool)0, ip)), double>::value), "");
354    static_assert((std::is_same<decltype(std::ldexp((unsigned short)0, ip)), double>::value), "");
355    static_assert((std::is_same<decltype(std::ldexp((int)0, ip)), double>::value), "");
356    static_assert((std::is_same<decltype(std::ldexp((unsigned int)0, ip)), double>::value), "");
357    static_assert((std::is_same<decltype(std::ldexp((long)0, ip)), double>::value), "");
358    static_assert((std::is_same<decltype(std::ldexp((unsigned long)0, ip)), double>::value), "");
359    static_assert((std::is_same<decltype(std::ldexp((long long)0, ip)), double>::value), "");
360    static_assert((std::is_same<decltype(std::ldexp((unsigned long long)0, ip)), double>::value), "");
361    static_assert((std::is_same<decltype(std::ldexp((double)0, ip)), double>::value), "");
362    static_assert((std::is_same<decltype(std::ldexp((long double)0, ip)), long double>::value), "");
363    static_assert((std::is_same<decltype(std::ldexpf(0, ip)), float>::value), "");
364    static_assert((std::is_same<decltype(std::ldexpl(0, ip)), long double>::value), "");
365    static_assert((std::is_same<decltype(ldexp(Ambiguous(), ip)), Ambiguous>::value), "");
366    assert(std::ldexp(1, ip) == 2);
367}
368
369void test_log()
370{
371    static_assert((std::is_same<decltype(std::log((float)0)), float>::value), "");
372    static_assert((std::is_same<decltype(std::log((bool)0)), double>::value), "");
373    static_assert((std::is_same<decltype(std::log((unsigned short)0)), double>::value), "");
374    static_assert((std::is_same<decltype(std::log((int)0)), double>::value), "");
375    static_assert((std::is_same<decltype(std::log((unsigned int)0)), double>::value), "");
376    static_assert((std::is_same<decltype(std::log((long)0)), double>::value), "");
377    static_assert((std::is_same<decltype(std::log((unsigned long)0)), double>::value), "");
378    static_assert((std::is_same<decltype(std::log((long long)0)), double>::value), "");
379    static_assert((std::is_same<decltype(std::log((unsigned long long)0)), double>::value), "");
380    static_assert((std::is_same<decltype(std::log((double)0)), double>::value), "");
381    static_assert((std::is_same<decltype(std::log((long double)0)), long double>::value), "");
382    static_assert((std::is_same<decltype(std::logf(0)), float>::value), "");
383    static_assert((std::is_same<decltype(std::logl(0)), long double>::value), "");
384    static_assert((std::is_same<decltype(log(Ambiguous())), Ambiguous>::value), "");
385    assert(std::log(1) == 0);
386}
387
388void test_log10()
389{
390    static_assert((std::is_same<decltype(std::log10((float)0)), float>::value), "");
391    static_assert((std::is_same<decltype(std::log10((bool)0)), double>::value), "");
392    static_assert((std::is_same<decltype(std::log10((unsigned short)0)), double>::value), "");
393    static_assert((std::is_same<decltype(std::log10((int)0)), double>::value), "");
394    static_assert((std::is_same<decltype(std::log10((unsigned int)0)), double>::value), "");
395    static_assert((std::is_same<decltype(std::log10((long)0)), double>::value), "");
396    static_assert((std::is_same<decltype(std::log10((unsigned long)0)), double>::value), "");
397    static_assert((std::is_same<decltype(std::log10((long long)0)), double>::value), "");
398    static_assert((std::is_same<decltype(std::log10((unsigned long long)0)), double>::value), "");
399    static_assert((std::is_same<decltype(std::log10((double)0)), double>::value), "");
400    static_assert((std::is_same<decltype(std::log10((long double)0)), long double>::value), "");
401    static_assert((std::is_same<decltype(std::log10f(0)), float>::value), "");
402    static_assert((std::is_same<decltype(std::log10l(0)), long double>::value), "");
403    static_assert((std::is_same<decltype(log10(Ambiguous())), Ambiguous>::value), "");
404    assert(std::log10(1) == 0);
405}
406
407void test_modf()
408{
409    static_assert((std::is_same<decltype(std::modf((float)0, (float*)0)), float>::value), "");
410    static_assert((std::is_same<decltype(std::modf((double)0, (double*)0)), double>::value), "");
411    static_assert((std::is_same<decltype(std::modf((long double)0, (long double*)0)), long double>::value), "");
412    static_assert((std::is_same<decltype(std::modff(0, (float*)0)), float>::value), "");
413    static_assert((std::is_same<decltype(std::modfl(0, (long double*)0)), long double>::value), "");
414    static_assert((std::is_same<decltype(modf(Ambiguous(), (Ambiguous*)0)), Ambiguous>::value), "");
415    double i;
416    assert(std::modf(1., &i) == 0);
417}
418
419void test_pow()
420{
421    static_assert((std::is_same<decltype(std::pow((float)0, (float)0)), float>::value), "");
422    static_assert((std::is_same<decltype(std::pow((bool)0, (float)0)), double>::value), "");
423    static_assert((std::is_same<decltype(std::pow((unsigned short)0, (double)0)), double>::value), "");
424    static_assert((std::is_same<decltype(std::pow((int)0, (long double)0)), long double>::value), "");
425    static_assert((std::is_same<decltype(std::pow((float)0, (unsigned int)0)), double>::value), "");
426    static_assert((std::is_same<decltype(std::pow((double)0, (long)0)), double>::value), "");
427    static_assert((std::is_same<decltype(std::pow((long double)0, (unsigned long)0)), long double>::value), "");
428    static_assert((std::is_same<decltype(std::pow((int)0, (long long)0)), double>::value), "");
429    static_assert((std::is_same<decltype(std::pow((int)0, (unsigned long long)0)), double>::value), "");
430    static_assert((std::is_same<decltype(std::pow((double)0, (double)0)), double>::value), "");
431    static_assert((std::is_same<decltype(std::pow((long double)0, (long double)0)), long double>::value), "");
432    static_assert((std::is_same<decltype(std::pow((float)0, (double)0)), double>::value), "");
433    static_assert((std::is_same<decltype(std::pow((float)0, (long double)0)), long double>::value), "");
434    static_assert((std::is_same<decltype(std::pow((double)0, (long double)0)), long double>::value), "");
435    static_assert((std::is_same<decltype(std::powf(0,0)), float>::value), "");
436    static_assert((std::is_same<decltype(std::powl(0,0)), long double>::value), "");
437    static_assert((std::is_same<decltype(std::pow((int)0, (int)0)), double>::value), "");
438//     static_assert((std::is_same<decltype(std::pow(Value<int>(), (int)0)), double>::value), "");
439//     static_assert((std::is_same<decltype(std::pow(Value<long double>(), (float)0)), long double>::value), "");
440//     static_assert((std::is_same<decltype(std::pow((float) 0, Value<float>())), float>::value), "");
441    static_assert((std::is_same<decltype(pow(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
442    assert(std::pow(1,1) == 1);
443//     assert(std::pow(Value<int,1>(), Value<float,1>())  == 1);
444//     assert(std::pow(1.0f, Value<double,1>()) == 1);
445//     assert(std::pow(1.0, Value<int,1>()) == 1);
446//     assert(std::pow(Value<long double,1>(), 1LL) == 1);
447}
448
449void test_sin()
450{
451    static_assert((std::is_same<decltype(std::sin((float)0)), float>::value), "");
452    static_assert((std::is_same<decltype(std::sin((bool)0)), double>::value), "");
453    static_assert((std::is_same<decltype(std::sin((unsigned short)0)), double>::value), "");
454    static_assert((std::is_same<decltype(std::sin((int)0)), double>::value), "");
455    static_assert((std::is_same<decltype(std::sin((unsigned int)0)), double>::value), "");
456    static_assert((std::is_same<decltype(std::sin((long)0)), double>::value), "");
457    static_assert((std::is_same<decltype(std::sin((unsigned long)0)), double>::value), "");
458    static_assert((std::is_same<decltype(std::sin((long long)0)), double>::value), "");
459    static_assert((std::is_same<decltype(std::sin((unsigned long long)0)), double>::value), "");
460    static_assert((std::is_same<decltype(std::sin((double)0)), double>::value), "");
461    static_assert((std::is_same<decltype(std::sin((long double)0)), long double>::value), "");
462    static_assert((std::is_same<decltype(std::sinf(0)), float>::value), "");
463    static_assert((std::is_same<decltype(std::sinl(0)), long double>::value), "");
464    static_assert((std::is_same<decltype(sin(Ambiguous())), Ambiguous>::value), "");
465    assert(std::sin(0) == 0);
466}
467
468void test_sinh()
469{
470    static_assert((std::is_same<decltype(std::sinh((float)0)), float>::value), "");
471    static_assert((std::is_same<decltype(std::sinh((bool)0)), double>::value), "");
472    static_assert((std::is_same<decltype(std::sinh((unsigned short)0)), double>::value), "");
473    static_assert((std::is_same<decltype(std::sinh((int)0)), double>::value), "");
474    static_assert((std::is_same<decltype(std::sinh((unsigned int)0)), double>::value), "");
475    static_assert((std::is_same<decltype(std::sinh((long)0)), double>::value), "");
476    static_assert((std::is_same<decltype(std::sinh((unsigned long)0)), double>::value), "");
477    static_assert((std::is_same<decltype(std::sinh((long long)0)), double>::value), "");
478    static_assert((std::is_same<decltype(std::sinh((unsigned long long)0)), double>::value), "");
479    static_assert((std::is_same<decltype(std::sinh((double)0)), double>::value), "");
480    static_assert((std::is_same<decltype(std::sinh((long double)0)), long double>::value), "");
481    static_assert((std::is_same<decltype(std::sinhf(0)), float>::value), "");
482    static_assert((std::is_same<decltype(std::sinhl(0)), long double>::value), "");
483    static_assert((std::is_same<decltype(sinh(Ambiguous())), Ambiguous>::value), "");
484    assert(std::sinh(0) == 0);
485}
486
487void test_sqrt()
488{
489    static_assert((std::is_same<decltype(std::sqrt((float)0)), float>::value), "");
490    static_assert((std::is_same<decltype(std::sqrt((bool)0)), double>::value), "");
491    static_assert((std::is_same<decltype(std::sqrt((unsigned short)0)), double>::value), "");
492    static_assert((std::is_same<decltype(std::sqrt((int)0)), double>::value), "");
493    static_assert((std::is_same<decltype(std::sqrt((unsigned int)0)), double>::value), "");
494    static_assert((std::is_same<decltype(std::sqrt((long)0)), double>::value), "");
495    static_assert((std::is_same<decltype(std::sqrt((unsigned long)0)), double>::value), "");
496    static_assert((std::is_same<decltype(std::sqrt((long long)0)), double>::value), "");
497    static_assert((std::is_same<decltype(std::sqrt((unsigned long long)0)), double>::value), "");
498    static_assert((std::is_same<decltype(std::sqrt((double)0)), double>::value), "");
499    static_assert((std::is_same<decltype(std::sqrt((long double)0)), long double>::value), "");
500    static_assert((std::is_same<decltype(std::sqrtf(0)), float>::value), "");
501    static_assert((std::is_same<decltype(std::sqrtl(0)), long double>::value), "");
502    static_assert((std::is_same<decltype(sqrt(Ambiguous())), Ambiguous>::value), "");
503    assert(std::sqrt(4) == 2);
504}
505
506void test_tan()
507{
508    static_assert((std::is_same<decltype(std::tan((float)0)), float>::value), "");
509    static_assert((std::is_same<decltype(std::tan((bool)0)), double>::value), "");
510    static_assert((std::is_same<decltype(std::tan((unsigned short)0)), double>::value), "");
511    static_assert((std::is_same<decltype(std::tan((int)0)), double>::value), "");
512    static_assert((std::is_same<decltype(std::tan((unsigned int)0)), double>::value), "");
513    static_assert((std::is_same<decltype(std::tan((long)0)), double>::value), "");
514    static_assert((std::is_same<decltype(std::tan((unsigned long)0)), double>::value), "");
515    static_assert((std::is_same<decltype(std::tan((long long)0)), double>::value), "");
516    static_assert((std::is_same<decltype(std::tan((unsigned long long)0)), double>::value), "");
517    static_assert((std::is_same<decltype(std::tan((double)0)), double>::value), "");
518    static_assert((std::is_same<decltype(std::tan((long double)0)), long double>::value), "");
519    static_assert((std::is_same<decltype(std::tanf(0)), float>::value), "");
520    static_assert((std::is_same<decltype(std::tanl(0)), long double>::value), "");
521    static_assert((std::is_same<decltype(tan(Ambiguous())), Ambiguous>::value), "");
522    assert(std::tan(0) == 0);
523}
524
525void test_tanh()
526{
527    static_assert((std::is_same<decltype(std::tanh((float)0)), float>::value), "");
528    static_assert((std::is_same<decltype(std::tanh((bool)0)), double>::value), "");
529    static_assert((std::is_same<decltype(std::tanh((unsigned short)0)), double>::value), "");
530    static_assert((std::is_same<decltype(std::tanh((int)0)), double>::value), "");
531    static_assert((std::is_same<decltype(std::tanh((unsigned int)0)), double>::value), "");
532    static_assert((std::is_same<decltype(std::tanh((long)0)), double>::value), "");
533    static_assert((std::is_same<decltype(std::tanh((unsigned long)0)), double>::value), "");
534    static_assert((std::is_same<decltype(std::tanh((long long)0)), double>::value), "");
535    static_assert((std::is_same<decltype(std::tanh((unsigned long long)0)), double>::value), "");
536    static_assert((std::is_same<decltype(std::tanh((double)0)), double>::value), "");
537    static_assert((std::is_same<decltype(std::tanh((long double)0)), long double>::value), "");
538    static_assert((std::is_same<decltype(std::tanhf(0)), float>::value), "");
539    static_assert((std::is_same<decltype(std::tanhl(0)), long double>::value), "");
540    static_assert((std::is_same<decltype(tanh(Ambiguous())), Ambiguous>::value), "");
541    assert(std::tanh(0) == 0);
542}
543
544void test_signbit()
545{
546#ifdef signbit
547#error signbit defined
548#endif
549    static_assert((std::is_same<decltype(std::signbit((float)0)), bool>::value), "");
550    static_assert((std::is_same<decltype(std::signbit((double)0)), bool>::value), "");
551    static_assert((std::is_same<decltype(std::signbit(0)), bool>::value), "");
552    static_assert((std::is_same<decltype(std::signbit((long double)0)), bool>::value), "");
553    static_assert((std::is_same<decltype(signbit(Ambiguous())), Ambiguous>::value), "");
554    assert(std::signbit(-1.0) == true);
555    assert(std::signbit(0u) == false);
556    assert(std::signbit(std::numeric_limits<unsigned>::max()) == false);
557    assert(std::signbit(0) == false);
558    assert(std::signbit(1) == false);
559    assert(std::signbit(-1) == true);
560    assert(std::signbit(std::numeric_limits<int>::max()) == false);
561    assert(std::signbit(std::numeric_limits<int>::min()) == true);
562}
563
564void test_fpclassify()
565{
566#ifdef fpclassify
567#error fpclassify defined
568#endif
569    static_assert((std::is_same<decltype(std::fpclassify((float)0)), int>::value), "");
570    static_assert((std::is_same<decltype(std::fpclassify((double)0)), int>::value), "");
571    static_assert((std::is_same<decltype(std::fpclassify(0)), int>::value), "");
572    static_assert((std::is_same<decltype(std::fpclassify((long double)0)), int>::value), "");
573    static_assert((std::is_same<decltype(fpclassify(Ambiguous())), Ambiguous>::value), "");
574    assert(std::fpclassify(-1.0) == FP_NORMAL);
575    assert(std::fpclassify(0) == FP_ZERO);
576    assert(std::fpclassify(1) == FP_NORMAL);
577    assert(std::fpclassify(-1) == FP_NORMAL);
578    assert(std::fpclassify(std::numeric_limits<int>::max()) == FP_NORMAL);
579    assert(std::fpclassify(std::numeric_limits<int>::min()) == FP_NORMAL);
580}
581
582void test_isfinite()
583{
584#ifdef isfinite
585#error isfinite defined
586#endif
587    static_assert((std::is_same<decltype(std::isfinite((float)0)), bool>::value), "");
588    static_assert((std::is_same<decltype(std::isfinite((double)0)), bool>::value), "");
589    static_assert((std::is_same<decltype(std::isfinite(0)), bool>::value), "");
590    static_assert((std::is_same<decltype(std::isfinite((long double)0)), bool>::value), "");
591    static_assert((std::is_same<decltype(isfinite(Ambiguous())), Ambiguous>::value), "");
592    assert(std::isfinite(-1.0) == true);
593    assert(std::isfinite(0) == true);
594    assert(std::isfinite(1) == true);
595    assert(std::isfinite(-1) == true);
596    assert(std::isfinite(std::numeric_limits<int>::max()) == true);
597    assert(std::isfinite(std::numeric_limits<int>::min()) == true);
598}
599
600void test_isnormal()
601{
602#ifdef isnormal
603#error isnormal defined
604#endif
605    static_assert((std::is_same<decltype(std::isnormal((float)0)), bool>::value), "");
606    static_assert((std::is_same<decltype(std::isnormal((double)0)), bool>::value), "");
607    static_assert((std::is_same<decltype(std::isnormal(0)), bool>::value), "");
608    static_assert((std::is_same<decltype(std::isnormal((long double)0)), bool>::value), "");
609    static_assert((std::is_same<decltype(isnormal(Ambiguous())), Ambiguous>::value), "");
610    assert(std::isnormal(-1.0) == true);
611    assert(std::isnormal(0) == false);
612    assert(std::isnormal(1) == true);
613    assert(std::isnormal(-1) == true);
614    assert(std::isnormal(std::numeric_limits<int>::max()) == true);
615    assert(std::isnormal(std::numeric_limits<int>::min()) == true);
616}
617
618void test_isgreater()
619{
620#ifdef isgreater
621#error isgreater defined
622#endif
623    static_assert((std::is_same<decltype(std::isgreater((float)0, (float)0)), bool>::value), "");
624    static_assert((std::is_same<decltype(std::isgreater((float)0, (double)0)), bool>::value), "");
625    static_assert((std::is_same<decltype(std::isgreater((float)0, (long double)0)), bool>::value), "");
626    static_assert((std::is_same<decltype(std::isgreater((double)0, (float)0)), bool>::value), "");
627    static_assert((std::is_same<decltype(std::isgreater((double)0, (double)0)), bool>::value), "");
628    static_assert((std::is_same<decltype(std::isgreater(0, (double)0)), bool>::value), "");
629    static_assert((std::is_same<decltype(std::isgreater((double)0, (long double)0)), bool>::value), "");
630    static_assert((std::is_same<decltype(std::isgreater((long double)0, (float)0)), bool>::value), "");
631    static_assert((std::is_same<decltype(std::isgreater((long double)0, (double)0)), bool>::value), "");
632    static_assert((std::is_same<decltype(std::isgreater((long double)0, (long double)0)), bool>::value), "");
633    static_assert((std::is_same<decltype(isgreater(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
634    assert(std::isgreater(-1.0, 0.F) == false);
635}
636
637void test_isgreaterequal()
638{
639#ifdef isgreaterequal
640#error isgreaterequal defined
641#endif
642    static_assert((std::is_same<decltype(std::isgreaterequal((float)0, (float)0)), bool>::value), "");
643    static_assert((std::is_same<decltype(std::isgreaterequal((float)0, (double)0)), bool>::value), "");
644    static_assert((std::is_same<decltype(std::isgreaterequal((float)0, (long double)0)), bool>::value), "");
645    static_assert((std::is_same<decltype(std::isgreaterequal((double)0, (float)0)), bool>::value), "");
646    static_assert((std::is_same<decltype(std::isgreaterequal((double)0, (double)0)), bool>::value), "");
647    static_assert((std::is_same<decltype(std::isgreaterequal(0, (double)0)), bool>::value), "");
648    static_assert((std::is_same<decltype(std::isgreaterequal((double)0, (long double)0)), bool>::value), "");
649    static_assert((std::is_same<decltype(std::isgreaterequal((long double)0, (float)0)), bool>::value), "");
650    static_assert((std::is_same<decltype(std::isgreaterequal((long double)0, (double)0)), bool>::value), "");
651    static_assert((std::is_same<decltype(std::isgreaterequal((long double)0, (long double)0)), bool>::value), "");
652    static_assert((std::is_same<decltype(isgreaterequal(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
653    assert(std::isgreaterequal(-1.0, 0.F) == false);
654}
655
656void test_isinf()
657{
658#ifdef isinf
659#error isinf defined
660#endif
661    static_assert((std::is_same<decltype(std::isinf((float)0)), bool>::value), "");
662
663    typedef decltype(std::isinf((double)0)) DoubleRetType;
664#ifndef __linux__
665    static_assert((std::is_same<DoubleRetType, bool>::value), "");
666#else
667    // GLIBC < 2.26 defines 'isinf(double)' with a return type of 'int' in
668    // all C++ dialects. The test should tolerate this.
669    // See: https://sourceware.org/bugzilla/show_bug.cgi?id=19439
670    static_assert((std::is_same<DoubleRetType, bool>::value
671                || std::is_same<DoubleRetType, int>::value), "");
672#endif
673
674    static_assert((std::is_same<decltype(std::isinf(0)), bool>::value), "");
675    static_assert((std::is_same<decltype(std::isinf((long double)0)), bool>::value), "");
676    assert(std::isinf(-1.0) == false);
677    assert(std::isinf(0) == false);
678    assert(std::isinf(1) == false);
679    assert(std::isinf(-1) == false);
680    assert(std::isinf(std::numeric_limits<int>::max()) == false);
681    assert(std::isinf(std::numeric_limits<int>::min()) == false);
682}
683
684void test_isless()
685{
686#ifdef isless
687#error isless defined
688#endif
689    static_assert((std::is_same<decltype(std::isless((float)0, (float)0)), bool>::value), "");
690    static_assert((std::is_same<decltype(std::isless((float)0, (double)0)), bool>::value), "");
691    static_assert((std::is_same<decltype(std::isless((float)0, (long double)0)), bool>::value), "");
692    static_assert((std::is_same<decltype(std::isless((double)0, (float)0)), bool>::value), "");
693    static_assert((std::is_same<decltype(std::isless((double)0, (double)0)), bool>::value), "");
694    static_assert((std::is_same<decltype(std::isless(0, (double)0)), bool>::value), "");
695    static_assert((std::is_same<decltype(std::isless((double)0, (long double)0)), bool>::value), "");
696    static_assert((std::is_same<decltype(std::isless((long double)0, (float)0)), bool>::value), "");
697    static_assert((std::is_same<decltype(std::isless((long double)0, (double)0)), bool>::value), "");
698    static_assert((std::is_same<decltype(std::isless((long double)0, (long double)0)), bool>::value), "");
699    static_assert((std::is_same<decltype(isless(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
700    assert(std::isless(-1.0, 0.F) == true);
701}
702
703void test_islessequal()
704{
705#ifdef islessequal
706#error islessequal defined
707#endif
708    static_assert((std::is_same<decltype(std::islessequal((float)0, (float)0)), bool>::value), "");
709    static_assert((std::is_same<decltype(std::islessequal((float)0, (double)0)), bool>::value), "");
710    static_assert((std::is_same<decltype(std::islessequal((float)0, (long double)0)), bool>::value), "");
711    static_assert((std::is_same<decltype(std::islessequal((double)0, (float)0)), bool>::value), "");
712    static_assert((std::is_same<decltype(std::islessequal((double)0, (double)0)), bool>::value), "");
713    static_assert((std::is_same<decltype(std::islessequal(0, (double)0)), bool>::value), "");
714    static_assert((std::is_same<decltype(std::islessequal((double)0, (long double)0)), bool>::value), "");
715    static_assert((std::is_same<decltype(std::islessequal((long double)0, (float)0)), bool>::value), "");
716    static_assert((std::is_same<decltype(std::islessequal((long double)0, (double)0)), bool>::value), "");
717    static_assert((std::is_same<decltype(std::islessequal((long double)0, (long double)0)), bool>::value), "");
718    static_assert((std::is_same<decltype(islessequal(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
719    assert(std::islessequal(-1.0, 0.F) == true);
720}
721
722void test_islessgreater()
723{
724#ifdef islessgreater
725#error islessgreater defined
726#endif
727    static_assert((std::is_same<decltype(std::islessgreater((float)0, (float)0)), bool>::value), "");
728    static_assert((std::is_same<decltype(std::islessgreater((float)0, (double)0)), bool>::value), "");
729    static_assert((std::is_same<decltype(std::islessgreater((float)0, (long double)0)), bool>::value), "");
730    static_assert((std::is_same<decltype(std::islessgreater((double)0, (float)0)), bool>::value), "");
731    static_assert((std::is_same<decltype(std::islessgreater((double)0, (double)0)), bool>::value), "");
732    static_assert((std::is_same<decltype(std::islessgreater(0, (double)0)), bool>::value), "");
733    static_assert((std::is_same<decltype(std::islessgreater((double)0, (long double)0)), bool>::value), "");
734    static_assert((std::is_same<decltype(std::islessgreater((long double)0, (float)0)), bool>::value), "");
735    static_assert((std::is_same<decltype(std::islessgreater((long double)0, (double)0)), bool>::value), "");
736    static_assert((std::is_same<decltype(std::islessgreater((long double)0, (long double)0)), bool>::value), "");
737    static_assert((std::is_same<decltype(islessgreater(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
738    assert(std::islessgreater(-1.0, 0.F) == true);
739}
740
741void test_isnan()
742{
743#ifdef isnan
744#error isnan defined
745#endif
746    static_assert((std::is_same<decltype(std::isnan((float)0)), bool>::value), "");
747
748    typedef decltype(std::isnan((double)0)) DoubleRetType;
749#ifndef __linux__
750    static_assert((std::is_same<DoubleRetType, bool>::value), "");
751#else
752    // GLIBC < 2.26 defines 'isnan(double)' with a return type of 'int' in
753    // all C++ dialects. The test should tolerate this.
754    // See: https://sourceware.org/bugzilla/show_bug.cgi?id=19439
755    static_assert((std::is_same<DoubleRetType, bool>::value
756                || std::is_same<DoubleRetType, int>::value), "");
757#endif
758
759    static_assert((std::is_same<decltype(std::isnan(0)), bool>::value), "");
760    static_assert((std::is_same<decltype(std::isnan((long double)0)), bool>::value), "");
761    assert(std::isnan(-1.0) == false);
762    assert(std::isnan(0) == false);
763    assert(std::isnan(1) == false);
764    assert(std::isnan(-1) == false);
765    assert(std::isnan(std::numeric_limits<int>::max()) == false);
766    assert(std::isnan(std::numeric_limits<int>::min()) == false);
767}
768
769void test_isunordered()
770{
771#ifdef isunordered
772#error isunordered defined
773#endif
774    static_assert((std::is_same<decltype(std::isunordered((float)0, (float)0)), bool>::value), "");
775    static_assert((std::is_same<decltype(std::isunordered((float)0, (double)0)), bool>::value), "");
776    static_assert((std::is_same<decltype(std::isunordered((float)0, (long double)0)), bool>::value), "");
777    static_assert((std::is_same<decltype(std::isunordered((double)0, (float)0)), bool>::value), "");
778    static_assert((std::is_same<decltype(std::isunordered((double)0, (double)0)), bool>::value), "");
779    static_assert((std::is_same<decltype(std::isunordered(0, (double)0)), bool>::value), "");
780    static_assert((std::is_same<decltype(std::isunordered((double)0, (long double)0)), bool>::value), "");
781    static_assert((std::is_same<decltype(std::isunordered((long double)0, (float)0)), bool>::value), "");
782    static_assert((std::is_same<decltype(std::isunordered((long double)0, (double)0)), bool>::value), "");
783    static_assert((std::is_same<decltype(std::isunordered((long double)0, (long double)0)), bool>::value), "");
784    static_assert((std::is_same<decltype(isunordered(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
785    assert(std::isunordered(-1.0, 0.F) == false);
786}
787
788void test_acosh()
789{
790    static_assert((std::is_same<decltype(std::acosh((float)0)), float>::value), "");
791    static_assert((std::is_same<decltype(std::acosh((bool)0)), double>::value), "");
792    static_assert((std::is_same<decltype(std::acosh((unsigned short)0)), double>::value), "");
793    static_assert((std::is_same<decltype(std::acosh((int)0)), double>::value), "");
794    static_assert((std::is_same<decltype(std::acosh((unsigned int)0)), double>::value), "");
795    static_assert((std::is_same<decltype(std::acosh((long)0)), double>::value), "");
796    static_assert((std::is_same<decltype(std::acosh((unsigned long)0)), double>::value), "");
797    static_assert((std::is_same<decltype(std::acosh((long long)0)), double>::value), "");
798    static_assert((std::is_same<decltype(std::acosh((unsigned long long)0)), double>::value), "");
799    static_assert((std::is_same<decltype(std::acosh((double)0)), double>::value), "");
800    static_assert((std::is_same<decltype(std::acosh((long double)0)), long double>::value), "");
801    static_assert((std::is_same<decltype(std::acoshf(0)), float>::value), "");
802    static_assert((std::is_same<decltype(std::acoshl(0)), long double>::value), "");
803    static_assert((std::is_same<decltype(acosh(Ambiguous())), Ambiguous>::value), "");
804    assert(std::acosh(1) == 0);
805}
806
807void test_asinh()
808{
809    static_assert((std::is_same<decltype(std::asinh((float)0)), float>::value), "");
810    static_assert((std::is_same<decltype(std::asinh((bool)0)), double>::value), "");
811    static_assert((std::is_same<decltype(std::asinh((unsigned short)0)), double>::value), "");
812    static_assert((std::is_same<decltype(std::asinh((int)0)), double>::value), "");
813    static_assert((std::is_same<decltype(std::asinh((unsigned int)0)), double>::value), "");
814    static_assert((std::is_same<decltype(std::asinh((long)0)), double>::value), "");
815    static_assert((std::is_same<decltype(std::asinh((unsigned long)0)), double>::value), "");
816    static_assert((std::is_same<decltype(std::asinh((long long)0)), double>::value), "");
817    static_assert((std::is_same<decltype(std::asinh((unsigned long long)0)), double>::value), "");
818    static_assert((std::is_same<decltype(std::asinh((double)0)), double>::value), "");
819    static_assert((std::is_same<decltype(std::asinh((long double)0)), long double>::value), "");
820    static_assert((std::is_same<decltype(std::asinhf(0)), float>::value), "");
821    static_assert((std::is_same<decltype(std::asinhl(0)), long double>::value), "");
822    static_assert((std::is_same<decltype(asinh(Ambiguous())), Ambiguous>::value), "");
823    assert(std::asinh(0) == 0);
824}
825
826void test_atanh()
827{
828    static_assert((std::is_same<decltype(std::atanh((float)0)), float>::value), "");
829    static_assert((std::is_same<decltype(std::atanh((bool)0)), double>::value), "");
830    static_assert((std::is_same<decltype(std::atanh((unsigned short)0)), double>::value), "");
831    static_assert((std::is_same<decltype(std::atanh((int)0)), double>::value), "");
832    static_assert((std::is_same<decltype(std::atanh((unsigned int)0)), double>::value), "");
833    static_assert((std::is_same<decltype(std::atanh((long)0)), double>::value), "");
834    static_assert((std::is_same<decltype(std::atanh((unsigned long)0)), double>::value), "");
835    static_assert((std::is_same<decltype(std::atanh((long long)0)), double>::value), "");
836    static_assert((std::is_same<decltype(std::atanh((unsigned long long)0)), double>::value), "");
837    static_assert((std::is_same<decltype(std::atanh((double)0)), double>::value), "");
838    static_assert((std::is_same<decltype(std::atanh((long double)0)), long double>::value), "");
839    static_assert((std::is_same<decltype(std::atanhf(0)), float>::value), "");
840    static_assert((std::is_same<decltype(std::atanhl(0)), long double>::value), "");
841    static_assert((std::is_same<decltype(atanh(Ambiguous())), Ambiguous>::value), "");
842    assert(std::atanh(0) == 0);
843}
844
845void test_cbrt()
846{
847    static_assert((std::is_same<decltype(std::cbrt((float)0)), float>::value), "");
848    static_assert((std::is_same<decltype(std::cbrt((bool)0)), double>::value), "");
849    static_assert((std::is_same<decltype(std::cbrt((unsigned short)0)), double>::value), "");
850    static_assert((std::is_same<decltype(std::cbrt((int)0)), double>::value), "");
851    static_assert((std::is_same<decltype(std::cbrt((unsigned int)0)), double>::value), "");
852    static_assert((std::is_same<decltype(std::cbrt((long)0)), double>::value), "");
853    static_assert((std::is_same<decltype(std::cbrt((unsigned long)0)), double>::value), "");
854    static_assert((std::is_same<decltype(std::cbrt((long long)0)), double>::value), "");
855    static_assert((std::is_same<decltype(std::cbrt((unsigned long long)0)), double>::value), "");
856    static_assert((std::is_same<decltype(std::cbrt((double)0)), double>::value), "");
857    static_assert((std::is_same<decltype(std::cbrt((long double)0)), long double>::value), "");
858    static_assert((std::is_same<decltype(std::cbrtf(0)), float>::value), "");
859    static_assert((std::is_same<decltype(std::cbrtl(0)), long double>::value), "");
860    static_assert((std::is_same<decltype(cbrt(Ambiguous())), Ambiguous>::value), "");
861    assert(std::cbrt(1) == 1);
862}
863
864void test_copysign()
865{
866    static_assert((std::is_same<decltype(std::copysign((float)0, (float)0)), float>::value), "");
867    static_assert((std::is_same<decltype(std::copysign((bool)0, (float)0)), double>::value), "");
868    static_assert((std::is_same<decltype(std::copysign((unsigned short)0, (double)0)), double>::value), "");
869    static_assert((std::is_same<decltype(std::copysign((int)0, (long double)0)), long double>::value), "");
870    static_assert((std::is_same<decltype(std::copysign((float)0, (unsigned int)0)), double>::value), "");
871    static_assert((std::is_same<decltype(std::copysign((double)0, (long)0)), double>::value), "");
872    static_assert((std::is_same<decltype(std::copysign((long double)0, (unsigned long)0)), long double>::value), "");
873    static_assert((std::is_same<decltype(std::copysign((int)0, (long long)0)), double>::value), "");
874    static_assert((std::is_same<decltype(std::copysign((int)0, (unsigned long long)0)), double>::value), "");
875    static_assert((std::is_same<decltype(std::copysign((double)0, (double)0)), double>::value), "");
876    static_assert((std::is_same<decltype(std::copysign((long double)0, (long double)0)), long double>::value), "");
877    static_assert((std::is_same<decltype(std::copysign((float)0, (double)0)), double>::value), "");
878    static_assert((std::is_same<decltype(std::copysign((float)0, (long double)0)), long double>::value), "");
879    static_assert((std::is_same<decltype(std::copysign((double)0, (long double)0)), long double>::value), "");
880    static_assert((std::is_same<decltype(std::copysignf(0,0)), float>::value), "");
881    static_assert((std::is_same<decltype(std::copysignl(0,0)), long double>::value), "");
882    static_assert((std::is_same<decltype(std::copysign((int)0, (int)0)), double>::value), "");
883    static_assert((std::is_same<decltype(copysign(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
884    assert(std::copysign(1,1) == 1);
885}
886
887void test_erf()
888{
889    static_assert((std::is_same<decltype(std::erf((float)0)), float>::value), "");
890    static_assert((std::is_same<decltype(std::erf((bool)0)), double>::value), "");
891    static_assert((std::is_same<decltype(std::erf((unsigned short)0)), double>::value), "");
892    static_assert((std::is_same<decltype(std::erf((int)0)), double>::value), "");
893    static_assert((std::is_same<decltype(std::erf((unsigned int)0)), double>::value), "");
894    static_assert((std::is_same<decltype(std::erf((long)0)), double>::value), "");
895    static_assert((std::is_same<decltype(std::erf((unsigned long)0)), double>::value), "");
896    static_assert((std::is_same<decltype(std::erf((long long)0)), double>::value), "");
897    static_assert((std::is_same<decltype(std::erf((unsigned long long)0)), double>::value), "");
898    static_assert((std::is_same<decltype(std::erf((double)0)), double>::value), "");
899    static_assert((std::is_same<decltype(std::erf((long double)0)), long double>::value), "");
900    static_assert((std::is_same<decltype(std::erff(0)), float>::value), "");
901    static_assert((std::is_same<decltype(std::erfl(0)), long double>::value), "");
902    static_assert((std::is_same<decltype(erf(Ambiguous())), Ambiguous>::value), "");
903    assert(std::erf(0) == 0);
904}
905
906void test_erfc()
907{
908    static_assert((std::is_same<decltype(std::erfc((float)0)), float>::value), "");
909    static_assert((std::is_same<decltype(std::erfc((bool)0)), double>::value), "");
910    static_assert((std::is_same<decltype(std::erfc((unsigned short)0)), double>::value), "");
911    static_assert((std::is_same<decltype(std::erfc((int)0)), double>::value), "");
912    static_assert((std::is_same<decltype(std::erfc((unsigned int)0)), double>::value), "");
913    static_assert((std::is_same<decltype(std::erfc((long)0)), double>::value), "");
914    static_assert((std::is_same<decltype(std::erfc((unsigned long)0)), double>::value), "");
915    static_assert((std::is_same<decltype(std::erfc((long long)0)), double>::value), "");
916    static_assert((std::is_same<decltype(std::erfc((unsigned long long)0)), double>::value), "");
917    static_assert((std::is_same<decltype(std::erfc((double)0)), double>::value), "");
918    static_assert((std::is_same<decltype(std::erfc((long double)0)), long double>::value), "");
919    static_assert((std::is_same<decltype(std::erfcf(0)), float>::value), "");
920    static_assert((std::is_same<decltype(std::erfcl(0)), long double>::value), "");
921    static_assert((std::is_same<decltype(erfc(Ambiguous())), Ambiguous>::value), "");
922    assert(std::erfc(0) == 1);
923}
924
925void test_exp2()
926{
927    static_assert((std::is_same<decltype(std::exp2((float)0)), float>::value), "");
928    static_assert((std::is_same<decltype(std::exp2((bool)0)), double>::value), "");
929    static_assert((std::is_same<decltype(std::exp2((unsigned short)0)), double>::value), "");
930    static_assert((std::is_same<decltype(std::exp2((int)0)), double>::value), "");
931    static_assert((std::is_same<decltype(std::exp2((unsigned int)0)), double>::value), "");
932    static_assert((std::is_same<decltype(std::exp2((long)0)), double>::value), "");
933    static_assert((std::is_same<decltype(std::exp2((unsigned long)0)), double>::value), "");
934    static_assert((std::is_same<decltype(std::exp2((long long)0)), double>::value), "");
935    static_assert((std::is_same<decltype(std::exp2((unsigned long long)0)), double>::value), "");
936    static_assert((std::is_same<decltype(std::exp2((double)0)), double>::value), "");
937    static_assert((std::is_same<decltype(std::exp2((long double)0)), long double>::value), "");
938    static_assert((std::is_same<decltype(std::exp2f(0)), float>::value), "");
939    static_assert((std::is_same<decltype(std::exp2l(0)), long double>::value), "");
940    static_assert((std::is_same<decltype(exp2(Ambiguous())), Ambiguous>::value), "");
941    assert(std::exp2(1) == 2);
942}
943
944void test_expm1()
945{
946    static_assert((std::is_same<decltype(std::expm1((float)0)), float>::value), "");
947    static_assert((std::is_same<decltype(std::expm1((bool)0)), double>::value), "");
948    static_assert((std::is_same<decltype(std::expm1((unsigned short)0)), double>::value), "");
949    static_assert((std::is_same<decltype(std::expm1((int)0)), double>::value), "");
950    static_assert((std::is_same<decltype(std::expm1((unsigned int)0)), double>::value), "");
951    static_assert((std::is_same<decltype(std::expm1((long)0)), double>::value), "");
952    static_assert((std::is_same<decltype(std::expm1((unsigned long)0)), double>::value), "");
953    static_assert((std::is_same<decltype(std::expm1((long long)0)), double>::value), "");
954    static_assert((std::is_same<decltype(std::expm1((unsigned long long)0)), double>::value), "");
955    static_assert((std::is_same<decltype(std::expm1((double)0)), double>::value), "");
956    static_assert((std::is_same<decltype(std::expm1((long double)0)), long double>::value), "");
957    static_assert((std::is_same<decltype(std::expm1f(0)), float>::value), "");
958    static_assert((std::is_same<decltype(std::expm1l(0)), long double>::value), "");
959    static_assert((std::is_same<decltype(expm1(Ambiguous())), Ambiguous>::value), "");
960    assert(std::expm1(0) == 0);
961}
962
963void test_fdim()
964{
965    static_assert((std::is_same<decltype(std::fdim((float)0, (float)0)), float>::value), "");
966    static_assert((std::is_same<decltype(std::fdim((bool)0, (float)0)), double>::value), "");
967    static_assert((std::is_same<decltype(std::fdim((unsigned short)0, (double)0)), double>::value), "");
968    static_assert((std::is_same<decltype(std::fdim((int)0, (long double)0)), long double>::value), "");
969    static_assert((std::is_same<decltype(std::fdim((float)0, (unsigned int)0)), double>::value), "");
970    static_assert((std::is_same<decltype(std::fdim((double)0, (long)0)), double>::value), "");
971    static_assert((std::is_same<decltype(std::fdim((long double)0, (unsigned long)0)), long double>::value), "");
972    static_assert((std::is_same<decltype(std::fdim((int)0, (long long)0)), double>::value), "");
973    static_assert((std::is_same<decltype(std::fdim((int)0, (unsigned long long)0)), double>::value), "");
974    static_assert((std::is_same<decltype(std::fdim((double)0, (double)0)), double>::value), "");
975    static_assert((std::is_same<decltype(std::fdim((long double)0, (long double)0)), long double>::value), "");
976    static_assert((std::is_same<decltype(std::fdim((float)0, (double)0)), double>::value), "");
977    static_assert((std::is_same<decltype(std::fdim((float)0, (long double)0)), long double>::value), "");
978    static_assert((std::is_same<decltype(std::fdim((double)0, (long double)0)), long double>::value), "");
979    static_assert((std::is_same<decltype(std::fdimf(0,0)), float>::value), "");
980    static_assert((std::is_same<decltype(std::fdiml(0,0)), long double>::value), "");
981    static_assert((std::is_same<decltype(std::fdim((int)0, (int)0)), double>::value), "");
982    static_assert((std::is_same<decltype(fdim(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
983    assert(std::fdim(1,0) == 1);
984}
985
986void test_fma()
987{
988    static_assert((std::is_same<decltype(std::fma((bool)0, (float)0, (float)0)), double>::value), "");
989    static_assert((std::is_same<decltype(std::fma((char)0, (float)0, (float)0)), double>::value), "");
990    static_assert((std::is_same<decltype(std::fma((unsigned)0, (float)0, (float)0)), double>::value), "");
991    static_assert((std::is_same<decltype(std::fma((float)0, (int)0, (float)0)), double>::value), "");
992    static_assert((std::is_same<decltype(std::fma((float)0, (long)0, (float)0)), double>::value), "");
993    static_assert((std::is_same<decltype(std::fma((float)0, (float)0, (unsigned long long)0)), double>::value), "");
994    static_assert((std::is_same<decltype(std::fma((float)0, (float)0, (double)0)), double>::value), "");
995    static_assert((std::is_same<decltype(std::fma((float)0, (float)0, (long double)0)), long double>::value), "");
996    static_assert((std::is_same<decltype(std::fma((float)0, (float)0, (float)0)), float>::value), "");
997
998    static_assert((std::is_same<decltype(std::fma((bool)0, (double)0, (double)0)), double>::value), "");
999    static_assert((std::is_same<decltype(std::fma((char)0, (double)0, (double)0)), double>::value), "");
1000    static_assert((std::is_same<decltype(std::fma((unsigned)0, (double)0, (double)0)), double>::value), "");
1001    static_assert((std::is_same<decltype(std::fma((double)0, (int)0, (double)0)), double>::value), "");
1002    static_assert((std::is_same<decltype(std::fma((double)0, (long)0, (double)0)), double>::value), "");
1003    static_assert((std::is_same<decltype(std::fma((double)0, (double)0, (unsigned long long)0)), double>::value), "");
1004    static_assert((std::is_same<decltype(std::fma((double)0, (double)0, (float)0)), double>::value), "");
1005    static_assert((std::is_same<decltype(std::fma((double)0, (double)0, (long double)0)), long double>::value), "");
1006    static_assert((std::is_same<decltype(std::fma((double)0, (double)0,  (double)0)), double>::value), "");
1007
1008    static_assert((std::is_same<decltype(std::fma((bool)0, (long double)0, (long double)0)), long double>::value), "");
1009    static_assert((std::is_same<decltype(std::fma((char)0, (long double)0, (long double)0)), long double>::value), "");
1010    static_assert((std::is_same<decltype(std::fma((unsigned)0, (long double)0, (long double)0)), long double>::value), "");
1011    static_assert((std::is_same<decltype(std::fma((long double)0, (int)0, (long double)0)), long double>::value), "");
1012    static_assert((std::is_same<decltype(std::fma((long double)0, (long)0, (long double)0)), long double>::value), "");
1013    static_assert((std::is_same<decltype(std::fma((long double)0, (long double)0, (unsigned long long)0)), long double>::value), "");
1014    static_assert((std::is_same<decltype(std::fma((long double)0, (long double)0, (float)0)), long double>::value), "");
1015    static_assert((std::is_same<decltype(std::fma((double)0, (long double)0, (long double)0)), long double>::value), "");
1016    static_assert((std::is_same<decltype(std::fma((long double)0, (long double)0, (long double)0)), long double>::value), "");
1017
1018    static_assert((std::is_same<decltype(std::fmaf(0,0,0)), float>::value), "");
1019    static_assert((std::is_same<decltype(std::fmal(0,0,0)), long double>::value), "");
1020    static_assert((std::is_same<decltype(fma(Ambiguous(), Ambiguous(), Ambiguous())), Ambiguous>::value), "");
1021    assert(std::fma(1,1,1) == 2);
1022}
1023
1024void test_fmax()
1025{
1026    static_assert((std::is_same<decltype(std::fmax((float)0, (float)0)), float>::value), "");
1027    static_assert((std::is_same<decltype(std::fmax((bool)0, (float)0)), double>::value), "");
1028    static_assert((std::is_same<decltype(std::fmax((unsigned short)0, (double)0)), double>::value), "");
1029    static_assert((std::is_same<decltype(std::fmax((int)0, (long double)0)), long double>::value), "");
1030    static_assert((std::is_same<decltype(std::fmax((float)0, (unsigned int)0)), double>::value), "");
1031    static_assert((std::is_same<decltype(std::fmax((double)0, (long)0)), double>::value), "");
1032    static_assert((std::is_same<decltype(std::fmax((long double)0, (unsigned long)0)), long double>::value), "");
1033    static_assert((std::is_same<decltype(std::fmax((int)0, (long long)0)), double>::value), "");
1034    static_assert((std::is_same<decltype(std::fmax((int)0, (unsigned long long)0)), double>::value), "");
1035    static_assert((std::is_same<decltype(std::fmax((double)0, (double)0)), double>::value), "");
1036    static_assert((std::is_same<decltype(std::fmax((long double)0, (long double)0)), long double>::value), "");
1037    static_assert((std::is_same<decltype(std::fmax((float)0, (double)0)), double>::value), "");
1038    static_assert((std::is_same<decltype(std::fmax((float)0, (long double)0)), long double>::value), "");
1039    static_assert((std::is_same<decltype(std::fmax((double)0, (long double)0)), long double>::value), "");
1040    static_assert((std::is_same<decltype(std::fmaxf(0,0)), float>::value), "");
1041    static_assert((std::is_same<decltype(std::fmaxl(0,0)), long double>::value), "");
1042    static_assert((std::is_same<decltype(std::fmax((int)0, (int)0)), double>::value), "");
1043    static_assert((std::is_same<decltype(fmax(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
1044    assert(std::fmax(1,0) == 1);
1045}
1046
1047void test_fmin()
1048{
1049    static_assert((std::is_same<decltype(std::fmin((float)0, (float)0)), float>::value), "");
1050    static_assert((std::is_same<decltype(std::fmin((bool)0, (float)0)), double>::value), "");
1051    static_assert((std::is_same<decltype(std::fmin((unsigned short)0, (double)0)), double>::value), "");
1052    static_assert((std::is_same<decltype(std::fmin((int)0, (long double)0)), long double>::value), "");
1053    static_assert((std::is_same<decltype(std::fmin((float)0, (unsigned int)0)), double>::value), "");
1054    static_assert((std::is_same<decltype(std::fmin((double)0, (long)0)), double>::value), "");
1055    static_assert((std::is_same<decltype(std::fmin((long double)0, (unsigned long)0)), long double>::value), "");
1056    static_assert((std::is_same<decltype(std::fmin((int)0, (long long)0)), double>::value), "");
1057    static_assert((std::is_same<decltype(std::fmin((int)0, (unsigned long long)0)), double>::value), "");
1058    static_assert((std::is_same<decltype(std::fmin((double)0, (double)0)), double>::value), "");
1059    static_assert((std::is_same<decltype(std::fmin((long double)0, (long double)0)), long double>::value), "");
1060    static_assert((std::is_same<decltype(std::fmin((float)0, (double)0)), double>::value), "");
1061    static_assert((std::is_same<decltype(std::fmin((float)0, (long double)0)), long double>::value), "");
1062    static_assert((std::is_same<decltype(std::fmin((double)0, (long double)0)), long double>::value), "");
1063    static_assert((std::is_same<decltype(std::fminf(0,0)), float>::value), "");
1064    static_assert((std::is_same<decltype(std::fminl(0,0)), long double>::value), "");
1065    static_assert((std::is_same<decltype(std::fmin((int)0, (int)0)), double>::value), "");
1066    static_assert((std::is_same<decltype(fmin(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
1067    assert(std::fmin(1,0) == 0);
1068}
1069
1070void test_hypot()
1071{
1072    static_assert((std::is_same<decltype(std::hypot((float)0, (float)0)), float>::value), "");
1073    static_assert((std::is_same<decltype(std::hypot((bool)0, (float)0)), double>::value), "");
1074    static_assert((std::is_same<decltype(std::hypot((unsigned short)0, (double)0)), double>::value), "");
1075    static_assert((std::is_same<decltype(std::hypot((int)0, (long double)0)), long double>::value), "");
1076    static_assert((std::is_same<decltype(std::hypot((float)0, (unsigned int)0)), double>::value), "");
1077    static_assert((std::is_same<decltype(std::hypot((double)0, (long)0)), double>::value), "");
1078    static_assert((std::is_same<decltype(std::hypot((long double)0, (unsigned long)0)), long double>::value), "");
1079    static_assert((std::is_same<decltype(std::hypot((int)0, (long long)0)), double>::value), "");
1080    static_assert((std::is_same<decltype(std::hypot((int)0, (unsigned long long)0)), double>::value), "");
1081    static_assert((std::is_same<decltype(std::hypot((double)0, (double)0)), double>::value), "");
1082    static_assert((std::is_same<decltype(std::hypot((long double)0, (long double)0)), long double>::value), "");
1083    static_assert((std::is_same<decltype(std::hypot((float)0, (double)0)), double>::value), "");
1084    static_assert((std::is_same<decltype(std::hypot((float)0, (long double)0)), long double>::value), "");
1085    static_assert((std::is_same<decltype(std::hypot((double)0, (long double)0)), long double>::value), "");
1086    static_assert((std::is_same<decltype(std::hypotf(0,0)), float>::value), "");
1087    static_assert((std::is_same<decltype(std::hypotl(0,0)), long double>::value), "");
1088    static_assert((std::is_same<decltype(std::hypot((int)0, (int)0)), double>::value), "");
1089    static_assert((std::is_same<decltype(hypot(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
1090    assert(std::hypot(3,4) == 5);
1091
1092#if TEST_STD_VER > 14
1093    static_assert((std::is_same<decltype(std::hypot((float)0, (float)0, (float)0)), float>::value), "");
1094    static_assert((std::is_same<decltype(std::hypot((float)0, (bool)0, (float)0)), double>::value), "");
1095    static_assert((std::is_same<decltype(std::hypot((float)0, (unsigned short)0, (double)0)), double>::value), "");
1096    static_assert((std::is_same<decltype(std::hypot((float)0, (int)0, (long double)0)), long double>::value), "");
1097    static_assert((std::is_same<decltype(std::hypot((float)0, (unsigned int)0)), double>::value), "");
1098    static_assert((std::is_same<decltype(std::hypot((float)0, (double)0, (long)0)), double>::value), "");
1099    static_assert((std::is_same<decltype(std::hypot((float)0, (long double)0, (unsigned long)0)), long double>::value), "");
1100    static_assert((std::is_same<decltype(std::hypot((float)0, (int)0, (long long)0)), double>::value), "");
1101    static_assert((std::is_same<decltype(std::hypot((float)0, (int)0, (unsigned long long)0)), double>::value), "");
1102    static_assert((std::is_same<decltype(std::hypot((float)0, (double)0, (double)0)), double>::value), "");
1103    static_assert((std::is_same<decltype(std::hypot((float)0, (long double)0, (long double)0)), long double>::value), "");
1104    static_assert((std::is_same<decltype(std::hypot((float)0, (float)0, (double)0)), double>::value), "");
1105    static_assert((std::is_same<decltype(std::hypot((float)0, (float)0, (long double)0)), long double>::value), "");
1106    static_assert((std::is_same<decltype(std::hypot((float)0, (double)0, (long double)0)), long double>::value), "");
1107    static_assert((std::is_same<decltype(std::hypot((int)0, (int)0, (int)0)), double>::value), "");
1108    static_assert((std::is_same<decltype(hypot(Ambiguous(), Ambiguous(), Ambiguous())), Ambiguous>::value), "");
1109
1110    assert(std::hypot(2,3,6) == 7);
1111    assert(std::hypot(1,4,8) == 9);
1112#endif
1113}
1114
1115void test_ilogb()
1116{
1117    static_assert((std::is_same<decltype(std::ilogb((float)0)), int>::value), "");
1118    static_assert((std::is_same<decltype(std::ilogb((bool)0)), int>::value), "");
1119    static_assert((std::is_same<decltype(std::ilogb((unsigned short)0)), int>::value), "");
1120    static_assert((std::is_same<decltype(std::ilogb((int)0)), int>::value), "");
1121    static_assert((std::is_same<decltype(std::ilogb((unsigned int)0)), int>::value), "");
1122    static_assert((std::is_same<decltype(std::ilogb((long)0)), int>::value), "");
1123    static_assert((std::is_same<decltype(std::ilogb((unsigned long)0)), int>::value), "");
1124    static_assert((std::is_same<decltype(std::ilogb((long long)0)), int>::value), "");
1125    static_assert((std::is_same<decltype(std::ilogb((unsigned long long)0)), int>::value), "");
1126    static_assert((std::is_same<decltype(std::ilogb((double)0)), int>::value), "");
1127    static_assert((std::is_same<decltype(std::ilogb((long double)0)), int>::value), "");
1128    static_assert((std::is_same<decltype(std::ilogbf(0)), int>::value), "");
1129    static_assert((std::is_same<decltype(std::ilogbl(0)), int>::value), "");
1130    static_assert((std::is_same<decltype(ilogb(Ambiguous())), Ambiguous>::value), "");
1131    assert(std::ilogb(1) == 0);
1132}
1133
1134void test_lgamma()
1135{
1136    static_assert((std::is_same<decltype(std::lgamma((float)0)), float>::value), "");
1137    static_assert((std::is_same<decltype(std::lgamma((bool)0)), double>::value), "");
1138    static_assert((std::is_same<decltype(std::lgamma((unsigned short)0)), double>::value), "");
1139    static_assert((std::is_same<decltype(std::lgamma((int)0)), double>::value), "");
1140    static_assert((std::is_same<decltype(std::lgamma((unsigned int)0)), double>::value), "");
1141    static_assert((std::is_same<decltype(std::lgamma((long)0)), double>::value), "");
1142    static_assert((std::is_same<decltype(std::lgamma((unsigned long)0)), double>::value), "");
1143    static_assert((std::is_same<decltype(std::lgamma((long long)0)), double>::value), "");
1144    static_assert((std::is_same<decltype(std::lgamma((unsigned long long)0)), double>::value), "");
1145    static_assert((std::is_same<decltype(std::lgamma((double)0)), double>::value), "");
1146    static_assert((std::is_same<decltype(std::lgamma((long double)0)), long double>::value), "");
1147    static_assert((std::is_same<decltype(std::lgammaf(0)), float>::value), "");
1148    static_assert((std::is_same<decltype(std::lgammal(0)), long double>::value), "");
1149    static_assert((std::is_same<decltype(lgamma(Ambiguous())), Ambiguous>::value), "");
1150    assert(std::lgamma(1) == 0);
1151}
1152
1153void test_llrint()
1154{
1155    static_assert((std::is_same<decltype(std::llrint((float)0)), long long>::value), "");
1156    static_assert((std::is_same<decltype(std::llrint((bool)0)), long long>::value), "");
1157    static_assert((std::is_same<decltype(std::llrint((unsigned short)0)), long long>::value), "");
1158    static_assert((std::is_same<decltype(std::llrint((int)0)), long long>::value), "");
1159    static_assert((std::is_same<decltype(std::llrint((unsigned int)0)), long long>::value), "");
1160    static_assert((std::is_same<decltype(std::llrint((long)0)), long long>::value), "");
1161    static_assert((std::is_same<decltype(std::llrint((unsigned long)0)), long long>::value), "");
1162    static_assert((std::is_same<decltype(std::llrint((long long)0)), long long>::value), "");
1163    static_assert((std::is_same<decltype(std::llrint((unsigned long long)0)), long long>::value), "");
1164    static_assert((std::is_same<decltype(std::llrint((double)0)), long long>::value), "");
1165    static_assert((std::is_same<decltype(std::llrint((long double)0)), long long>::value), "");
1166    static_assert((std::is_same<decltype(std::llrintf(0)), long long>::value), "");
1167    static_assert((std::is_same<decltype(std::llrintl(0)), long long>::value), "");
1168    static_assert((std::is_same<decltype(llrint(Ambiguous())), Ambiguous>::value), "");
1169    assert(std::llrint(1) == 1LL);
1170}
1171
1172void test_llround()
1173{
1174    static_assert((std::is_same<decltype(std::llround((float)0)), long long>::value), "");
1175    static_assert((std::is_same<decltype(std::llround((bool)0)), long long>::value), "");
1176    static_assert((std::is_same<decltype(std::llround((unsigned short)0)), long long>::value), "");
1177    static_assert((std::is_same<decltype(std::llround((int)0)), long long>::value), "");
1178    static_assert((std::is_same<decltype(std::llround((unsigned int)0)), long long>::value), "");
1179    static_assert((std::is_same<decltype(std::llround((long)0)), long long>::value), "");
1180    static_assert((std::is_same<decltype(std::llround((unsigned long)0)), long long>::value), "");
1181    static_assert((std::is_same<decltype(std::llround((long long)0)), long long>::value), "");
1182    static_assert((std::is_same<decltype(std::llround((unsigned long long)0)), long long>::value), "");
1183    static_assert((std::is_same<decltype(std::llround((double)0)), long long>::value), "");
1184    static_assert((std::is_same<decltype(std::llround((long double)0)), long long>::value), "");
1185    static_assert((std::is_same<decltype(std::llroundf(0)), long long>::value), "");
1186    static_assert((std::is_same<decltype(std::llroundl(0)), long long>::value), "");
1187    static_assert((std::is_same<decltype(llround(Ambiguous())), Ambiguous>::value), "");
1188    assert(std::llround(1) == 1LL);
1189}
1190
1191void test_log1p()
1192{
1193    static_assert((std::is_same<decltype(std::log1p((float)0)), float>::value), "");
1194    static_assert((std::is_same<decltype(std::log1p((bool)0)), double>::value), "");
1195    static_assert((std::is_same<decltype(std::log1p((unsigned short)0)), double>::value), "");
1196    static_assert((std::is_same<decltype(std::log1p((int)0)), double>::value), "");
1197    static_assert((std::is_same<decltype(std::log1p((unsigned int)0)), double>::value), "");
1198    static_assert((std::is_same<decltype(std::log1p((long)0)), double>::value), "");
1199    static_assert((std::is_same<decltype(std::log1p((unsigned long)0)), double>::value), "");
1200    static_assert((std::is_same<decltype(std::log1p((long long)0)), double>::value), "");
1201    static_assert((std::is_same<decltype(std::log1p((unsigned long long)0)), double>::value), "");
1202    static_assert((std::is_same<decltype(std::log1p((double)0)), double>::value), "");
1203    static_assert((std::is_same<decltype(std::log1p((long double)0)), long double>::value), "");
1204    static_assert((std::is_same<decltype(std::log1pf(0)), float>::value), "");
1205    static_assert((std::is_same<decltype(std::log1pl(0)), long double>::value), "");
1206    static_assert((std::is_same<decltype(log1p(Ambiguous())), Ambiguous>::value), "");
1207    assert(std::log1p(0) == 0);
1208}
1209
1210void test_log2()
1211{
1212    static_assert((std::is_same<decltype(std::log2((float)0)), float>::value), "");
1213    static_assert((std::is_same<decltype(std::log2((bool)0)), double>::value), "");
1214    static_assert((std::is_same<decltype(std::log2((unsigned short)0)), double>::value), "");
1215    static_assert((std::is_same<decltype(std::log2((int)0)), double>::value), "");
1216    static_assert((std::is_same<decltype(std::log2((unsigned int)0)), double>::value), "");
1217    static_assert((std::is_same<decltype(std::log2((long)0)), double>::value), "");
1218    static_assert((std::is_same<decltype(std::log2((unsigned long)0)), double>::value), "");
1219    static_assert((std::is_same<decltype(std::log2((long long)0)), double>::value), "");
1220    static_assert((std::is_same<decltype(std::log2((unsigned long long)0)), double>::value), "");
1221    static_assert((std::is_same<decltype(std::log2((double)0)), double>::value), "");
1222    static_assert((std::is_same<decltype(std::log2((long double)0)), long double>::value), "");
1223    static_assert((std::is_same<decltype(std::log2f(0)), float>::value), "");
1224    static_assert((std::is_same<decltype(std::log2l(0)), long double>::value), "");
1225    static_assert((std::is_same<decltype(log2(Ambiguous())), Ambiguous>::value), "");
1226    assert(std::log2(1) == 0);
1227}
1228
1229void test_logb()
1230{
1231    static_assert((std::is_same<decltype(std::logb((float)0)), float>::value), "");
1232    static_assert((std::is_same<decltype(std::logb((bool)0)), double>::value), "");
1233    static_assert((std::is_same<decltype(std::logb((unsigned short)0)), double>::value), "");
1234    static_assert((std::is_same<decltype(std::logb((int)0)), double>::value), "");
1235    static_assert((std::is_same<decltype(std::logb((unsigned int)0)), double>::value), "");
1236    static_assert((std::is_same<decltype(std::logb((long)0)), double>::value), "");
1237    static_assert((std::is_same<decltype(std::logb((unsigned long)0)), double>::value), "");
1238    static_assert((std::is_same<decltype(std::logb((long long)0)), double>::value), "");
1239    static_assert((std::is_same<decltype(std::logb((unsigned long long)0)), double>::value), "");
1240    static_assert((std::is_same<decltype(std::logb((double)0)), double>::value), "");
1241    static_assert((std::is_same<decltype(std::logb((long double)0)), long double>::value), "");
1242    static_assert((std::is_same<decltype(std::logbf(0)), float>::value), "");
1243    static_assert((std::is_same<decltype(std::logbl(0)), long double>::value), "");
1244    static_assert((std::is_same<decltype(logb(Ambiguous())), Ambiguous>::value), "");
1245    assert(std::logb(1) == 0);
1246}
1247
1248void test_lrint()
1249{
1250    static_assert((std::is_same<decltype(std::lrint((float)0)), long>::value), "");
1251    static_assert((std::is_same<decltype(std::lrint((bool)0)), long>::value), "");
1252    static_assert((std::is_same<decltype(std::lrint((unsigned short)0)), long>::value), "");
1253    static_assert((std::is_same<decltype(std::lrint((int)0)), long>::value), "");
1254    static_assert((std::is_same<decltype(std::lrint((unsigned int)0)), long>::value), "");
1255    static_assert((std::is_same<decltype(std::lrint((long)0)), long>::value), "");
1256    static_assert((std::is_same<decltype(std::lrint((unsigned long)0)), long>::value), "");
1257    static_assert((std::is_same<decltype(std::lrint((long long)0)), long>::value), "");
1258    static_assert((std::is_same<decltype(std::lrint((unsigned long long)0)), long>::value), "");
1259    static_assert((std::is_same<decltype(std::lrint((double)0)), long>::value), "");
1260    static_assert((std::is_same<decltype(std::lrint((long double)0)), long>::value), "");
1261    static_assert((std::is_same<decltype(std::lrintf(0)), long>::value), "");
1262    static_assert((std::is_same<decltype(std::lrintl(0)), long>::value), "");
1263    static_assert((std::is_same<decltype(lrint(Ambiguous())), Ambiguous>::value), "");
1264    assert(std::lrint(1) == 1L);
1265}
1266
1267void test_lround()
1268{
1269    static_assert((std::is_same<decltype(std::lround((float)0)), long>::value), "");
1270    static_assert((std::is_same<decltype(std::lround((bool)0)), long>::value), "");
1271    static_assert((std::is_same<decltype(std::lround((unsigned short)0)), long>::value), "");
1272    static_assert((std::is_same<decltype(std::lround((int)0)), long>::value), "");
1273    static_assert((std::is_same<decltype(std::lround((unsigned int)0)), long>::value), "");
1274    static_assert((std::is_same<decltype(std::lround((long)0)), long>::value), "");
1275    static_assert((std::is_same<decltype(std::lround((unsigned long)0)), long>::value), "");
1276    static_assert((std::is_same<decltype(std::lround((long long)0)), long>::value), "");
1277    static_assert((std::is_same<decltype(std::lround((unsigned long long)0)), long>::value), "");
1278    static_assert((std::is_same<decltype(std::lround((double)0)), long>::value), "");
1279    static_assert((std::is_same<decltype(std::lround((long double)0)), long>::value), "");
1280    static_assert((std::is_same<decltype(std::lroundf(0)), long>::value), "");
1281    static_assert((std::is_same<decltype(std::lroundl(0)), long>::value), "");
1282    static_assert((std::is_same<decltype(lround(Ambiguous())), Ambiguous>::value), "");
1283    assert(std::lround(1) == 1L);
1284}
1285
1286void test_nan()
1287{
1288    static_assert((std::is_same<decltype(std::nan("")), double>::value), "");
1289    static_assert((std::is_same<decltype(std::nanf("")), float>::value), "");
1290    static_assert((std::is_same<decltype(std::nanl("")), long double>::value), "");
1291}
1292
1293void test_nearbyint()
1294{
1295    static_assert((std::is_same<decltype(std::nearbyint((float)0)), float>::value), "");
1296    static_assert((std::is_same<decltype(std::nearbyint((bool)0)), double>::value), "");
1297    static_assert((std::is_same<decltype(std::nearbyint((unsigned short)0)), double>::value), "");
1298    static_assert((std::is_same<decltype(std::nearbyint((int)0)), double>::value), "");
1299    static_assert((std::is_same<decltype(std::nearbyint((unsigned int)0)), double>::value), "");
1300    static_assert((std::is_same<decltype(std::nearbyint((long)0)), double>::value), "");
1301    static_assert((std::is_same<decltype(std::nearbyint((unsigned long)0)), double>::value), "");
1302    static_assert((std::is_same<decltype(std::nearbyint((long long)0)), double>::value), "");
1303    static_assert((std::is_same<decltype(std::nearbyint((unsigned long long)0)), double>::value), "");
1304    static_assert((std::is_same<decltype(std::nearbyint((double)0)), double>::value), "");
1305    static_assert((std::is_same<decltype(std::nearbyint((long double)0)), long double>::value), "");
1306    static_assert((std::is_same<decltype(std::nearbyintf(0)), float>::value), "");
1307    static_assert((std::is_same<decltype(std::nearbyintl(0)), long double>::value), "");
1308    static_assert((std::is_same<decltype(nearbyint(Ambiguous())), Ambiguous>::value), "");
1309    assert(std::nearbyint(1) == 1);
1310}
1311
1312void test_nextafter()
1313{
1314    static_assert((std::is_same<decltype(std::nextafter((float)0, (float)0)), float>::value), "");
1315    static_assert((std::is_same<decltype(std::nextafter((bool)0, (float)0)), double>::value), "");
1316    static_assert((std::is_same<decltype(std::nextafter((unsigned short)0, (double)0)), double>::value), "");
1317    static_assert((std::is_same<decltype(std::nextafter((int)0, (long double)0)), long double>::value), "");
1318    static_assert((std::is_same<decltype(std::nextafter((float)0, (unsigned int)0)), double>::value), "");
1319    static_assert((std::is_same<decltype(std::nextafter((double)0, (long)0)), double>::value), "");
1320    static_assert((std::is_same<decltype(std::nextafter((long double)0, (unsigned long)0)), long double>::value), "");
1321    static_assert((std::is_same<decltype(std::nextafter((int)0, (long long)0)), double>::value), "");
1322    static_assert((std::is_same<decltype(std::nextafter((int)0, (unsigned long long)0)), double>::value), "");
1323    static_assert((std::is_same<decltype(std::nextafter((double)0, (double)0)), double>::value), "");
1324    static_assert((std::is_same<decltype(std::nextafter((long double)0, (long double)0)), long double>::value), "");
1325    static_assert((std::is_same<decltype(std::nextafter((float)0, (double)0)), double>::value), "");
1326    static_assert((std::is_same<decltype(std::nextafter((float)0, (long double)0)), long double>::value), "");
1327    static_assert((std::is_same<decltype(std::nextafter((double)0, (long double)0)), long double>::value), "");
1328    static_assert((std::is_same<decltype(std::nextafterf(0,0)), float>::value), "");
1329    static_assert((std::is_same<decltype(std::nextafterl(0,0)), long double>::value), "");
1330    static_assert((std::is_same<decltype(std::nextafter((int)0, (int)0)), double>::value), "");
1331    static_assert((std::is_same<decltype(nextafter(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
1332    assert(std::nextafter(0,1) == hexfloat<double>(0x1, 0, -1074));
1333}
1334
1335void test_nexttoward()
1336{
1337    static_assert((std::is_same<decltype(std::nexttoward((float)0, (long double)0)), float>::value), "");
1338    static_assert((std::is_same<decltype(std::nexttoward((bool)0, (long double)0)), double>::value), "");
1339    static_assert((std::is_same<decltype(std::nexttoward((unsigned short)0, (long double)0)), double>::value), "");
1340    static_assert((std::is_same<decltype(std::nexttoward((int)0, (long double)0)), double>::value), "");
1341    static_assert((std::is_same<decltype(std::nexttoward((unsigned int)0, (long double)0)), double>::value), "");
1342    static_assert((std::is_same<decltype(std::nexttoward((long)0, (long double)0)), double>::value), "");
1343    static_assert((std::is_same<decltype(std::nexttoward((unsigned long)0, (long double)0)), double>::value), "");
1344    static_assert((std::is_same<decltype(std::nexttoward((long long)0, (long double)0)), double>::value), "");
1345    static_assert((std::is_same<decltype(std::nexttoward((unsigned long long)0, (long double)0)), double>::value), "");
1346    static_assert((std::is_same<decltype(std::nexttoward((double)0, (long double)0)), double>::value), "");
1347    static_assert((std::is_same<decltype(std::nexttoward((long double)0, (long double)0)), long double>::value), "");
1348    static_assert((std::is_same<decltype(std::nexttowardf(0, (long double)0)), float>::value), "");
1349    static_assert((std::is_same<decltype(std::nexttowardl(0, (long double)0)), long double>::value), "");
1350    static_assert((std::is_same<decltype(nexttoward(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
1351    assert(std::nexttoward(0, 1) == hexfloat<double>(0x1, 0, -1074));
1352}
1353
1354void test_remainder()
1355{
1356    static_assert((std::is_same<decltype(std::remainder((float)0, (float)0)), float>::value), "");
1357    static_assert((std::is_same<decltype(std::remainder((bool)0, (float)0)), double>::value), "");
1358    static_assert((std::is_same<decltype(std::remainder((unsigned short)0, (double)0)), double>::value), "");
1359    static_assert((std::is_same<decltype(std::remainder((int)0, (long double)0)), long double>::value), "");
1360    static_assert((std::is_same<decltype(std::remainder((float)0, (unsigned int)0)), double>::value), "");
1361    static_assert((std::is_same<decltype(std::remainder((double)0, (long)0)), double>::value), "");
1362    static_assert((std::is_same<decltype(std::remainder((long double)0, (unsigned long)0)), long double>::value), "");
1363    static_assert((std::is_same<decltype(std::remainder((int)0, (long long)0)), double>::value), "");
1364    static_assert((std::is_same<decltype(std::remainder((int)0, (unsigned long long)0)), double>::value), "");
1365    static_assert((std::is_same<decltype(std::remainder((double)0, (double)0)), double>::value), "");
1366    static_assert((std::is_same<decltype(std::remainder((long double)0, (long double)0)), long double>::value), "");
1367    static_assert((std::is_same<decltype(std::remainder((float)0, (double)0)), double>::value), "");
1368    static_assert((std::is_same<decltype(std::remainder((float)0, (long double)0)), long double>::value), "");
1369    static_assert((std::is_same<decltype(std::remainder((double)0, (long double)0)), long double>::value), "");
1370    static_assert((std::is_same<decltype(std::remainderf(0,0)), float>::value), "");
1371    static_assert((std::is_same<decltype(std::remainderl(0,0)), long double>::value), "");
1372    static_assert((std::is_same<decltype(std::remainder((int)0, (int)0)), double>::value), "");
1373    static_assert((std::is_same<decltype(remainder(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
1374    assert(std::remainder(0.5,1) == 0.5);
1375}
1376
1377void test_remquo()
1378{
1379    int ip;
1380    static_assert((std::is_same<decltype(std::remquo((float)0, (float)0, &ip)), float>::value), "");
1381    static_assert((std::is_same<decltype(std::remquo((bool)0, (float)0, &ip)), double>::value), "");
1382    static_assert((std::is_same<decltype(std::remquo((unsigned short)0, (double)0, &ip)), double>::value), "");
1383    static_assert((std::is_same<decltype(std::remquo((int)0, (long double)0, &ip)), long double>::value), "");
1384    static_assert((std::is_same<decltype(std::remquo((float)0, (unsigned int)0, &ip)), double>::value), "");
1385    static_assert((std::is_same<decltype(std::remquo((double)0, (long)0, &ip)), double>::value), "");
1386    static_assert((std::is_same<decltype(std::remquo((long double)0, (unsigned long)0, &ip)), long double>::value), "");
1387    static_assert((std::is_same<decltype(std::remquo((int)0, (long long)0, &ip)), double>::value), "");
1388    static_assert((std::is_same<decltype(std::remquo((int)0, (unsigned long long)0, &ip)), double>::value), "");
1389    static_assert((std::is_same<decltype(std::remquo((double)0, (double)0, &ip)), double>::value), "");
1390    static_assert((std::is_same<decltype(std::remquo((long double)0, (long double)0, &ip)), long double>::value), "");
1391    static_assert((std::is_same<decltype(std::remquo((float)0, (double)0, &ip)), double>::value), "");
1392    static_assert((std::is_same<decltype(std::remquo((float)0, (long double)0, &ip)), long double>::value), "");
1393    static_assert((std::is_same<decltype(std::remquo((double)0, (long double)0, &ip)), long double>::value), "");
1394    static_assert((std::is_same<decltype(std::remquof(0,0, &ip)), float>::value), "");
1395    static_assert((std::is_same<decltype(std::remquol(0,0, &ip)), long double>::value), "");
1396    static_assert((std::is_same<decltype(std::remquo((int)0, (int)0, &ip)), double>::value), "");
1397    static_assert((std::is_same<decltype(remquo(Ambiguous(), Ambiguous(), &ip)), Ambiguous>::value), "");
1398    assert(std::remquo(0.5,1, &ip) == 0.5);
1399}
1400
1401void test_rint()
1402{
1403    static_assert((std::is_same<decltype(std::rint((float)0)), float>::value), "");
1404    static_assert((std::is_same<decltype(std::rint((bool)0)), double>::value), "");
1405    static_assert((std::is_same<decltype(std::rint((unsigned short)0)), double>::value), "");
1406    static_assert((std::is_same<decltype(std::rint((int)0)), double>::value), "");
1407    static_assert((std::is_same<decltype(std::rint((unsigned int)0)), double>::value), "");
1408    static_assert((std::is_same<decltype(std::rint((long)0)), double>::value), "");
1409    static_assert((std::is_same<decltype(std::rint((unsigned long)0)), double>::value), "");
1410    static_assert((std::is_same<decltype(std::rint((long long)0)), double>::value), "");
1411    static_assert((std::is_same<decltype(std::rint((unsigned long long)0)), double>::value), "");
1412    static_assert((std::is_same<decltype(std::rint((double)0)), double>::value), "");
1413    static_assert((std::is_same<decltype(std::rint((long double)0)), long double>::value), "");
1414    static_assert((std::is_same<decltype(std::rintf(0)), float>::value), "");
1415    static_assert((std::is_same<decltype(std::rintl(0)), long double>::value), "");
1416    static_assert((std::is_same<decltype(rint(Ambiguous())), Ambiguous>::value), "");
1417    assert(std::rint(1) == 1);
1418}
1419
1420void test_round()
1421{
1422    static_assert((std::is_same<decltype(std::round((float)0)), float>::value), "");
1423    static_assert((std::is_same<decltype(std::round((bool)0)), double>::value), "");
1424    static_assert((std::is_same<decltype(std::round((unsigned short)0)), double>::value), "");
1425    static_assert((std::is_same<decltype(std::round((int)0)), double>::value), "");
1426    static_assert((std::is_same<decltype(std::round((unsigned int)0)), double>::value), "");
1427    static_assert((std::is_same<decltype(std::round((long)0)), double>::value), "");
1428    static_assert((std::is_same<decltype(std::round((unsigned long)0)), double>::value), "");
1429    static_assert((std::is_same<decltype(std::round((long long)0)), double>::value), "");
1430    static_assert((std::is_same<decltype(std::round((unsigned long long)0)), double>::value), "");
1431    static_assert((std::is_same<decltype(std::round((double)0)), double>::value), "");
1432    static_assert((std::is_same<decltype(std::round((long double)0)), long double>::value), "");
1433    static_assert((std::is_same<decltype(std::roundf(0)), float>::value), "");
1434    static_assert((std::is_same<decltype(std::roundl(0)), long double>::value), "");
1435    static_assert((std::is_same<decltype(round(Ambiguous())), Ambiguous>::value), "");
1436    assert(std::round(1) == 1);
1437}
1438
1439void test_scalbln()
1440{
1441    static_assert((std::is_same<decltype(std::scalbln((float)0, (long)0)), float>::value), "");
1442    static_assert((std::is_same<decltype(std::scalbln((bool)0, (long)0)), double>::value), "");
1443    static_assert((std::is_same<decltype(std::scalbln((unsigned short)0, (long)0)), double>::value), "");
1444    static_assert((std::is_same<decltype(std::scalbln((int)0, (long)0)), double>::value), "");
1445    static_assert((std::is_same<decltype(std::scalbln((unsigned int)0, (long)0)), double>::value), "");
1446    static_assert((std::is_same<decltype(std::scalbln((long)0, (long)0)), double>::value), "");
1447    static_assert((std::is_same<decltype(std::scalbln((unsigned long)0, (long)0)), double>::value), "");
1448    static_assert((std::is_same<decltype(std::scalbln((long long)0, (long)0)), double>::value), "");
1449    static_assert((std::is_same<decltype(std::scalbln((unsigned long long)0, (long)0)), double>::value), "");
1450    static_assert((std::is_same<decltype(std::scalbln((double)0, (long)0)), double>::value), "");
1451    static_assert((std::is_same<decltype(std::scalbln((long double)0, (long)0)), long double>::value), "");
1452    static_assert((std::is_same<decltype(std::scalblnf(0, (long)0)), float>::value), "");
1453    static_assert((std::is_same<decltype(std::scalblnl(0, (long)0)), long double>::value), "");
1454    static_assert((std::is_same<decltype(scalbln(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
1455    assert(std::scalbln(1, 1) == 2);
1456}
1457
1458void test_scalbn()
1459{
1460    static_assert((std::is_same<decltype(std::scalbn((float)0, (int)0)), float>::value), "");
1461    static_assert((std::is_same<decltype(std::scalbn((bool)0, (int)0)), double>::value), "");
1462    static_assert((std::is_same<decltype(std::scalbn((unsigned short)0, (int)0)), double>::value), "");
1463    static_assert((std::is_same<decltype(std::scalbn((int)0, (int)0)), double>::value), "");
1464    static_assert((std::is_same<decltype(std::scalbn((unsigned int)0, (int)0)), double>::value), "");
1465    static_assert((std::is_same<decltype(std::scalbn((long)0, (int)0)), double>::value), "");
1466    static_assert((std::is_same<decltype(std::scalbn((unsigned long)0, (int)0)), double>::value), "");
1467    static_assert((std::is_same<decltype(std::scalbn((long long)0, (int)0)), double>::value), "");
1468    static_assert((std::is_same<decltype(std::scalbn((unsigned long long)0, (int)0)), double>::value), "");
1469    static_assert((std::is_same<decltype(std::scalbn((double)0, (int)0)), double>::value), "");
1470    static_assert((std::is_same<decltype(std::scalbn((long double)0, (int)0)), long double>::value), "");
1471    static_assert((std::is_same<decltype(std::scalbnf(0, (int)0)), float>::value), "");
1472    static_assert((std::is_same<decltype(std::scalbnl(0, (int)0)), long double>::value), "");
1473    static_assert((std::is_same<decltype(scalbn(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
1474    assert(std::scalbn(1, 1) == 2);
1475}
1476
1477void test_tgamma()
1478{
1479    static_assert((std::is_same<decltype(std::tgamma((float)0)), float>::value), "");
1480    static_assert((std::is_same<decltype(std::tgamma((bool)0)), double>::value), "");
1481    static_assert((std::is_same<decltype(std::tgamma((unsigned short)0)), double>::value), "");
1482    static_assert((std::is_same<decltype(std::tgamma((int)0)), double>::value), "");
1483    static_assert((std::is_same<decltype(std::tgamma((unsigned int)0)), double>::value), "");
1484    static_assert((std::is_same<decltype(std::tgamma((long)0)), double>::value), "");
1485    static_assert((std::is_same<decltype(std::tgamma((unsigned long)0)), double>::value), "");
1486    static_assert((std::is_same<decltype(std::tgamma((long long)0)), double>::value), "");
1487    static_assert((std::is_same<decltype(std::tgamma((unsigned long long)0)), double>::value), "");
1488    static_assert((std::is_same<decltype(std::tgamma((double)0)), double>::value), "");
1489    static_assert((std::is_same<decltype(std::tgamma((long double)0)), long double>::value), "");
1490    static_assert((std::is_same<decltype(std::tgammaf(0)), float>::value), "");
1491    static_assert((std::is_same<decltype(std::tgammal(0)), long double>::value), "");
1492    static_assert((std::is_same<decltype(tgamma(Ambiguous())), Ambiguous>::value), "");
1493    assert(std::tgamma(1) == 1);
1494}
1495
1496void test_trunc()
1497{
1498    static_assert((std::is_same<decltype(std::trunc((float)0)), float>::value), "");
1499    static_assert((std::is_same<decltype(std::trunc((bool)0)), double>::value), "");
1500    static_assert((std::is_same<decltype(std::trunc((unsigned short)0)), double>::value), "");
1501    static_assert((std::is_same<decltype(std::trunc((int)0)), double>::value), "");
1502    static_assert((std::is_same<decltype(std::trunc((unsigned int)0)), double>::value), "");
1503    static_assert((std::is_same<decltype(std::trunc((long)0)), double>::value), "");
1504    static_assert((std::is_same<decltype(std::trunc((unsigned long)0)), double>::value), "");
1505    static_assert((std::is_same<decltype(std::trunc((long long)0)), double>::value), "");
1506    static_assert((std::is_same<decltype(std::trunc((unsigned long long)0)), double>::value), "");
1507    static_assert((std::is_same<decltype(std::trunc((double)0)), double>::value), "");
1508    static_assert((std::is_same<decltype(std::trunc((long double)0)), long double>::value), "");
1509    static_assert((std::is_same<decltype(std::truncf(0)), float>::value), "");
1510    static_assert((std::is_same<decltype(std::truncl(0)), long double>::value), "");
1511    static_assert((std::is_same<decltype(trunc(Ambiguous())), Ambiguous>::value), "");
1512    assert(std::trunc(1) == 1);
1513}
1514
1515int main()
1516{
1517    test_abs();
1518    test_acos();
1519    test_asin();
1520    test_atan();
1521    test_atan2();
1522    test_ceil();
1523    test_cos();
1524    test_cosh();
1525    test_exp();
1526    test_fabs();
1527    test_floor();
1528    test_fmod();
1529    test_frexp();
1530    test_ldexp();
1531    test_log();
1532    test_log10();
1533    test_modf();
1534    test_pow();
1535    test_sin();
1536    test_sinh();
1537    test_sqrt();
1538    test_tan();
1539    test_tanh();
1540    test_signbit();
1541    test_fpclassify();
1542    test_isfinite();
1543    test_isnormal();
1544    test_isgreater();
1545    test_isgreaterequal();
1546    test_isinf();
1547    test_isless();
1548    test_islessequal();
1549    test_islessgreater();
1550    test_isnan();
1551    test_isunordered();
1552    test_acosh();
1553    test_asinh();
1554    test_atanh();
1555    test_cbrt();
1556    test_copysign();
1557    test_erf();
1558    test_erfc();
1559    test_exp2();
1560    test_expm1();
1561    test_fdim();
1562    test_fma();
1563    test_fmax();
1564    test_fmin();
1565    test_hypot();
1566    test_ilogb();
1567    test_lgamma();
1568    test_llrint();
1569    test_llround();
1570    test_log1p();
1571    test_log2();
1572    test_logb();
1573    test_lrint();
1574    test_lround();
1575    test_nan();
1576    test_nearbyint();
1577    test_nextafter();
1578    test_nexttoward();
1579    test_remainder();
1580    test_remquo();
1581    test_rint();
1582    test_round();
1583    test_scalbln();
1584    test_scalbn();
1585    test_tgamma();
1586    test_trunc();
1587}
1588