1 //===----------------------------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 // This test fails because Clang no longer enables -fdelayed-template-parsing 10 // by default on Windows with C++20 (#69431). 11 // XFAIL: msvc && (clang-18 || clang-19 || clang-20) 12 13 // <math.h> 14 15 #include <math.h> 16 #include <type_traits> 17 #include <cassert> 18 19 #include "test_macros.h" 20 #include "hexfloat.h" 21 #include "truncate_fp.h" 22 #include "type_algorithms.h" 23 24 // convertible to int/float/double/etc 25 template <class T, int N=0> 26 struct Value { 27 operator T () { return T(N); } 28 }; 29 30 // See PR21083 31 // Ambiguous is a user-defined type that defines its own overloads of cmath 32 // functions. When the std overloads are candidates too (by using or adl), 33 // they should not interfere. 34 struct Ambiguous : std::true_type { // ADL 35 operator float () { return 0.f; } 36 operator double () { return 0.; } 37 }; 38 Ambiguous abs(Ambiguous){ return Ambiguous(); } 39 Ambiguous acos(Ambiguous){ return Ambiguous(); } 40 Ambiguous asin(Ambiguous){ return Ambiguous(); } 41 Ambiguous atan(Ambiguous){ return Ambiguous(); } 42 Ambiguous atan2(Ambiguous, Ambiguous){ return Ambiguous(); } 43 Ambiguous ceil(Ambiguous){ return Ambiguous(); } 44 Ambiguous cos(Ambiguous){ return Ambiguous(); } 45 Ambiguous cosh(Ambiguous){ return Ambiguous(); } 46 Ambiguous exp(Ambiguous){ return Ambiguous(); } 47 Ambiguous fabs(Ambiguous){ return Ambiguous(); } 48 Ambiguous floor(Ambiguous){ return Ambiguous(); } 49 Ambiguous fmod(Ambiguous, Ambiguous){ return Ambiguous(); } 50 Ambiguous frexp(Ambiguous, int*){ return Ambiguous(); } 51 Ambiguous ldexp(Ambiguous, int){ return Ambiguous(); } 52 Ambiguous log(Ambiguous){ return Ambiguous(); } 53 Ambiguous log10(Ambiguous){ return Ambiguous(); } 54 Ambiguous modf(Ambiguous, Ambiguous*){ return Ambiguous(); } 55 Ambiguous pow(Ambiguous, Ambiguous){ return Ambiguous(); } 56 Ambiguous sin(Ambiguous){ return Ambiguous(); } 57 Ambiguous sinh(Ambiguous){ return Ambiguous(); } 58 Ambiguous sqrt(Ambiguous){ return Ambiguous(); } 59 Ambiguous tan(Ambiguous){ return Ambiguous(); } 60 Ambiguous tanh(Ambiguous){ return Ambiguous(); } 61 Ambiguous signbit(Ambiguous){ return Ambiguous(); } 62 Ambiguous fpclassify(Ambiguous){ return Ambiguous(); } 63 Ambiguous isfinite(Ambiguous){ return Ambiguous(); } 64 Ambiguous isnormal(Ambiguous){ return Ambiguous(); } 65 Ambiguous isgreater(Ambiguous, Ambiguous){ return Ambiguous(); } 66 Ambiguous isgreaterequal(Ambiguous, Ambiguous){ return Ambiguous(); } 67 Ambiguous isless(Ambiguous, Ambiguous){ return Ambiguous(); } 68 Ambiguous islessequal(Ambiguous, Ambiguous){ return Ambiguous(); } 69 Ambiguous islessgreater(Ambiguous, Ambiguous){ return Ambiguous(); } 70 Ambiguous isunordered(Ambiguous, Ambiguous){ return Ambiguous(); } 71 Ambiguous acosh(Ambiguous){ return Ambiguous(); } 72 Ambiguous asinh(Ambiguous){ return Ambiguous(); } 73 Ambiguous atanh(Ambiguous){ return Ambiguous(); } 74 Ambiguous cbrt(Ambiguous){ return Ambiguous(); } 75 Ambiguous copysign(Ambiguous, Ambiguous){ return Ambiguous(); } 76 Ambiguous erf(Ambiguous){ return Ambiguous(); } 77 Ambiguous erfc(Ambiguous){ return Ambiguous(); } 78 Ambiguous exp2(Ambiguous){ return Ambiguous(); } 79 Ambiguous expm1(Ambiguous){ return Ambiguous(); } 80 Ambiguous fdim(Ambiguous, Ambiguous){ return Ambiguous(); } 81 Ambiguous fma(Ambiguous, Ambiguous, Ambiguous){ return Ambiguous(); } 82 Ambiguous fmax(Ambiguous, Ambiguous){ return Ambiguous(); } 83 Ambiguous fmin(Ambiguous, Ambiguous){ return Ambiguous(); } 84 Ambiguous hypot(Ambiguous, Ambiguous){ return Ambiguous(); } 85 Ambiguous ilogb(Ambiguous){ return Ambiguous(); } 86 Ambiguous lgamma(Ambiguous){ return Ambiguous(); } 87 Ambiguous llrint(Ambiguous){ return Ambiguous(); } 88 Ambiguous llround(Ambiguous){ return Ambiguous(); } 89 Ambiguous log1p(Ambiguous){ return Ambiguous(); } 90 Ambiguous log2(Ambiguous){ return Ambiguous(); } 91 Ambiguous logb(Ambiguous){ return Ambiguous(); } 92 Ambiguous lrint(Ambiguous){ return Ambiguous(); } 93 Ambiguous lround(Ambiguous){ return Ambiguous(); } 94 Ambiguous nearbyint(Ambiguous){ return Ambiguous(); } 95 Ambiguous nextafter(Ambiguous, Ambiguous){ return Ambiguous(); } 96 Ambiguous nexttoward(Ambiguous, Ambiguous){ return Ambiguous(); } 97 Ambiguous remainder(Ambiguous, Ambiguous){ return Ambiguous(); } 98 Ambiguous remquo(Ambiguous, Ambiguous, int*){ return Ambiguous(); } 99 Ambiguous rint(Ambiguous){ return Ambiguous(); } 100 Ambiguous round(Ambiguous){ return Ambiguous(); } 101 Ambiguous scalbln(Ambiguous, Ambiguous){ return Ambiguous(); } 102 Ambiguous scalbn(Ambiguous, Ambiguous){ return Ambiguous(); } 103 Ambiguous tgamma(Ambiguous){ return Ambiguous(); } 104 Ambiguous trunc(Ambiguous){ return Ambiguous(); } 105 106 template <class T, class = decltype(::abs(T()))> 107 std::true_type has_abs_imp(int); 108 template <class T> 109 std::false_type has_abs_imp(...); 110 111 template <class T> 112 struct has_abs : decltype(has_abs_imp<T>(0)) {}; 113 114 void test_abs() { 115 TEST_DIAGNOSTIC_PUSH 116 TEST_CLANG_DIAGNOSTIC_IGNORED("-Wabsolute-value") 117 118 ASSERT_SAME_TYPE(decltype(abs((float)0)), float); 119 ASSERT_SAME_TYPE(decltype(abs((double)0)), double); 120 ASSERT_SAME_TYPE(decltype(abs((long double)0)), long double); 121 ASSERT_SAME_TYPE(decltype(abs((int)0)), int); 122 ASSERT_SAME_TYPE(decltype(abs((long)0)), long); 123 ASSERT_SAME_TYPE(decltype(abs((long long)0)), long long); 124 ASSERT_SAME_TYPE(decltype(abs((unsigned char)0)), int); 125 ASSERT_SAME_TYPE(decltype(abs((unsigned short)0)), int); 126 ASSERT_SAME_TYPE(decltype(abs(Ambiguous())), Ambiguous); 127 128 static_assert(!has_abs<unsigned>::value, ""); 129 static_assert(!has_abs<unsigned long>::value, ""); 130 static_assert(!has_abs<unsigned long long>::value, ""); 131 132 TEST_DIAGNOSTIC_POP 133 134 assert(abs(-1.) == 1); 135 } 136 137 void test_acos() { 138 ASSERT_SAME_TYPE(decltype(acosf(0)), float); 139 ASSERT_SAME_TYPE(decltype(acosl(0)), long double); 140 ASSERT_SAME_TYPE(decltype(acos(Ambiguous())), Ambiguous); 141 assert(acos(1) == 0); 142 } 143 144 void test_asin() { 145 ASSERT_SAME_TYPE(decltype(asinf(0)), float); 146 ASSERT_SAME_TYPE(decltype(asinl(0)), long double); 147 ASSERT_SAME_TYPE(decltype(asin(Ambiguous())), Ambiguous); 148 assert(asin(0) == 0); 149 } 150 151 void test_atan() { 152 ASSERT_SAME_TYPE(decltype(atanf(0)), float); 153 ASSERT_SAME_TYPE(decltype(atanl(0)), long double); 154 ASSERT_SAME_TYPE(decltype(atan(Ambiguous())), Ambiguous); 155 assert(atan(0) == 0); 156 } 157 158 void test_atan2() { 159 ASSERT_SAME_TYPE(decltype(atan2f(0,0)), float); 160 ASSERT_SAME_TYPE(decltype(atan2l(0,0)), long double); 161 ASSERT_SAME_TYPE(decltype(atan2(Ambiguous(), Ambiguous())), Ambiguous); 162 assert(atan2(0,1) == 0); 163 } 164 165 void test_ceil() { 166 ASSERT_SAME_TYPE(decltype(ceilf(0)), float); 167 ASSERT_SAME_TYPE(decltype(ceill(0)), long double); 168 ASSERT_SAME_TYPE(decltype(ceil(Ambiguous())), Ambiguous); 169 assert(ceil(0) == 0); 170 } 171 172 void test_cos() { 173 ASSERT_SAME_TYPE(decltype(cosf(0)), float); 174 ASSERT_SAME_TYPE(decltype(cosl(0)), long double); 175 ASSERT_SAME_TYPE(decltype(cos(Ambiguous())), Ambiguous); 176 assert(cos(0) == 1); 177 } 178 179 void test_cosh() { 180 ASSERT_SAME_TYPE(decltype(coshf(0)), float); 181 ASSERT_SAME_TYPE(decltype(coshl(0)), long double); 182 ASSERT_SAME_TYPE(decltype(cosh(Ambiguous())), Ambiguous); 183 assert(cosh(0) == 1); 184 } 185 186 void test_exp() { 187 ASSERT_SAME_TYPE(decltype(expf(0)), float); 188 ASSERT_SAME_TYPE(decltype(expl(0)), long double); 189 ASSERT_SAME_TYPE(decltype(exp(Ambiguous())), Ambiguous); 190 assert(exp(0) == 1); 191 } 192 193 void test_fabs() { 194 ASSERT_SAME_TYPE(decltype(fabsf(0.0f)), float); 195 ASSERT_SAME_TYPE(decltype(fabsl(0.0L)), long double); 196 ASSERT_SAME_TYPE(decltype(fabs(Ambiguous())), Ambiguous); 197 assert(fabs(-1) == 1); 198 } 199 200 void test_floor() { 201 ASSERT_SAME_TYPE(decltype(floorf(0)), float); 202 ASSERT_SAME_TYPE(decltype(floorl(0)), long double); 203 ASSERT_SAME_TYPE(decltype(floor(Ambiguous())), Ambiguous); 204 assert(floor(1) == 1); 205 } 206 207 void test_fmod() { 208 ASSERT_SAME_TYPE(decltype(fmodf(0,0)), float); 209 ASSERT_SAME_TYPE(decltype(fmodl(0,0)), long double); 210 ASSERT_SAME_TYPE(decltype(fmod(Ambiguous(), Ambiguous())), Ambiguous); 211 assert(fmod(1.5,1) == .5); 212 } 213 214 void test_frexp() { 215 int ip; 216 ASSERT_SAME_TYPE(decltype(frexpf(0, &ip)), float); 217 ASSERT_SAME_TYPE(decltype(frexpl(0, &ip)), long double); 218 ASSERT_SAME_TYPE(decltype(frexp(Ambiguous(), &ip)), Ambiguous); 219 assert(frexp(0, &ip) == 0); 220 } 221 222 void test_ldexp() { 223 int ip = 1; 224 ASSERT_SAME_TYPE(decltype(ldexpf(0, ip)), float); 225 ASSERT_SAME_TYPE(decltype(ldexpl(0, ip)), long double); 226 ASSERT_SAME_TYPE(decltype(ldexp(Ambiguous(), ip)), Ambiguous); 227 assert(ldexp(1, ip) == 2); 228 } 229 230 void test_log() { 231 ASSERT_SAME_TYPE(decltype(logf(0)), float); 232 ASSERT_SAME_TYPE(decltype(logl(0)), long double); 233 ASSERT_SAME_TYPE(decltype(log(Ambiguous())), Ambiguous); 234 assert(log(1) == 0); 235 } 236 237 void test_log10() { 238 ASSERT_SAME_TYPE(decltype(log10f(0)), float); 239 ASSERT_SAME_TYPE(decltype(log10l(0)), long double); 240 ASSERT_SAME_TYPE(decltype(log10(Ambiguous())), Ambiguous); 241 assert(log10(1) == 0); 242 } 243 244 void test_modf() { 245 ASSERT_SAME_TYPE(decltype(modf((float)0, (float*)0)), float); 246 ASSERT_SAME_TYPE(decltype(modf((double)0, (double*)0)), double); 247 ASSERT_SAME_TYPE(decltype(modf((long double)0, (long double*)0)), long double); 248 ASSERT_SAME_TYPE(decltype(modff(0, (float*)0)), float); 249 ASSERT_SAME_TYPE(decltype(modfl(0, (long double*)0)), long double); 250 ASSERT_SAME_TYPE(decltype(modf(Ambiguous(), (Ambiguous*)0)), Ambiguous); 251 double i; 252 assert(modf(1., &i) == 0); 253 } 254 255 void test_pow() { 256 ASSERT_SAME_TYPE(decltype(powf(0,0)), float); 257 ASSERT_SAME_TYPE(decltype(powl(0,0)), long double); 258 ASSERT_SAME_TYPE(decltype(pow((int)0, (int)0)), double); 259 // ASSERT_SAME_TYPE(decltype(pow(Value<int>(), (int)0)), double); 260 // ASSERT_SAME_TYPE(decltype(pow(Value<long double>(), (float)0)), long double); 261 // ASSERT_SAME_TYPE(decltype(pow((float) 0, Value<float>())), float); 262 ASSERT_SAME_TYPE(decltype(pow(Ambiguous(), Ambiguous())), Ambiguous); 263 assert(pow(1,1) == 1); 264 // assert(pow(Value<int,1>(), Value<float,1>()) == 1); 265 // assert(pow(1.0f, Value<double,1>()) == 1); 266 // assert(pow(1.0, Value<int,1>()) == 1); 267 // assert(pow(Value<long double,1>(), 1LL) == 1); 268 } 269 270 void test_sin() { 271 ASSERT_SAME_TYPE(decltype(sinf(0)), float); 272 ASSERT_SAME_TYPE(decltype(sinl(0)), long double); 273 ASSERT_SAME_TYPE(decltype(sin(Ambiguous())), Ambiguous); 274 assert(sin(0) == 0); 275 } 276 277 void test_sinh() { 278 ASSERT_SAME_TYPE(decltype(sinhf(0)), float); 279 ASSERT_SAME_TYPE(decltype(sinhl(0)), long double); 280 ASSERT_SAME_TYPE(decltype(sinh(Ambiguous())), Ambiguous); 281 assert(sinh(0) == 0); 282 } 283 284 void test_sqrt() { 285 ASSERT_SAME_TYPE(decltype(sqrtf(0)), float); 286 ASSERT_SAME_TYPE(decltype(sqrtl(0)), long double); 287 ASSERT_SAME_TYPE(decltype(sqrt(Ambiguous())), Ambiguous); 288 assert(sqrt(4) == 2); 289 } 290 291 void test_tan() { 292 ASSERT_SAME_TYPE(decltype(tanf(0)), float); 293 ASSERT_SAME_TYPE(decltype(tanl(0)), long double); 294 ASSERT_SAME_TYPE(decltype(tan(Ambiguous())), Ambiguous); 295 assert(tan(0) == 0); 296 } 297 298 void test_tanh() { 299 ASSERT_SAME_TYPE(decltype(tanhf(0)), float); 300 ASSERT_SAME_TYPE(decltype(tanhl(0)), long double); 301 ASSERT_SAME_TYPE(decltype(tanh(Ambiguous())), Ambiguous); 302 assert(tanh(0) == 0); 303 } 304 305 void test_signbit() { 306 #ifdef signbit 307 #error signbit defined 308 #endif 309 ASSERT_SAME_TYPE(decltype(signbit(Ambiguous())), Ambiguous); 310 assert(signbit(-1.0) == true); 311 } 312 313 void test_fpclassify() { 314 #ifdef fpclassify 315 #error fpclassify defined 316 #endif 317 ASSERT_SAME_TYPE(decltype(fpclassify(Ambiguous())), Ambiguous); 318 assert(fpclassify(-1.0) == FP_NORMAL); 319 } 320 321 void test_isfinite() { 322 #ifdef isfinite 323 #error isfinite defined 324 #endif 325 ASSERT_SAME_TYPE(decltype(isfinite(Ambiguous())), Ambiguous); 326 assert(isfinite(-1.0) == true); 327 } 328 329 void test_isnormal() { 330 #ifdef isnormal 331 #error isnormal defined 332 #endif 333 ASSERT_SAME_TYPE(decltype(isnormal(Ambiguous())), Ambiguous); 334 assert(isnormal(-1.0) == true); 335 } 336 337 void test_isgreater() { 338 #ifdef isgreater 339 #error isgreater defined 340 #endif 341 ASSERT_SAME_TYPE(decltype(isgreater(Ambiguous(), Ambiguous())), Ambiguous); 342 assert(isgreater(-1.0, 0.F) == false); 343 } 344 345 void test_isgreaterequal() { 346 #ifdef isgreaterequal 347 #error isgreaterequal defined 348 #endif 349 ASSERT_SAME_TYPE(decltype(isgreaterequal(Ambiguous(), Ambiguous())), Ambiguous); 350 assert(isgreaterequal(-1.0, 0.F) == false); 351 } 352 353 void test_isinf() { 354 #ifdef isinf 355 #error isinf defined 356 #endif 357 ASSERT_SAME_TYPE(decltype(isinf((float)0)), bool); 358 359 typedef decltype(isinf((double)0)) DoubleRetType; 360 #ifndef __linux__ 361 ASSERT_SAME_TYPE(DoubleRetType, bool); 362 #else 363 // GLIBC < 2.26 defines 'isinf(double)' with a return type of 'int' in 364 // all C++ dialects. The test should tolerate this. 365 // See: https://sourceware.org/bugzilla/show_bug.cgi?id=19439 366 static_assert((std::is_same<DoubleRetType, bool>::value 367 || std::is_same<DoubleRetType, int>::value), ""); 368 #endif 369 370 ASSERT_SAME_TYPE(decltype(isinf(0)), bool); 371 ASSERT_SAME_TYPE(decltype(isinf((long double)0)), bool); 372 assert(isinf(-1.0) == false); 373 } 374 375 void test_isless() { 376 #ifdef isless 377 #error isless defined 378 #endif 379 ASSERT_SAME_TYPE(decltype(isless(Ambiguous(), Ambiguous())), Ambiguous); 380 assert(isless(-1.0, 0.F) == true); 381 } 382 383 void test_islessequal() { 384 #ifdef islessequal 385 #error islessequal defined 386 #endif 387 ASSERT_SAME_TYPE(decltype(islessequal(Ambiguous(), Ambiguous())), Ambiguous); 388 assert(islessequal(-1.0, 0.F) == true); 389 } 390 391 void test_islessgreater() { 392 #ifdef islessgreater 393 #error islessgreater defined 394 #endif 395 ASSERT_SAME_TYPE(decltype(islessgreater(Ambiguous(), Ambiguous())), Ambiguous); 396 assert(islessgreater(-1.0, 0.F) == true); 397 } 398 399 void test_isnan() { 400 #ifdef isnan 401 #error isnan defined 402 #endif 403 ASSERT_SAME_TYPE(decltype(isnan((float)0)), bool); 404 405 typedef decltype(isnan((double)0)) DoubleRetType; 406 #ifndef __linux__ 407 ASSERT_SAME_TYPE(DoubleRetType, bool); 408 #else 409 // GLIBC < 2.26 defines 'isnan(double)' with a return type of 'int' in 410 // all C++ dialects. The test should tolerate this. 411 // See: https://sourceware.org/bugzilla/show_bug.cgi?id=19439 412 static_assert((std::is_same<DoubleRetType, bool>::value 413 || std::is_same<DoubleRetType, int>::value), ""); 414 #endif 415 416 ASSERT_SAME_TYPE(decltype(isnan(0)), bool); 417 ASSERT_SAME_TYPE(decltype(isnan((long double)0)), bool); 418 assert(isnan(-1.0) == false); 419 } 420 421 void test_isunordered() { 422 #ifdef isunordered 423 #error isunordered defined 424 #endif 425 ASSERT_SAME_TYPE(decltype(isunordered(Ambiguous(), Ambiguous())), Ambiguous); 426 assert(isunordered(-1.0, 0.F) == false); 427 } 428 429 void test_acosh() { 430 ASSERT_SAME_TYPE(decltype(acoshf(0)), float); 431 ASSERT_SAME_TYPE(decltype(acoshl(0)), long double); 432 ASSERT_SAME_TYPE(decltype(acosh(Ambiguous())), Ambiguous); 433 assert(acosh(1) == 0); 434 } 435 436 void test_asinh() { 437 ASSERT_SAME_TYPE(decltype(asinhf(0)), float); 438 ASSERT_SAME_TYPE(decltype(asinhl(0)), long double); 439 ASSERT_SAME_TYPE(decltype(asinh(Ambiguous())), Ambiguous); 440 assert(asinh(0) == 0); 441 } 442 443 void test_atanh() { 444 ASSERT_SAME_TYPE(decltype(atanhf(0)), float); 445 ASSERT_SAME_TYPE(decltype(atanhl(0)), long double); 446 ASSERT_SAME_TYPE(decltype(atanh(Ambiguous())), Ambiguous); 447 assert(atanh(0) == 0); 448 } 449 450 void test_cbrt() { 451 ASSERT_SAME_TYPE(decltype(cbrtf(0)), float); 452 ASSERT_SAME_TYPE(decltype(cbrtl(0)), long double); 453 ASSERT_SAME_TYPE(decltype(cbrt(Ambiguous())), Ambiguous); 454 assert(truncate_fp(cbrt(1)) == 1); 455 } 456 457 void test_copysign() { 458 ASSERT_SAME_TYPE(decltype(copysignf(0,0)), float); 459 ASSERT_SAME_TYPE(decltype(copysignl(0,0)), long double); 460 ASSERT_SAME_TYPE(decltype(copysign((int)0, (int)0)), double); 461 ASSERT_SAME_TYPE(decltype(copysign(Ambiguous(), Ambiguous())), Ambiguous); 462 assert(copysign(1,1) == 1); 463 } 464 465 void test_erf() { 466 ASSERT_SAME_TYPE(decltype(erff(0)), float); 467 ASSERT_SAME_TYPE(decltype(erfl(0)), long double); 468 ASSERT_SAME_TYPE(decltype(erf(Ambiguous())), Ambiguous); 469 assert(erf(0) == 0); 470 } 471 472 void test_erfc() { 473 ASSERT_SAME_TYPE(decltype(erfcf(0)), float); 474 ASSERT_SAME_TYPE(decltype(erfcl(0)), long double); 475 ASSERT_SAME_TYPE(decltype(erfc(Ambiguous())), Ambiguous); 476 assert(erfc(0) == 1); 477 } 478 479 void test_exp2() { 480 ASSERT_SAME_TYPE(decltype(exp2f(0)), float); 481 ASSERT_SAME_TYPE(decltype(exp2l(0)), long double); 482 ASSERT_SAME_TYPE(decltype(exp2(Ambiguous())), Ambiguous); 483 assert(exp2(1) == 2); 484 } 485 486 void test_expm1() { 487 ASSERT_SAME_TYPE(decltype(expm1f(0)), float); 488 ASSERT_SAME_TYPE(decltype(expm1l(0)), long double); 489 ASSERT_SAME_TYPE(decltype(expm1(Ambiguous())), Ambiguous); 490 assert(expm1(0) == 0); 491 } 492 493 void test_fdim() { 494 ASSERT_SAME_TYPE(decltype(fdimf(0,0)), float); 495 ASSERT_SAME_TYPE(decltype(fdiml(0,0)), long double); 496 ASSERT_SAME_TYPE(decltype(fdim((int)0, (int)0)), double); 497 ASSERT_SAME_TYPE(decltype(fdim(Ambiguous(), Ambiguous())), Ambiguous); 498 assert(fdim(1,0) == 1); 499 } 500 501 void test_fma() { 502 ASSERT_SAME_TYPE(decltype(fma((bool)0, (float)0, (float)0)), double); 503 ASSERT_SAME_TYPE(decltype(fma((float)0, (float)0, (double)0)), double); 504 ASSERT_SAME_TYPE(decltype(fma((float)0, (float)0, (long double)0)), long double); 505 ASSERT_SAME_TYPE(decltype(fma((float)0, (float)0, (float)0)), float); 506 507 ASSERT_SAME_TYPE(decltype(fma((bool)0, (double)0, (double)0)), double); 508 ASSERT_SAME_TYPE(decltype(fma((double)0, (double)0, (float)0)), double); 509 ASSERT_SAME_TYPE(decltype(fma((double)0, (double)0, (long double)0)), long double); 510 ASSERT_SAME_TYPE(decltype(fma((double)0, (double)0, (double)0)), double); 511 512 ASSERT_SAME_TYPE(decltype(fma((long double)0, (long double)0, (float)0)), long double); 513 ASSERT_SAME_TYPE(decltype(fma((double)0, (long double)0, (long double)0)), long double); 514 ASSERT_SAME_TYPE(decltype(fma((long double)0, (long double)0, (long double)0)), long double); 515 516 ASSERT_SAME_TYPE(decltype(fmaf(0,0,0)), float); 517 ASSERT_SAME_TYPE(decltype(fmal(0,0,0)), long double); 518 ASSERT_SAME_TYPE(decltype(fma(Ambiguous(), Ambiguous(), Ambiguous())), Ambiguous); 519 assert(fma(1,1,1) == 2); 520 } 521 522 void test_fmax() { 523 ASSERT_SAME_TYPE(decltype(fmaxf(0,0)), float); 524 ASSERT_SAME_TYPE(decltype(fmaxl(0,0)), long double); 525 ASSERT_SAME_TYPE(decltype(fmax((int)0, (int)0)), double); 526 ASSERT_SAME_TYPE(decltype(fmax(Ambiguous(), Ambiguous())), Ambiguous); 527 assert(fmax(1,0) == 1); 528 } 529 530 void test_fmin() { 531 ASSERT_SAME_TYPE(decltype(fminf(0,0)), float); 532 ASSERT_SAME_TYPE(decltype(fminl(0,0)), long double); 533 ASSERT_SAME_TYPE(decltype(fmin((int)0, (int)0)), double); 534 ASSERT_SAME_TYPE(decltype(fmin(Ambiguous(), Ambiguous())), Ambiguous); 535 assert(fmin(1,0) == 0); 536 } 537 538 void test_hypot() { 539 ASSERT_SAME_TYPE(decltype(hypotf(0,0)), float); 540 ASSERT_SAME_TYPE(decltype(hypotl(0,0)), long double); 541 ASSERT_SAME_TYPE(decltype(hypot((int)0, (int)0)), double); 542 ASSERT_SAME_TYPE(decltype(hypot(Ambiguous(), Ambiguous())), Ambiguous); 543 assert(hypot(3,4) == 5); 544 } 545 546 void test_ilogb() { 547 ASSERT_SAME_TYPE(decltype(ilogbf(0)), int); 548 ASSERT_SAME_TYPE(decltype(ilogbl(0)), int); 549 ASSERT_SAME_TYPE(decltype(ilogb(Ambiguous())), Ambiguous); 550 assert(ilogb(1) == 0); 551 } 552 553 void test_lgamma() { 554 ASSERT_SAME_TYPE(decltype(lgammaf(0)), float); 555 ASSERT_SAME_TYPE(decltype(lgammal(0)), long double); 556 ASSERT_SAME_TYPE(decltype(lgamma(Ambiguous())), Ambiguous); 557 assert(lgamma(1) == 0); 558 } 559 560 void test_llrint() { 561 ASSERT_SAME_TYPE(decltype(llrintf(0)), long long); 562 ASSERT_SAME_TYPE(decltype(llrintl(0)), long long); 563 ASSERT_SAME_TYPE(decltype(llrint(Ambiguous())), Ambiguous); 564 assert(llrint(1) == 1LL); 565 } 566 567 void test_llround() { 568 ASSERT_SAME_TYPE(decltype(llroundf(0)), long long); 569 ASSERT_SAME_TYPE(decltype(llroundl(0)), long long); 570 ASSERT_SAME_TYPE(decltype(llround(Ambiguous())), Ambiguous); 571 assert(llround(1) == 1LL); 572 } 573 574 void test_log1p() { 575 ASSERT_SAME_TYPE(decltype(log1pf(0)), float); 576 ASSERT_SAME_TYPE(decltype(log1pl(0)), long double); 577 ASSERT_SAME_TYPE(decltype(log1p(Ambiguous())), Ambiguous); 578 assert(log1p(0) == 0); 579 } 580 581 void test_log2() { 582 ASSERT_SAME_TYPE(decltype(log2f(0)), float); 583 ASSERT_SAME_TYPE(decltype(log2l(0)), long double); 584 ASSERT_SAME_TYPE(decltype(log2(Ambiguous())), Ambiguous); 585 assert(log2(1) == 0); 586 } 587 588 void test_logb() { 589 ASSERT_SAME_TYPE(decltype(logbf(0)), float); 590 ASSERT_SAME_TYPE(decltype(logbl(0)), long double); 591 ASSERT_SAME_TYPE(decltype(logb(Ambiguous())), Ambiguous); 592 assert(logb(1) == 0); 593 } 594 595 void test_lrint() { 596 ASSERT_SAME_TYPE(decltype(lrintf(0)), long); 597 ASSERT_SAME_TYPE(decltype(lrintl(0)), long); 598 ASSERT_SAME_TYPE(decltype(lrint(Ambiguous())), Ambiguous); 599 assert(lrint(1) == 1L); 600 } 601 602 void test_lround() { 603 ASSERT_SAME_TYPE(decltype(lroundf(0)), long); 604 ASSERT_SAME_TYPE(decltype(lroundl(0)), long); 605 ASSERT_SAME_TYPE(decltype(lround(Ambiguous())), Ambiguous); 606 assert(lround(1) == 1L); 607 } 608 609 void test_nan() { 610 ASSERT_SAME_TYPE(decltype(nan("")), double); 611 ASSERT_SAME_TYPE(decltype(nanf("")), float); 612 ASSERT_SAME_TYPE(decltype(nanl("")), long double); 613 } 614 615 void test_nearbyint() { 616 ASSERT_SAME_TYPE(decltype(nearbyintf(0)), float); 617 ASSERT_SAME_TYPE(decltype(nearbyintl(0)), long double); 618 ASSERT_SAME_TYPE(decltype(nearbyint(Ambiguous())), Ambiguous); 619 assert(nearbyint(1) == 1); 620 } 621 622 void test_nextafter() { 623 ASSERT_SAME_TYPE(decltype(nextafterf(0,0)), float); 624 ASSERT_SAME_TYPE(decltype(nextafterl(0,0)), long double); 625 ASSERT_SAME_TYPE(decltype(nextafter((int)0, (int)0)), double); 626 ASSERT_SAME_TYPE(decltype(nextafter(Ambiguous(), Ambiguous())), Ambiguous); 627 assert(nextafter(0,1) == hexfloat<double>(0x1, 0, -1074)); 628 } 629 630 void test_nexttoward() { 631 ASSERT_SAME_TYPE(decltype(nexttoward((float)0, (long double)0)), float); 632 ASSERT_SAME_TYPE(decltype(nexttoward((bool)0, (long double)0)), double); 633 ASSERT_SAME_TYPE(decltype(nexttoward((unsigned short)0, (long double)0)), double); 634 ASSERT_SAME_TYPE(decltype(nexttoward((int)0, (long double)0)), double); 635 ASSERT_SAME_TYPE(decltype(nexttoward((unsigned int)0, (long double)0)), double); 636 ASSERT_SAME_TYPE(decltype(nexttoward((long)0, (long double)0)), double); 637 ASSERT_SAME_TYPE(decltype(nexttoward((unsigned long)0, (long double)0)), double); 638 ASSERT_SAME_TYPE(decltype(nexttoward((long long)0, (long double)0)), double); 639 ASSERT_SAME_TYPE(decltype(nexttoward((unsigned long long)0, (long double)0)), double); 640 ASSERT_SAME_TYPE(decltype(nexttoward((double)0, (long double)0)), double); 641 ASSERT_SAME_TYPE(decltype(nexttoward((long double)0, (long double)0)), long double); 642 ASSERT_SAME_TYPE(decltype(nexttowardf(0, (long double)0)), float); 643 ASSERT_SAME_TYPE(decltype(nexttowardl(0, (long double)0)), long double); 644 ASSERT_SAME_TYPE(decltype(nexttoward(Ambiguous(), Ambiguous())), Ambiguous); 645 assert(nexttoward(0, 1) == hexfloat<double>(0x1, 0, -1074)); 646 } 647 648 void test_remainder() { 649 ASSERT_SAME_TYPE(decltype(remainderf(0,0)), float); 650 ASSERT_SAME_TYPE(decltype(remainderl(0,0)), long double); 651 ASSERT_SAME_TYPE(decltype(remainder((int)0, (int)0)), double); 652 ASSERT_SAME_TYPE(decltype(remainder(Ambiguous(), Ambiguous())), Ambiguous); 653 assert(remainder(0.5,1) == 0.5); 654 } 655 656 void test_remquo() { 657 int ip; 658 ASSERT_SAME_TYPE(decltype(remquof(0,0, &ip)), float); 659 ASSERT_SAME_TYPE(decltype(remquol(0,0, &ip)), long double); 660 ASSERT_SAME_TYPE(decltype(remquo((int)0, (int)0, &ip)), double); 661 ASSERT_SAME_TYPE(decltype(remquo(Ambiguous(), Ambiguous(), &ip)), Ambiguous); 662 assert(remquo(0.5,1, &ip) == 0.5); 663 } 664 665 void test_rint() { 666 ASSERT_SAME_TYPE(decltype(rintf(0)), float); 667 ASSERT_SAME_TYPE(decltype(rintl(0)), long double); 668 ASSERT_SAME_TYPE(decltype(rint(Ambiguous())), Ambiguous); 669 assert(rint(1) == 1); 670 } 671 672 void test_round() { 673 ASSERT_SAME_TYPE(decltype(roundf(0)), float); 674 ASSERT_SAME_TYPE(decltype(roundl(0)), long double); 675 ASSERT_SAME_TYPE(decltype(round(Ambiguous())), Ambiguous); 676 assert(round(1) == 1); 677 } 678 679 void test_scalbln() { 680 ASSERT_SAME_TYPE(decltype(scalbln((float)0, (long)0)), float); 681 ASSERT_SAME_TYPE(decltype(scalbln((bool)0, (long)0)), double); 682 ASSERT_SAME_TYPE(decltype(scalbln((unsigned short)0, (long)0)), double); 683 ASSERT_SAME_TYPE(decltype(scalbln((int)0, (long)0)), double); 684 ASSERT_SAME_TYPE(decltype(scalbln((unsigned int)0, (long)0)), double); 685 ASSERT_SAME_TYPE(decltype(scalbln((long)0, (long)0)), double); 686 ASSERT_SAME_TYPE(decltype(scalbln((unsigned long)0, (long)0)), double); 687 ASSERT_SAME_TYPE(decltype(scalbln((long long)0, (long)0)), double); 688 ASSERT_SAME_TYPE(decltype(scalbln((unsigned long long)0, (long)0)), double); 689 ASSERT_SAME_TYPE(decltype(scalbln((double)0, (long)0)), double); 690 ASSERT_SAME_TYPE(decltype(scalbln((long double)0, (long)0)), long double); 691 ASSERT_SAME_TYPE(decltype(scalblnf(0, (long)0)), float); 692 ASSERT_SAME_TYPE(decltype(scalblnl(0, (long)0)), long double); 693 ASSERT_SAME_TYPE(decltype(scalbln(Ambiguous(), Ambiguous())), Ambiguous); 694 assert(scalbln(1, 1) == 2); 695 } 696 697 void test_scalbn() { 698 ASSERT_SAME_TYPE(decltype(scalbn((float)0, (int)0)), float); 699 ASSERT_SAME_TYPE(decltype(scalbn((bool)0, (int)0)), double); 700 ASSERT_SAME_TYPE(decltype(scalbn((unsigned short)0, (int)0)), double); 701 ASSERT_SAME_TYPE(decltype(scalbn((int)0, (int)0)), double); 702 ASSERT_SAME_TYPE(decltype(scalbn((unsigned int)0, (int)0)), double); 703 ASSERT_SAME_TYPE(decltype(scalbn((long)0, (int)0)), double); 704 ASSERT_SAME_TYPE(decltype(scalbn((unsigned long)0, (int)0)), double); 705 ASSERT_SAME_TYPE(decltype(scalbn((long long)0, (int)0)), double); 706 ASSERT_SAME_TYPE(decltype(scalbn((unsigned long long)0, (int)0)), double); 707 ASSERT_SAME_TYPE(decltype(scalbn((double)0, (int)0)), double); 708 ASSERT_SAME_TYPE(decltype(scalbn((long double)0, (int)0)), long double); 709 ASSERT_SAME_TYPE(decltype(scalbnf(0, (int)0)), float); 710 ASSERT_SAME_TYPE(decltype(scalbnl(0, (int)0)), long double); 711 ASSERT_SAME_TYPE(decltype(scalbn(Ambiguous(), Ambiguous())), Ambiguous); 712 assert(scalbn(1, 1) == 2); 713 } 714 715 void test_tgamma() { 716 ASSERT_SAME_TYPE(decltype(tgammaf(0)), float); 717 ASSERT_SAME_TYPE(decltype(tgammal(0)), long double); 718 ASSERT_SAME_TYPE(decltype(tgamma(Ambiguous())), Ambiguous); 719 assert(tgamma(1) == 1); 720 } 721 722 void test_trunc() { 723 ASSERT_SAME_TYPE(decltype(truncf(0)), float); 724 ASSERT_SAME_TYPE(decltype(truncl(0)), long double); 725 ASSERT_SAME_TYPE(decltype(trunc(Ambiguous())), Ambiguous); 726 assert(trunc(1) == 1); 727 } 728 729 template <class PromoteResult, class Arg = void> 730 struct test_single_arg { 731 template <class T = Arg> 732 void operator()() { 733 ASSERT_SAME_TYPE(decltype(::acos(T())), PromoteResult); 734 (void)::acos(T()); 735 ASSERT_SAME_TYPE(decltype(::asin(T())), PromoteResult); 736 (void)::asin(T()); 737 ASSERT_SAME_TYPE(decltype(::atan(T())), PromoteResult); 738 (void)::atan(T()); 739 ASSERT_SAME_TYPE(decltype(::ceil(T())), PromoteResult); 740 (void)::ceil(T()); 741 ASSERT_SAME_TYPE(decltype(::cos(T())), PromoteResult); 742 (void)::cos(T()); 743 ASSERT_SAME_TYPE(decltype(::cosh(T())), PromoteResult); 744 (void)::cosh(T()); 745 ASSERT_SAME_TYPE(decltype(::exp(T())), PromoteResult); 746 (void)::exp(T()); 747 ASSERT_SAME_TYPE(decltype(::fabs(T())), PromoteResult); 748 (void)::fabs(T()); 749 ASSERT_SAME_TYPE(decltype(::floor(T())), PromoteResult); 750 (void)::floor(T()); 751 int ip; 752 ASSERT_SAME_TYPE(decltype(::frexp(T(), &ip)), PromoteResult); 753 (void)::frexp(T(), &ip); 754 ASSERT_SAME_TYPE(decltype(::ldexp(T(), ip)), PromoteResult); 755 (void)::ldexp(T(), ip); 756 ASSERT_SAME_TYPE(decltype(::log(T())), PromoteResult); 757 (void)::log(T()); 758 ASSERT_SAME_TYPE(decltype(::log10(T())), PromoteResult); 759 (void)::log10(T()); 760 ASSERT_SAME_TYPE(decltype(::sin(T())), PromoteResult); 761 (void)::sin(T()); 762 ASSERT_SAME_TYPE(decltype(::sinh(T())), PromoteResult); 763 (void)::sinh(T()); 764 ASSERT_SAME_TYPE(decltype(::sqrt(T())), PromoteResult); 765 (void)::sqrt(T()); 766 ASSERT_SAME_TYPE(decltype(::tan(T())), PromoteResult); 767 (void)::tan(T()); 768 ASSERT_SAME_TYPE(decltype(::tanh(T())), PromoteResult); 769 (void)::tanh(T()); 770 ASSERT_SAME_TYPE(decltype(::signbit(T())), bool); 771 (void)::signbit(T()); 772 ASSERT_SAME_TYPE(decltype(::fpclassify(T())), int); 773 (void)::fpclassify(T()); 774 ASSERT_SAME_TYPE(decltype(::isfinite(T())), bool); 775 (void)::isfinite(T()); 776 ASSERT_SAME_TYPE(decltype(::isnormal(T())), bool); 777 (void)::isnormal(T()); 778 ASSERT_SAME_TYPE(decltype(::acosh(T())), PromoteResult); 779 (void)::acosh(T()); 780 ASSERT_SAME_TYPE(decltype(::asinh(T())), PromoteResult); 781 (void)::asinh(T()); 782 ASSERT_SAME_TYPE(decltype(::atanh(T())), PromoteResult); 783 (void)::atanh(T()); 784 ASSERT_SAME_TYPE(decltype(::cbrt(T())), PromoteResult); 785 (void)::cbrt(T()); 786 ASSERT_SAME_TYPE(decltype(::erf(T())), PromoteResult); 787 (void)::erf(T()); 788 ASSERT_SAME_TYPE(decltype(::erfc(T())), PromoteResult); 789 (void)::erfc(T()); 790 ASSERT_SAME_TYPE(decltype(::exp2(T())), PromoteResult); 791 (void)::exp2(T()); 792 ASSERT_SAME_TYPE(decltype(::expm1(T())), PromoteResult); 793 (void)::expm1(T()); 794 ASSERT_SAME_TYPE(decltype(::ilogb(T())), int); 795 (void)::ilogb(T()); 796 ASSERT_SAME_TYPE(decltype(::lgamma(T())), PromoteResult); 797 (void)::lgamma(T()); 798 ASSERT_SAME_TYPE(decltype(::llrint(T())), long long); 799 (void)::llrint(T()); 800 ASSERT_SAME_TYPE(decltype(::llround(T())), long long); 801 (void)::llround(T()); 802 ASSERT_SAME_TYPE(decltype(::log1p(T())), PromoteResult); 803 (void)::log1p(T()); 804 ASSERT_SAME_TYPE(decltype(::log2(T())), PromoteResult); 805 (void)::log2(T()); 806 ASSERT_SAME_TYPE(decltype(::logb(T())), PromoteResult); 807 (void)::logb(T()); 808 ASSERT_SAME_TYPE(decltype(::lrint(T())), long); 809 (void)::lrint(T()); 810 ASSERT_SAME_TYPE(decltype(::lround(T())), long); 811 (void)::lround(T()); 812 ASSERT_SAME_TYPE(decltype(::nearbyint(T())), PromoteResult); 813 (void)::nearbyint(T()); 814 ASSERT_SAME_TYPE(decltype(::rint(T())), PromoteResult); 815 (void)::rint(T()); 816 ASSERT_SAME_TYPE(decltype(::round(T())), PromoteResult); 817 (void)::round(T()); 818 ASSERT_SAME_TYPE(decltype(::trunc(T())), PromoteResult); 819 (void)::trunc(T()); 820 ASSERT_SAME_TYPE(decltype(::tgamma(T())), PromoteResult); 821 (void)::tgamma(T()); 822 } 823 }; 824 825 template <class PromoteResult, class Arg1 = void, class Arg2 = void> 826 struct test_two_args { 827 template <class T = Arg1, class U = Arg2> 828 void operator()() { 829 ASSERT_SAME_TYPE(decltype(::atan2(T(), U())), PromoteResult); 830 (void)::atan2(T(), U()); 831 ASSERT_SAME_TYPE(decltype(::fmod(T(), U())), PromoteResult); 832 (void)::fmod(T(), U()); 833 ASSERT_SAME_TYPE(decltype(::pow(T(), U())), PromoteResult); 834 (void)::pow(T(), U()); 835 ASSERT_SAME_TYPE(decltype(::isgreater(T(), U())), bool); 836 (void)::isgreater(T(), U()); 837 ASSERT_SAME_TYPE(decltype(::isgreaterequal(T(), U())), bool); 838 (void)::isgreaterequal(T(), U()); 839 ASSERT_SAME_TYPE(decltype(::isless(T(), U())), bool); 840 (void)::isless(T(), U()); 841 ASSERT_SAME_TYPE(decltype(::islessequal(T(), U())), bool); 842 (void)::islessequal(T(), U()); 843 ASSERT_SAME_TYPE(decltype(::islessgreater(T(), U())), bool); 844 (void)::islessgreater(T(), U()); 845 ASSERT_SAME_TYPE(decltype(::isunordered(T(), U())), bool); 846 (void)::isunordered(T(), U()); 847 ASSERT_SAME_TYPE(decltype(::copysign(T(), U())), PromoteResult); 848 (void)::copysign(T(), U()); 849 ASSERT_SAME_TYPE(decltype(::fdim(T(), U())), PromoteResult); 850 (void)::fdim(T(), U()); 851 ASSERT_SAME_TYPE(decltype(::fmax(T(), U())), PromoteResult); 852 (void)::fmax(T(), U()); 853 ASSERT_SAME_TYPE(decltype(::fmin(T(), U())), PromoteResult); 854 (void)::fmin(T(), U()); 855 ASSERT_SAME_TYPE(decltype(::hypot(T(), U())), PromoteResult); 856 (void)::hypot(T(), U()); 857 ASSERT_SAME_TYPE(decltype(::nextafter(T(), U())), PromoteResult); 858 (void)::nextafter(T(), U()); 859 ASSERT_SAME_TYPE(decltype(::remainder(T(), U())), PromoteResult); 860 (void)::remainder(T(), U()); 861 int ip; 862 ASSERT_SAME_TYPE(decltype(::remquo(T(), U(), &ip)), PromoteResult); 863 ::remquo(T(), U(), &ip); 864 } 865 }; 866 867 template <class PromoteResult, class Arg1 = void, class Arg2 = void, class Arg3 = void> 868 struct test_three_args { 869 template <class T = Arg1, class U = Arg2, class V = Arg3> 870 void operator()() { 871 ASSERT_SAME_TYPE(decltype(::fma(T(), U(), V())), PromoteResult); 872 (void)::fma(T(), U(), V()); 873 } 874 }; 875 876 struct CallTwoArgs { 877 using integral_float_double = types::concatenate_t<types::integral_types, types::type_list<float, double> >; 878 879 template <class Arg2> 880 void operator()() { 881 types::for_each(integral_float_double(), test_two_args</*PromoteResult=*/double, /*Iterate*/void, Arg2>()); 882 } 883 }; 884 885 template <class T> 886 struct CallThreeArgs { 887 using integral_float_double = types::concatenate_t<types::integral_types, types::type_list<float, double> >; 888 889 template <class Arg3> 890 struct Helper { 891 892 template <class Arg2> 893 void operator()() { 894 types::for_each(integral_float_double(), test_three_args</*PromoteResult=*/double, /*Iterate*/void, Arg2, Arg3>()); 895 } 896 }; 897 898 template <class Arg3> 899 void operator()() { 900 types::for_each(integral_float_double(), Helper<Arg3>()); 901 } 902 }; 903 904 int main(int, char**) { 905 types::for_each(types::integral_types(), test_single_arg</*PromoteResult=*/double>()); 906 test_single_arg</*PromoteResult=*/float, /*Arg=*/float>(); 907 test_single_arg</*PromoteResult=*/double, /*Arg=*/double>(); 908 test_single_arg</*PromoteResult=*/long double, /*Arg=*/long double>(); 909 910 types::for_each(types::integral_types(), CallTwoArgs()); 911 912 types::for_each( 913 types::integral_types(), test_two_args</*PromoteResult=*/long double, /*Arg1=*/void, /*Arg2=*/long double>()); 914 915 test_two_args</*PromoteResult=*/float, /*Args=*/float, float>(); 916 test_two_args</*PromoteResult=*/float, /*Args=*/double, double>(); 917 test_two_args</*PromoteResult=*/double, /*Args=*/float, double>(); 918 test_two_args</*PromoteResult=*/double, /*Args=*/double, double>(); 919 920 types::for_each(types::integral_types(), CallThreeArgs<double>()); 921 types::for_each( 922 types::integral_types(), test_three_args</*PromoteResult=*/long double, /*Iterate*/ void, long double, double>()); 923 924 test_three_args</*PromoteResult=*/float, /*Args=*/float, float, float>(); 925 test_three_args</*PromoteResult=*/double, /*Args=*/double, double, double>(); 926 test_three_args</*PromoteResult=*/long double, /*Args=*/long double, long double, long double>(); 927 928 test_abs(); 929 test_acos(); 930 test_asin(); 931 test_atan(); 932 test_atan2(); 933 test_ceil(); 934 test_cos(); 935 test_cosh(); 936 test_exp(); 937 test_fabs(); 938 test_floor(); 939 test_fmod(); 940 test_frexp(); 941 test_ldexp(); 942 test_log(); 943 test_log10(); 944 test_modf(); 945 test_pow(); 946 test_sin(); 947 test_sinh(); 948 test_sqrt(); 949 test_tan(); 950 test_tanh(); 951 test_signbit(); 952 test_fpclassify(); 953 test_isfinite(); 954 test_isnormal(); 955 test_isgreater(); 956 test_isgreaterequal(); 957 test_isinf(); 958 test_isless(); 959 test_islessequal(); 960 test_islessgreater(); 961 test_isnan(); 962 test_isunordered(); 963 test_acosh(); 964 test_asinh(); 965 test_atanh(); 966 test_cbrt(); 967 test_copysign(); 968 test_erf(); 969 test_erfc(); 970 test_exp2(); 971 test_expm1(); 972 test_fdim(); 973 test_fma(); 974 test_fmax(); 975 test_fmin(); 976 test_hypot(); 977 test_ilogb(); 978 test_lgamma(); 979 test_llrint(); 980 test_llround(); 981 test_log1p(); 982 test_log2(); 983 test_logb(); 984 test_lrint(); 985 test_lround(); 986 test_nan(); 987 test_nearbyint(); 988 test_nextafter(); 989 test_nexttoward(); 990 test_remainder(); 991 test_remquo(); 992 test_rint(); 993 test_round(); 994 test_scalbln(); 995 test_scalbn(); 996 test_tgamma(); 997 test_trunc(); 998 999 return 0; 1000 } 1001