1 /* A GNU-like <math.h>. 2 3 Copyright (C) 2002-2003, 2007-2020 Free Software Foundation, Inc. 4 5 This program is free software: you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by 7 the Free Software Foundation; either version 3 of the License, or 8 (at your option) any later version. 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program. If not, see <https://www.gnu.org/licenses/>. */ 17 18 #ifndef _@GUARD_PREFIX@_MATH_H 19 20 #if __GNUC__ >= 3 21 @PRAGMA_SYSTEM_HEADER@ 22 #endif 23 @PRAGMA_COLUMNS@ 24 25 /* The include_next requires a split double-inclusion guard. */ 26 #@INCLUDE_NEXT_AS_FIRST_DIRECTIVE@ @NEXT_AS_FIRST_DIRECTIVE_MATH_H@ 27 28 #ifndef _@GUARD_PREFIX@_MATH_H 29 #define _@GUARD_PREFIX@_MATH_H 30 31 /* On OpenVMS, NAN, INFINITY, and HUGEVAL macros are defined in <fp.h>. */ 32 #if defined __VMS && ! defined NAN 33 # include <fp.h> 34 #endif 35 36 #ifndef _GL_INLINE_HEADER_BEGIN 37 #error "Please include config.h first." 38 #endif 39 _GL_INLINE_HEADER_BEGIN 40 #ifndef _GL_MATH_INLINE 41 # define _GL_MATH_INLINE _GL_INLINE 42 #endif 43 44 /* The definitions of _GL_FUNCDECL_RPL etc. are copied here. */ 45 46 /* The definition of _GL_ARG_NONNULL is copied here. */ 47 48 /* The definition of _GL_WARN_ON_USE is copied here. */ 49 50 #ifdef __cplusplus 51 /* Helper macros to define type-generic function FUNC as overloaded functions, 52 rather than as macros like in C. POSIX declares these with an argument of 53 real-floating (that is, one of float, double, or long double). */ 54 # define _GL_MATH_CXX_REAL_FLOATING_DECL_1(func) \ 55 static inline int \ 56 _gl_cxx_ ## func ## f (float f) \ 57 { \ 58 return func (f); \ 59 } \ 60 static inline int \ 61 _gl_cxx_ ## func ## d (double d) \ 62 { \ 63 return func (d); \ 64 } \ 65 static inline int \ 66 _gl_cxx_ ## func ## l (long double l) \ 67 { \ 68 return func (l); \ 69 } 70 # define _GL_MATH_CXX_REAL_FLOATING_DECL_2(func,rpl_func,rettype) \ 71 _GL_BEGIN_NAMESPACE \ 72 inline rettype \ 73 rpl_func (float f) \ 74 { \ 75 return _gl_cxx_ ## func ## f (f); \ 76 } \ 77 inline rettype \ 78 rpl_func (double d) \ 79 { \ 80 return _gl_cxx_ ## func ## d (d); \ 81 } \ 82 inline rettype \ 83 rpl_func (long double l) \ 84 { \ 85 return _gl_cxx_ ## func ## l (l); \ 86 } \ 87 _GL_END_NAMESPACE 88 #endif 89 90 /* Helper macros to define a portability warning for the 91 classification macro FUNC called with VALUE. POSIX declares the 92 classification macros with an argument of real-floating (that is, 93 one of float, double, or long double). */ 94 #define _GL_WARN_REAL_FLOATING_DECL(func) \ 95 _GL_MATH_INLINE int \ 96 _GL_WARN_ON_USE_ATTRIBUTE (#func " is unportable - " \ 97 "use gnulib module " #func " for portability") \ 98 rpl_ ## func ## f (float f) \ 99 { \ 100 return func (f); \ 101 } \ 102 _GL_MATH_INLINE int \ 103 _GL_WARN_ON_USE_ATTRIBUTE (#func " is unportable - " \ 104 "use gnulib module " #func " for portability") \ 105 rpl_ ## func ## d (double d) \ 106 { \ 107 return func (d); \ 108 } \ 109 _GL_MATH_INLINE int \ 110 _GL_WARN_ON_USE_ATTRIBUTE (#func " is unportable - " \ 111 "use gnulib module " #func " for portability") \ 112 rpl_ ## func ## l (long double l) \ 113 { \ 114 return func (l); \ 115 } 116 #define _GL_WARN_REAL_FLOATING_IMPL(func, value) \ 117 (sizeof (value) == sizeof (float) ? rpl_ ## func ## f (value) \ 118 : sizeof (value) == sizeof (double) ? rpl_ ## func ## d (value) \ 119 : rpl_ ## func ## l (value)) 120 121 122 #if @REPLACE_ITOLD@ 123 /* Pull in a function that fixes the 'int' to 'long double' conversion 124 of glibc 2.7. */ 125 _GL_EXTERN_C void _Qp_itoq (long double *, int); 126 static void (*_gl_math_fix_itold) (long double *, int) = _Qp_itoq; 127 #endif 128 129 130 /* For clang: Use __has_builtin to determine whether a builtin is available. */ 131 #ifndef __has_builtin 132 # define __has_builtin(name) 0 133 #endif 134 135 136 /* POSIX allows platforms that don't support NAN. But all major 137 machines in the past 15 years have supported something close to 138 IEEE NaN, so we define this unconditionally. We also must define 139 it on platforms like Solaris 10, where NAN is present but defined 140 as a function pointer rather than a floating point constant. */ 141 #if !defined NAN || @REPLACE_NAN@ 142 # if !GNULIB_defined_NAN 143 # undef NAN 144 /* The Compaq (ex-DEC) C 6.4 compiler and the Microsoft MSVC 9 compiler 145 choke on the expression 0.0 / 0.0. */ 146 # if defined __DECC || defined _MSC_VER 147 _GL_MATH_INLINE float 148 _NaN () 149 { 150 static float zero = 0.0f; 151 return zero / zero; 152 } 153 # define NAN (_NaN()) 154 # else 155 # define NAN (0.0f / 0.0f) 156 # endif 157 # define GNULIB_defined_NAN 1 158 # endif 159 #endif 160 161 /* Solaris 10 defines HUGE_VAL, but as a function pointer rather 162 than a floating point constant. */ 163 #if @REPLACE_HUGE_VAL@ 164 # undef HUGE_VALF 165 # define HUGE_VALF (1.0f / 0.0f) 166 # undef HUGE_VAL 167 # define HUGE_VAL (1.0 / 0.0) 168 # undef HUGE_VALL 169 # define HUGE_VALL (1.0L / 0.0L) 170 #endif 171 172 /* HUGE_VALF is a 'float' Infinity. */ 173 #ifndef HUGE_VALF 174 # if defined _MSC_VER 175 /* The Microsoft MSVC 9 compiler chokes on the expression 1.0f / 0.0f. */ 176 # define HUGE_VALF (1e25f * 1e25f) 177 # else 178 # define HUGE_VALF (1.0f / 0.0f) 179 # endif 180 #endif 181 182 /* HUGE_VAL is a 'double' Infinity. */ 183 #ifndef HUGE_VAL 184 # if defined _MSC_VER 185 /* The Microsoft MSVC 9 compiler chokes on the expression 1.0 / 0.0. */ 186 # define HUGE_VAL (1e250 * 1e250) 187 # else 188 # define HUGE_VAL (1.0 / 0.0) 189 # endif 190 #endif 191 192 /* HUGE_VALL is a 'long double' Infinity. */ 193 #ifndef HUGE_VALL 194 # if defined _MSC_VER 195 /* The Microsoft MSVC 9 compiler chokes on the expression 1.0L / 0.0L. */ 196 # define HUGE_VALL (1e250L * 1e250L) 197 # else 198 # define HUGE_VALL (1.0L / 0.0L) 199 # endif 200 #endif 201 202 203 #if defined FP_ILOGB0 && defined FP_ILOGBNAN 204 /* Ensure FP_ILOGB0 and FP_ILOGBNAN are correct. */ 205 # if defined __HAIKU__ 206 /* Haiku: match what ilogb() does */ 207 # undef FP_ILOGB0 208 # undef FP_ILOGBNAN 209 # define FP_ILOGB0 (- 2147483647 - 1) /* INT_MIN */ 210 # define FP_ILOGBNAN (- 2147483647 - 1) /* INT_MIN */ 211 # endif 212 #else 213 /* Ensure FP_ILOGB0 and FP_ILOGBNAN are defined. */ 214 # if defined __NetBSD__ || defined __sgi 215 /* NetBSD, IRIX 6.5: match what ilogb() does */ 216 # define FP_ILOGB0 (- 2147483647 - 1) /* INT_MIN */ 217 # define FP_ILOGBNAN (- 2147483647 - 1) /* INT_MIN */ 218 # elif defined _AIX 219 /* AIX 5.1: match what ilogb() does in AIX >= 5.2 */ 220 # define FP_ILOGB0 (- 2147483647 - 1) /* INT_MIN */ 221 # define FP_ILOGBNAN 2147483647 /* INT_MAX */ 222 # elif defined __sun 223 /* Solaris 9: match what ilogb() does */ 224 # define FP_ILOGB0 (- 2147483647) /* - INT_MAX */ 225 # define FP_ILOGBNAN 2147483647 /* INT_MAX */ 226 # else 227 /* Gnulib defined values. */ 228 # define FP_ILOGB0 (- 2147483647) /* - INT_MAX */ 229 # define FP_ILOGBNAN (- 2147483647 - 1) /* INT_MIN */ 230 # endif 231 #endif 232 233 234 #if @GNULIB_ACOSF@ 235 # if @REPLACE_ACOSF@ 236 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 237 # undef acosf 238 # define acosf rpl_acosf 239 # endif 240 _GL_FUNCDECL_RPL (acosf, float, (float x)); 241 _GL_CXXALIAS_RPL (acosf, float, (float x)); 242 # else 243 # if !@HAVE_ACOSF@ 244 # undef acosf 245 _GL_FUNCDECL_SYS (acosf, float, (float x)); 246 # endif 247 _GL_CXXALIAS_SYS (acosf, float, (float x)); 248 # endif 249 _GL_CXXALIASWARN (acosf); 250 #elif defined GNULIB_POSIXCHECK 251 # undef acosf 252 # if HAVE_RAW_DECL_ACOSF 253 _GL_WARN_ON_USE (acosf, "acosf is unportable - " 254 "use gnulib module acosf for portability"); 255 # endif 256 #endif 257 258 #if @GNULIB_ACOSL@ 259 # if !@HAVE_ACOSL@ || !@HAVE_DECL_ACOSL@ 260 # undef acosl 261 _GL_FUNCDECL_SYS (acosl, long double, (long double x)); 262 # endif 263 _GL_CXXALIAS_SYS (acosl, long double, (long double x)); 264 _GL_CXXALIASWARN (acosl); 265 #elif defined GNULIB_POSIXCHECK 266 # undef acosl 267 # if HAVE_RAW_DECL_ACOSL 268 _GL_WARN_ON_USE (acosl, "acosl is unportable - " 269 "use gnulib module acosl for portability"); 270 # endif 271 #endif 272 273 274 #if @GNULIB_ASINF@ 275 # if @REPLACE_ASINF@ 276 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 277 # undef asinf 278 # define asinf rpl_asinf 279 # endif 280 _GL_FUNCDECL_RPL (asinf, float, (float x)); 281 _GL_CXXALIAS_RPL (asinf, float, (float x)); 282 # else 283 # if !@HAVE_ASINF@ 284 # undef asinf 285 _GL_FUNCDECL_SYS (asinf, float, (float x)); 286 # endif 287 _GL_CXXALIAS_SYS (asinf, float, (float x)); 288 # endif 289 _GL_CXXALIASWARN (asinf); 290 #elif defined GNULIB_POSIXCHECK 291 # undef asinf 292 # if HAVE_RAW_DECL_ASINF 293 _GL_WARN_ON_USE (asinf, "asinf is unportable - " 294 "use gnulib module asinf for portability"); 295 # endif 296 #endif 297 298 #if @GNULIB_ASINL@ 299 # if !@HAVE_ASINL@ || !@HAVE_DECL_ASINL@ 300 # undef asinl 301 _GL_FUNCDECL_SYS (asinl, long double, (long double x)); 302 # endif 303 _GL_CXXALIAS_SYS (asinl, long double, (long double x)); 304 _GL_CXXALIASWARN (asinl); 305 #elif defined GNULIB_POSIXCHECK 306 # undef asinl 307 # if HAVE_RAW_DECL_ASINL 308 _GL_WARN_ON_USE (asinl, "asinl is unportable - " 309 "use gnulib module asinl for portability"); 310 # endif 311 #endif 312 313 314 #if @GNULIB_ATANF@ 315 # if @REPLACE_ATANF@ 316 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 317 # undef atanf 318 # define atanf rpl_atanf 319 # endif 320 _GL_FUNCDECL_RPL (atanf, float, (float x)); 321 _GL_CXXALIAS_RPL (atanf, float, (float x)); 322 # else 323 # if !@HAVE_ATANF@ 324 # undef atanf 325 _GL_FUNCDECL_SYS (atanf, float, (float x)); 326 # endif 327 _GL_CXXALIAS_SYS (atanf, float, (float x)); 328 # endif 329 _GL_CXXALIASWARN (atanf); 330 #elif defined GNULIB_POSIXCHECK 331 # undef atanf 332 # if HAVE_RAW_DECL_ATANF 333 _GL_WARN_ON_USE (atanf, "atanf is unportable - " 334 "use gnulib module atanf for portability"); 335 # endif 336 #endif 337 338 #if @GNULIB_ATANL@ 339 # if !@HAVE_ATANL@ || !@HAVE_DECL_ATANL@ 340 # undef atanl 341 _GL_FUNCDECL_SYS (atanl, long double, (long double x)); 342 # endif 343 _GL_CXXALIAS_SYS (atanl, long double, (long double x)); 344 _GL_CXXALIASWARN (atanl); 345 #elif defined GNULIB_POSIXCHECK 346 # undef atanl 347 # if HAVE_RAW_DECL_ATANL 348 _GL_WARN_ON_USE (atanl, "atanl is unportable - " 349 "use gnulib module atanl for portability"); 350 # endif 351 #endif 352 353 354 #if @GNULIB_ATAN2F@ 355 # if @REPLACE_ATAN2F@ 356 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 357 # undef atan2f 358 # define atan2f rpl_atan2f 359 # endif 360 _GL_FUNCDECL_RPL (atan2f, float, (float y, float x)); 361 _GL_CXXALIAS_RPL (atan2f, float, (float y, float x)); 362 # else 363 # if !@HAVE_ATAN2F@ 364 # undef atan2f 365 _GL_FUNCDECL_SYS (atan2f, float, (float y, float x)); 366 # endif 367 _GL_CXXALIAS_SYS (atan2f, float, (float y, float x)); 368 # endif 369 _GL_CXXALIASWARN (atan2f); 370 #elif defined GNULIB_POSIXCHECK 371 # undef atan2f 372 # if HAVE_RAW_DECL_ATAN2F 373 _GL_WARN_ON_USE (atan2f, "atan2f is unportable - " 374 "use gnulib module atan2f for portability"); 375 # endif 376 #endif 377 378 379 #if @GNULIB_CBRTF@ 380 # if @REPLACE_CBRTF@ 381 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 382 # undef cbrtf 383 # define cbrtf rpl_cbrtf 384 # endif 385 _GL_FUNCDECL_RPL (cbrtf, float, (float x)); 386 _GL_CXXALIAS_RPL (cbrtf, float, (float x)); 387 # else 388 # if !@HAVE_DECL_CBRTF@ 389 _GL_FUNCDECL_SYS (cbrtf, float, (float x)); 390 # endif 391 _GL_CXXALIAS_SYS (cbrtf, float, (float x)); 392 # endif 393 _GL_CXXALIASWARN (cbrtf); 394 #elif defined GNULIB_POSIXCHECK 395 # undef cbrtf 396 # if HAVE_RAW_DECL_CBRTF 397 _GL_WARN_ON_USE (cbrtf, "cbrtf is unportable - " 398 "use gnulib module cbrtf for portability"); 399 # endif 400 #endif 401 402 #if @GNULIB_CBRT@ 403 # if !@HAVE_CBRT@ 404 _GL_FUNCDECL_SYS (cbrt, double, (double x)); 405 # endif 406 _GL_CXXALIAS_SYS (cbrt, double, (double x)); 407 # if __GLIBC__ >= 2 408 _GL_CXXALIASWARN (cbrt); 409 # endif 410 #elif defined GNULIB_POSIXCHECK 411 # undef cbrt 412 # if HAVE_RAW_DECL_CBRT 413 _GL_WARN_ON_USE (cbrt, "cbrt is unportable - " 414 "use gnulib module cbrt for portability"); 415 # endif 416 #endif 417 418 #if @GNULIB_CBRTL@ 419 # if @REPLACE_CBRTL@ 420 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 421 # undef cbrtl 422 # define cbrtl rpl_cbrtl 423 # endif 424 _GL_FUNCDECL_RPL (cbrtl, long double, (long double x)); 425 _GL_CXXALIAS_RPL (cbrtl, long double, (long double x)); 426 # else 427 # if !@HAVE_DECL_CBRTL@ 428 _GL_FUNCDECL_SYS (cbrtl, long double, (long double x)); 429 # endif 430 _GL_CXXALIAS_SYS (cbrtl, long double, (long double x)); 431 # endif 432 _GL_CXXALIASWARN (cbrtl); 433 #elif defined GNULIB_POSIXCHECK 434 # undef cbrtl 435 # if HAVE_RAW_DECL_CBRTL 436 _GL_WARN_ON_USE (cbrtl, "cbrtl is unportable - " 437 "use gnulib module cbrtl for portability"); 438 # endif 439 #endif 440 441 442 #if @GNULIB_CEILF@ 443 # if @REPLACE_CEILF@ 444 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 445 # undef ceilf 446 # define ceilf rpl_ceilf 447 # endif 448 _GL_FUNCDECL_RPL (ceilf, float, (float x)); 449 _GL_CXXALIAS_RPL (ceilf, float, (float x)); 450 # else 451 # if !@HAVE_DECL_CEILF@ 452 # undef ceilf 453 _GL_FUNCDECL_SYS (ceilf, float, (float x)); 454 # endif 455 _GL_CXXALIAS_SYS (ceilf, float, (float x)); 456 # endif 457 _GL_CXXALIASWARN (ceilf); 458 #elif defined GNULIB_POSIXCHECK 459 # undef ceilf 460 # if HAVE_RAW_DECL_CEILF 461 _GL_WARN_ON_USE (ceilf, "ceilf is unportable - " 462 "use gnulib module ceilf for portability"); 463 # endif 464 #endif 465 466 #if @GNULIB_CEIL@ 467 # if @REPLACE_CEIL@ 468 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 469 # undef ceil 470 # define ceil rpl_ceil 471 # endif 472 _GL_FUNCDECL_RPL (ceil, double, (double x)); 473 _GL_CXXALIAS_RPL (ceil, double, (double x)); 474 # else 475 _GL_CXXALIAS_SYS (ceil, double, (double x)); 476 # endif 477 # if __GLIBC__ >= 2 478 _GL_CXXALIASWARN (ceil); 479 # endif 480 #endif 481 482 #if @GNULIB_CEILL@ 483 # if @REPLACE_CEILL@ 484 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 485 # undef ceill 486 # define ceill rpl_ceill 487 # endif 488 _GL_FUNCDECL_RPL (ceill, long double, (long double x)); 489 _GL_CXXALIAS_RPL (ceill, long double, (long double x)); 490 # else 491 # if !@HAVE_DECL_CEILL@ 492 # undef ceill 493 _GL_FUNCDECL_SYS (ceill, long double, (long double x)); 494 # endif 495 _GL_CXXALIAS_SYS (ceill, long double, (long double x)); 496 # endif 497 _GL_CXXALIASWARN (ceill); 498 #elif defined GNULIB_POSIXCHECK 499 # undef ceill 500 # if HAVE_RAW_DECL_CEILL 501 _GL_WARN_ON_USE (ceill, "ceill is unportable - " 502 "use gnulib module ceill for portability"); 503 # endif 504 #endif 505 506 507 #if @GNULIB_COPYSIGNF@ 508 # if !@HAVE_DECL_COPYSIGNF@ 509 # undef copysignf 510 _GL_FUNCDECL_SYS (copysignf, float, (float x, float y)); 511 # endif 512 _GL_CXXALIAS_SYS (copysignf, float, (float x, float y)); 513 _GL_CXXALIASWARN (copysignf); 514 #elif defined GNULIB_POSIXCHECK 515 # undef copysignf 516 # if HAVE_RAW_DECL_COPYSIGNF 517 _GL_WARN_ON_USE (copysignf, "copysignf is unportable - " 518 "use gnulib module copysignf for portability"); 519 # endif 520 #endif 521 522 #if @GNULIB_COPYSIGN@ 523 # if !@HAVE_COPYSIGN@ 524 _GL_FUNCDECL_SYS (copysign, double, (double x, double y)); 525 # endif 526 _GL_CXXALIAS_SYS (copysign, double, (double x, double y)); 527 # if __GLIBC__ >= 2 528 _GL_CXXALIASWARN (copysign); 529 # endif 530 #elif defined GNULIB_POSIXCHECK 531 # undef copysign 532 # if HAVE_RAW_DECL_COPYSIGN 533 _GL_WARN_ON_USE (copysign, "copysign is unportable - " 534 "use gnulib module copysign for portability"); 535 # endif 536 #endif 537 538 #if @GNULIB_COPYSIGNL@ 539 # if !@HAVE_COPYSIGNL@ 540 _GL_FUNCDECL_SYS (copysignl, long double, (long double x, long double y)); 541 # endif 542 _GL_CXXALIAS_SYS (copysignl, long double, (long double x, long double y)); 543 _GL_CXXALIASWARN (copysignl); 544 #elif defined GNULIB_POSIXCHECK 545 # undef copysignl 546 # if HAVE_RAW_DECL_COPYSIGNL 547 _GL_WARN_ON_USE (copysign, "copysignl is unportable - " 548 "use gnulib module copysignl for portability"); 549 # endif 550 #endif 551 552 553 #if @GNULIB_COSF@ 554 # if @REPLACE_COSF@ 555 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 556 # undef cosf 557 # define cosf rpl_cosf 558 # endif 559 _GL_FUNCDECL_RPL (cosf, float, (float x)); 560 _GL_CXXALIAS_RPL (cosf, float, (float x)); 561 # else 562 # if !@HAVE_COSF@ 563 # undef cosf 564 _GL_FUNCDECL_SYS (cosf, float, (float x)); 565 # endif 566 _GL_CXXALIAS_SYS (cosf, float, (float x)); 567 # endif 568 _GL_CXXALIASWARN (cosf); 569 #elif defined GNULIB_POSIXCHECK 570 # undef cosf 571 # if HAVE_RAW_DECL_COSF 572 _GL_WARN_ON_USE (cosf, "cosf is unportable - " 573 "use gnulib module cosf for portability"); 574 # endif 575 #endif 576 577 #if @GNULIB_COSL@ 578 # if !@HAVE_COSL@ || !@HAVE_DECL_COSL@ 579 # undef cosl 580 _GL_FUNCDECL_SYS (cosl, long double, (long double x)); 581 # endif 582 _GL_CXXALIAS_SYS (cosl, long double, (long double x)); 583 _GL_CXXALIASWARN (cosl); 584 #elif defined GNULIB_POSIXCHECK 585 # undef cosl 586 # if HAVE_RAW_DECL_COSL 587 _GL_WARN_ON_USE (cosl, "cosl is unportable - " 588 "use gnulib module cosl for portability"); 589 # endif 590 #endif 591 592 593 #if @GNULIB_COSHF@ 594 # if @REPLACE_COSHF@ 595 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 596 # undef coshf 597 # define coshf rpl_coshf 598 # endif 599 _GL_FUNCDECL_RPL (coshf, float, (float x)); 600 _GL_CXXALIAS_RPL (coshf, float, (float x)); 601 # else 602 # if !@HAVE_COSHF@ 603 # undef coshf 604 _GL_FUNCDECL_SYS (coshf, float, (float x)); 605 # endif 606 _GL_CXXALIAS_SYS (coshf, float, (float x)); 607 # endif 608 _GL_CXXALIASWARN (coshf); 609 #elif defined GNULIB_POSIXCHECK 610 # undef coshf 611 # if HAVE_RAW_DECL_COSHF 612 _GL_WARN_ON_USE (coshf, "coshf is unportable - " 613 "use gnulib module coshf for portability"); 614 # endif 615 #endif 616 617 618 #if @GNULIB_EXPF@ 619 # if @REPLACE_EXPF@ 620 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 621 # undef expf 622 # define expf rpl_expf 623 # endif 624 _GL_FUNCDECL_RPL (expf, float, (float x)); 625 _GL_CXXALIAS_RPL (expf, float, (float x)); 626 # else 627 # if !@HAVE_EXPF@ 628 # undef expf 629 _GL_FUNCDECL_SYS (expf, float, (float x)); 630 # endif 631 _GL_CXXALIAS_SYS (expf, float, (float x)); 632 # endif 633 _GL_CXXALIASWARN (expf); 634 #elif defined GNULIB_POSIXCHECK 635 # undef expf 636 # if HAVE_RAW_DECL_EXPF 637 _GL_WARN_ON_USE (expf, "expf is unportable - " 638 "use gnulib module expf for portability"); 639 # endif 640 #endif 641 642 #if @GNULIB_EXPL@ 643 # if @REPLACE_EXPL@ 644 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 645 # undef expl 646 # define expl rpl_expl 647 # endif 648 _GL_FUNCDECL_RPL (expl, long double, (long double x)); 649 _GL_CXXALIAS_RPL (expl, long double, (long double x)); 650 # else 651 # if !@HAVE_EXPL@ || !@HAVE_DECL_EXPL@ 652 # undef expl 653 _GL_FUNCDECL_SYS (expl, long double, (long double x)); 654 # endif 655 _GL_CXXALIAS_SYS (expl, long double, (long double x)); 656 # endif 657 _GL_CXXALIASWARN (expl); 658 #elif defined GNULIB_POSIXCHECK 659 # undef expl 660 # if HAVE_RAW_DECL_EXPL 661 _GL_WARN_ON_USE (expl, "expl is unportable - " 662 "use gnulib module expl for portability"); 663 # endif 664 #endif 665 666 667 #if @GNULIB_EXP2F@ 668 # if !@HAVE_DECL_EXP2F@ 669 _GL_FUNCDECL_SYS (exp2f, float, (float x)); 670 # endif 671 _GL_CXXALIAS_SYS (exp2f, float, (float x)); 672 _GL_CXXALIASWARN (exp2f); 673 #elif defined GNULIB_POSIXCHECK 674 # undef exp2f 675 # if HAVE_RAW_DECL_EXP2F 676 _GL_WARN_ON_USE (exp2f, "exp2f is unportable - " 677 "use gnulib module exp2f for portability"); 678 # endif 679 #endif 680 681 #if @GNULIB_EXP2@ 682 # if @REPLACE_EXP2@ 683 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 684 # undef exp2 685 # define exp2 rpl_exp2 686 # endif 687 _GL_FUNCDECL_RPL (exp2, double, (double x)); 688 _GL_CXXALIAS_RPL (exp2, double, (double x)); 689 # else 690 # if !@HAVE_DECL_EXP2@ 691 _GL_FUNCDECL_SYS (exp2, double, (double x)); 692 # endif 693 _GL_CXXALIAS_SYS (exp2, double, (double x)); 694 # endif 695 # if __GLIBC__ >= 2 696 _GL_CXXALIASWARN (exp2); 697 # endif 698 #elif defined GNULIB_POSIXCHECK 699 # undef exp2 700 # if HAVE_RAW_DECL_EXP2 701 _GL_WARN_ON_USE (exp2, "exp2 is unportable - " 702 "use gnulib module exp2 for portability"); 703 # endif 704 #endif 705 706 #if @GNULIB_EXP2L@ 707 # if @REPLACE_EXP2L@ 708 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 709 # undef exp2l 710 # define exp2l rpl_exp2l 711 # endif 712 _GL_FUNCDECL_RPL (exp2l, long double, (long double x)); 713 _GL_CXXALIAS_RPL (exp2l, long double, (long double x)); 714 # else 715 # if !@HAVE_DECL_EXP2L@ 716 # undef exp2l 717 _GL_FUNCDECL_SYS (exp2l, long double, (long double x)); 718 # endif 719 _GL_CXXALIAS_SYS (exp2l, long double, (long double x)); 720 # endif 721 _GL_CXXALIASWARN (exp2l); 722 #elif defined GNULIB_POSIXCHECK 723 # undef exp2l 724 # if HAVE_RAW_DECL_EXP2L 725 _GL_WARN_ON_USE (exp2l, "exp2l is unportable - " 726 "use gnulib module exp2l for portability"); 727 # endif 728 #endif 729 730 731 #if @GNULIB_EXPM1F@ 732 # if @REPLACE_EXPM1F@ 733 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 734 # undef expm1f 735 # define expm1f rpl_expm1f 736 # endif 737 _GL_FUNCDECL_RPL (expm1f, float, (float x)); 738 _GL_CXXALIAS_RPL (expm1f, float, (float x)); 739 # else 740 # if !@HAVE_EXPM1F@ 741 _GL_FUNCDECL_SYS (expm1f, float, (float x)); 742 # endif 743 _GL_CXXALIAS_SYS (expm1f, float, (float x)); 744 # endif 745 _GL_CXXALIASWARN (expm1f); 746 #elif defined GNULIB_POSIXCHECK 747 # undef expm1f 748 # if HAVE_RAW_DECL_EXPM1F 749 _GL_WARN_ON_USE (expm1f, "expm1f is unportable - " 750 "use gnulib module expm1f for portability"); 751 # endif 752 #endif 753 754 #if @GNULIB_EXPM1@ 755 # if @REPLACE_EXPM1@ 756 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 757 # undef expm1 758 # define expm1 rpl_expm1 759 # endif 760 _GL_FUNCDECL_RPL (expm1, double, (double x)); 761 _GL_CXXALIAS_RPL (expm1, double, (double x)); 762 # else 763 # if !@HAVE_EXPM1@ 764 _GL_FUNCDECL_SYS (expm1, double, (double x)); 765 # endif 766 _GL_CXXALIAS_SYS (expm1, double, (double x)); 767 # endif 768 # if __GLIBC__ >= 2 769 _GL_CXXALIASWARN (expm1); 770 # endif 771 #elif defined GNULIB_POSIXCHECK 772 # undef expm1 773 # if HAVE_RAW_DECL_EXPM1 774 _GL_WARN_ON_USE (expm1, "expm1 is unportable - " 775 "use gnulib module expm1 for portability"); 776 # endif 777 #endif 778 779 #if @GNULIB_EXPM1L@ 780 # if @REPLACE_EXPM1L@ 781 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 782 # undef expm1l 783 # define expm1l rpl_expm1l 784 # endif 785 _GL_FUNCDECL_RPL (expm1l, long double, (long double x)); 786 _GL_CXXALIAS_RPL (expm1l, long double, (long double x)); 787 # else 788 # if !@HAVE_DECL_EXPM1L@ 789 # undef expm1l 790 # if !(defined __cplusplus && defined _AIX) 791 _GL_FUNCDECL_SYS (expm1l, long double, (long double x)); 792 # endif 793 # endif 794 _GL_CXXALIAS_SYS (expm1l, long double, (long double x)); 795 # endif 796 _GL_CXXALIASWARN (expm1l); 797 #elif defined GNULIB_POSIXCHECK 798 # undef expm1l 799 # if HAVE_RAW_DECL_EXPM1L 800 _GL_WARN_ON_USE (expm1l, "expm1l is unportable - " 801 "use gnulib module expm1l for portability"); 802 # endif 803 #endif 804 805 806 #if @GNULIB_FABSF@ 807 # if !@HAVE_FABSF@ 808 # undef fabsf 809 _GL_FUNCDECL_SYS (fabsf, float, (float x)); 810 # endif 811 _GL_CXXALIAS_SYS (fabsf, float, (float x)); 812 _GL_CXXALIASWARN (fabsf); 813 #elif defined GNULIB_POSIXCHECK 814 # undef fabsf 815 # if HAVE_RAW_DECL_FABSF 816 _GL_WARN_ON_USE (fabsf, "fabsf is unportable - " 817 "use gnulib module fabsf for portability"); 818 # endif 819 #endif 820 821 #if @GNULIB_FABSL@ 822 # if @REPLACE_FABSL@ 823 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 824 # undef fabsl 825 # define fabsl rpl_fabsl 826 # endif 827 _GL_FUNCDECL_RPL (fabsl, long double, (long double x)); 828 _GL_CXXALIAS_RPL (fabsl, long double, (long double x)); 829 # else 830 # if !@HAVE_FABSL@ 831 # undef fabsl 832 _GL_FUNCDECL_SYS (fabsl, long double, (long double x)); 833 # endif 834 _GL_CXXALIAS_SYS (fabsl, long double, (long double x)); 835 # endif 836 _GL_CXXALIASWARN (fabsl); 837 #elif defined GNULIB_POSIXCHECK 838 # undef fabsl 839 # if HAVE_RAW_DECL_FABSL 840 _GL_WARN_ON_USE (fabsl, "fabsl is unportable - " 841 "use gnulib module fabsl for portability"); 842 # endif 843 #endif 844 845 846 #if @GNULIB_FLOORF@ 847 # if @REPLACE_FLOORF@ 848 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 849 # undef floorf 850 # define floorf rpl_floorf 851 # endif 852 _GL_FUNCDECL_RPL (floorf, float, (float x)); 853 _GL_CXXALIAS_RPL (floorf, float, (float x)); 854 # else 855 # if !@HAVE_DECL_FLOORF@ 856 # undef floorf 857 _GL_FUNCDECL_SYS (floorf, float, (float x)); 858 # endif 859 _GL_CXXALIAS_SYS (floorf, float, (float x)); 860 # endif 861 _GL_CXXALIASWARN (floorf); 862 #elif defined GNULIB_POSIXCHECK 863 # undef floorf 864 # if HAVE_RAW_DECL_FLOORF 865 _GL_WARN_ON_USE (floorf, "floorf is unportable - " 866 "use gnulib module floorf for portability"); 867 # endif 868 #endif 869 870 #if @GNULIB_FLOOR@ 871 # if @REPLACE_FLOOR@ 872 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 873 # undef floor 874 # define floor rpl_floor 875 # endif 876 _GL_FUNCDECL_RPL (floor, double, (double x)); 877 _GL_CXXALIAS_RPL (floor, double, (double x)); 878 # else 879 _GL_CXXALIAS_SYS (floor, double, (double x)); 880 # endif 881 # if __GLIBC__ >= 2 882 _GL_CXXALIASWARN (floor); 883 # endif 884 #endif 885 886 #if @GNULIB_FLOORL@ 887 # if @REPLACE_FLOORL@ 888 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 889 # undef floorl 890 # define floorl rpl_floorl 891 # endif 892 _GL_FUNCDECL_RPL (floorl, long double, (long double x)); 893 _GL_CXXALIAS_RPL (floorl, long double, (long double x)); 894 # else 895 # if !@HAVE_DECL_FLOORL@ 896 # undef floorl 897 _GL_FUNCDECL_SYS (floorl, long double, (long double x)); 898 # endif 899 _GL_CXXALIAS_SYS (floorl, long double, (long double x)); 900 # endif 901 _GL_CXXALIASWARN (floorl); 902 #elif defined GNULIB_POSIXCHECK 903 # undef floorl 904 # if HAVE_RAW_DECL_FLOORL 905 _GL_WARN_ON_USE (floorl, "floorl is unportable - " 906 "use gnulib module floorl for portability"); 907 # endif 908 #endif 909 910 911 #if @GNULIB_FMAF@ 912 # if @REPLACE_FMAF@ 913 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 914 # undef fmaf 915 # define fmaf rpl_fmaf 916 # endif 917 _GL_FUNCDECL_RPL (fmaf, float, (float x, float y, float z)); 918 _GL_CXXALIAS_RPL (fmaf, float, (float x, float y, float z)); 919 # else 920 # if !@HAVE_FMAF@ 921 # undef fmaf 922 _GL_FUNCDECL_SYS (fmaf, float, (float x, float y, float z)); 923 # endif 924 _GL_CXXALIAS_SYS (fmaf, float, (float x, float y, float z)); 925 # endif 926 _GL_CXXALIASWARN (fmaf); 927 #elif defined GNULIB_POSIXCHECK 928 # undef fmaf 929 # if HAVE_RAW_DECL_FMAF 930 _GL_WARN_ON_USE (fmaf, "fmaf is unportable - " 931 "use gnulib module fmaf for portability"); 932 # endif 933 #endif 934 935 #if @GNULIB_FMA@ 936 # if @REPLACE_FMA@ 937 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 938 # undef fma 939 # define fma rpl_fma 940 # endif 941 _GL_FUNCDECL_RPL (fma, double, (double x, double y, double z)); 942 _GL_CXXALIAS_RPL (fma, double, (double x, double y, double z)); 943 # else 944 # if !@HAVE_FMA@ 945 # undef fma 946 _GL_FUNCDECL_SYS (fma, double, (double x, double y, double z)); 947 # endif 948 _GL_CXXALIAS_SYS (fma, double, (double x, double y, double z)); 949 # endif 950 # if __GLIBC__ >= 2 951 _GL_CXXALIASWARN (fma); 952 # endif 953 #elif defined GNULIB_POSIXCHECK 954 # undef fma 955 # if HAVE_RAW_DECL_FMA 956 _GL_WARN_ON_USE (fma, "fma is unportable - " 957 "use gnulib module fma for portability"); 958 # endif 959 #endif 960 961 #if @GNULIB_FMAL@ 962 # if @REPLACE_FMAL@ 963 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 964 # undef fmal 965 # define fmal rpl_fmal 966 # endif 967 _GL_FUNCDECL_RPL (fmal, long double, 968 (long double x, long double y, long double z)); 969 _GL_CXXALIAS_RPL (fmal, long double, 970 (long double x, long double y, long double z)); 971 # else 972 # if !@HAVE_FMAL@ 973 # undef fmal 974 # if !(defined __cplusplus && defined _AIX) 975 _GL_FUNCDECL_SYS (fmal, long double, 976 (long double x, long double y, long double z)); 977 # endif 978 # endif 979 _GL_CXXALIAS_SYS (fmal, long double, 980 (long double x, long double y, long double z)); 981 # endif 982 _GL_CXXALIASWARN (fmal); 983 #elif defined GNULIB_POSIXCHECK 984 # undef fmal 985 # if HAVE_RAW_DECL_FMAL 986 _GL_WARN_ON_USE (fmal, "fmal is unportable - " 987 "use gnulib module fmal for portability"); 988 # endif 989 #endif 990 991 992 #if @GNULIB_FMODF@ 993 # if @REPLACE_FMODF@ 994 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 995 # undef fmodf 996 # define fmodf rpl_fmodf 997 # endif 998 _GL_FUNCDECL_RPL (fmodf, float, (float x, float y)); 999 _GL_CXXALIAS_RPL (fmodf, float, (float x, float y)); 1000 # else 1001 # if !@HAVE_FMODF@ 1002 # undef fmodf 1003 _GL_FUNCDECL_SYS (fmodf, float, (float x, float y)); 1004 # endif 1005 _GL_CXXALIAS_SYS (fmodf, float, (float x, float y)); 1006 # endif 1007 _GL_CXXALIASWARN (fmodf); 1008 #elif defined GNULIB_POSIXCHECK 1009 # undef fmodf 1010 # if HAVE_RAW_DECL_FMODF 1011 _GL_WARN_ON_USE (fmodf, "fmodf is unportable - " 1012 "use gnulib module fmodf for portability"); 1013 # endif 1014 #endif 1015 1016 #if @GNULIB_FMOD@ 1017 # if @REPLACE_FMOD@ 1018 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1019 # undef fmod 1020 # define fmod rpl_fmod 1021 # endif 1022 _GL_FUNCDECL_RPL (fmod, double, (double x, double y)); 1023 _GL_CXXALIAS_RPL (fmod, double, (double x, double y)); 1024 # else 1025 _GL_CXXALIAS_SYS (fmod, double, (double x, double y)); 1026 # endif 1027 # if __GLIBC__ >= 2 1028 _GL_CXXALIASWARN (fmod); 1029 # endif 1030 #elif defined GNULIB_POSIXCHECK 1031 # undef fmod 1032 # if HAVE_RAW_DECL_FMOD 1033 _GL_WARN_ON_USE (fmod, "fmod has portability problems - " 1034 "use gnulib module fmod for portability"); 1035 # endif 1036 #endif 1037 1038 #if @GNULIB_FMODL@ 1039 # if @REPLACE_FMODL@ 1040 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1041 # undef fmodl 1042 # define fmodl rpl_fmodl 1043 # endif 1044 _GL_FUNCDECL_RPL (fmodl, long double, (long double x, long double y)); 1045 _GL_CXXALIAS_RPL (fmodl, long double, (long double x, long double y)); 1046 # else 1047 # if !@HAVE_FMODL@ 1048 # undef fmodl 1049 _GL_FUNCDECL_SYS (fmodl, long double, (long double x, long double y)); 1050 # endif 1051 _GL_CXXALIAS_SYS (fmodl, long double, (long double x, long double y)); 1052 # endif 1053 _GL_CXXALIASWARN (fmodl); 1054 #elif defined GNULIB_POSIXCHECK 1055 # undef fmodl 1056 # if HAVE_RAW_DECL_FMODL 1057 _GL_WARN_ON_USE (fmodl, "fmodl is unportable - " 1058 "use gnulib module fmodl for portability"); 1059 # endif 1060 #endif 1061 1062 1063 /* Write x as 1064 x = mantissa * 2^exp 1065 where 1066 If x finite and nonzero: 0.5 <= |mantissa| < 1.0. 1067 If x is zero: mantissa = x, exp = 0. 1068 If x is infinite or NaN: mantissa = x, exp unspecified. 1069 Store exp in *EXPPTR and return mantissa. */ 1070 #if @GNULIB_FREXPF@ 1071 # if @REPLACE_FREXPF@ 1072 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1073 # undef frexpf 1074 # define frexpf rpl_frexpf 1075 # endif 1076 _GL_FUNCDECL_RPL (frexpf, float, (float x, int *expptr) _GL_ARG_NONNULL ((2))); 1077 _GL_CXXALIAS_RPL (frexpf, float, (float x, int *expptr)); 1078 # else 1079 # if !@HAVE_FREXPF@ 1080 # undef frexpf 1081 _GL_FUNCDECL_SYS (frexpf, float, (float x, int *expptr) _GL_ARG_NONNULL ((2))); 1082 # endif 1083 _GL_CXXALIAS_SYS (frexpf, float, (float x, int *expptr)); 1084 # endif 1085 _GL_CXXALIASWARN (frexpf); 1086 #elif defined GNULIB_POSIXCHECK 1087 # undef frexpf 1088 # if HAVE_RAW_DECL_FREXPF 1089 _GL_WARN_ON_USE (frexpf, "frexpf is unportable - " 1090 "use gnulib module frexpf for portability"); 1091 # endif 1092 #endif 1093 1094 /* Write x as 1095 x = mantissa * 2^exp 1096 where 1097 If x finite and nonzero: 0.5 <= |mantissa| < 1.0. 1098 If x is zero: mantissa = x, exp = 0. 1099 If x is infinite or NaN: mantissa = x, exp unspecified. 1100 Store exp in *EXPPTR and return mantissa. */ 1101 #if @GNULIB_FREXP@ 1102 # if @REPLACE_FREXP@ 1103 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1104 # undef frexp 1105 # define frexp rpl_frexp 1106 # endif 1107 _GL_FUNCDECL_RPL (frexp, double, (double x, int *expptr) _GL_ARG_NONNULL ((2))); 1108 _GL_CXXALIAS_RPL (frexp, double, (double x, int *expptr)); 1109 # else 1110 _GL_CXXALIAS_SYS (frexp, double, (double x, int *expptr)); 1111 # endif 1112 # if __GLIBC__ >= 2 1113 _GL_CXXALIASWARN1 (frexp, double, (double x, int *expptr)); 1114 # endif 1115 #elif defined GNULIB_POSIXCHECK 1116 # undef frexp 1117 /* Assume frexp is always declared. */ 1118 _GL_WARN_ON_USE (frexp, "frexp is unportable - " 1119 "use gnulib module frexp for portability"); 1120 #endif 1121 1122 /* Write x as 1123 x = mantissa * 2^exp 1124 where 1125 If x finite and nonzero: 0.5 <= |mantissa| < 1.0. 1126 If x is zero: mantissa = x, exp = 0. 1127 If x is infinite or NaN: mantissa = x, exp unspecified. 1128 Store exp in *EXPPTR and return mantissa. */ 1129 #if @GNULIB_FREXPL@ && @REPLACE_FREXPL@ 1130 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1131 # undef frexpl 1132 # define frexpl rpl_frexpl 1133 # endif 1134 _GL_FUNCDECL_RPL (frexpl, long double, 1135 (long double x, int *expptr) _GL_ARG_NONNULL ((2))); 1136 _GL_CXXALIAS_RPL (frexpl, long double, (long double x, int *expptr)); 1137 #else 1138 # if !@HAVE_DECL_FREXPL@ 1139 _GL_FUNCDECL_SYS (frexpl, long double, 1140 (long double x, int *expptr) _GL_ARG_NONNULL ((2))); 1141 # endif 1142 # if @GNULIB_FREXPL@ 1143 _GL_CXXALIAS_SYS (frexpl, long double, (long double x, int *expptr)); 1144 # endif 1145 #endif 1146 #if @GNULIB_FREXPL@ && !(@REPLACE_FREXPL@ && !@HAVE_DECL_FREXPL@) 1147 _GL_CXXALIASWARN (frexpl); 1148 #endif 1149 #if !@GNULIB_FREXPL@ && defined GNULIB_POSIXCHECK 1150 # undef frexpl 1151 # if HAVE_RAW_DECL_FREXPL 1152 _GL_WARN_ON_USE (frexpl, "frexpl is unportable - " 1153 "use gnulib module frexpl for portability"); 1154 # endif 1155 #endif 1156 1157 1158 /* Return sqrt(x^2+y^2). */ 1159 #if @GNULIB_HYPOTF@ 1160 # if @REPLACE_HYPOTF@ 1161 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1162 # undef hypotf 1163 # define hypotf rpl_hypotf 1164 # endif 1165 _GL_FUNCDECL_RPL (hypotf, float, (float x, float y)); 1166 _GL_CXXALIAS_RPL (hypotf, float, (float x, float y)); 1167 # else 1168 # if !@HAVE_HYPOTF@ 1169 _GL_FUNCDECL_SYS (hypotf, float, (float x, float y)); 1170 # endif 1171 _GL_CXXALIAS_SYS (hypotf, float, (float x, float y)); 1172 # endif 1173 _GL_CXXALIASWARN (hypotf); 1174 #elif defined GNULIB_POSIXCHECK 1175 # undef hypotf 1176 # if HAVE_RAW_DECL_HYPOTF 1177 _GL_WARN_ON_USE (hypotf, "hypotf is unportable - " 1178 "use gnulib module hypotf for portability"); 1179 # endif 1180 #endif 1181 1182 /* Return sqrt(x^2+y^2). */ 1183 #if @GNULIB_HYPOT@ 1184 # if @REPLACE_HYPOT@ 1185 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1186 # undef hypot 1187 # define hypot rpl_hypot 1188 # endif 1189 _GL_FUNCDECL_RPL (hypot, double, (double x, double y)); 1190 _GL_CXXALIAS_RPL (hypot, double, (double x, double y)); 1191 # else 1192 _GL_CXXALIAS_SYS (hypot, double, (double x, double y)); 1193 # endif 1194 # if __GLIBC__ >= 2 1195 _GL_CXXALIASWARN (hypot); 1196 # endif 1197 #elif defined GNULIB_POSIXCHECK 1198 # undef hypot 1199 # if HAVE_RAW_DECL_HYPOT 1200 _GL_WARN_ON_USE (hypotf, "hypot has portability problems - " 1201 "use gnulib module hypot for portability"); 1202 # endif 1203 #endif 1204 1205 /* Return sqrt(x^2+y^2). */ 1206 #if @GNULIB_HYPOTL@ 1207 # if @REPLACE_HYPOTL@ 1208 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1209 # undef hypotl 1210 # define hypotl rpl_hypotl 1211 # endif 1212 _GL_FUNCDECL_RPL (hypotl, long double, (long double x, long double y)); 1213 _GL_CXXALIAS_RPL (hypotl, long double, (long double x, long double y)); 1214 # else 1215 # if !@HAVE_HYPOTL@ 1216 _GL_FUNCDECL_SYS (hypotl, long double, (long double x, long double y)); 1217 # endif 1218 _GL_CXXALIAS_SYS (hypotl, long double, (long double x, long double y)); 1219 # endif 1220 _GL_CXXALIASWARN (hypotl); 1221 #elif defined GNULIB_POSIXCHECK 1222 # undef hypotl 1223 # if HAVE_RAW_DECL_HYPOTL 1224 _GL_WARN_ON_USE (hypotl, "hypotl is unportable - " 1225 "use gnulib module hypotl for portability"); 1226 # endif 1227 #endif 1228 1229 1230 #if @GNULIB_ILOGBF@ 1231 # if @REPLACE_ILOGBF@ 1232 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1233 # undef ilogbf 1234 # define ilogbf rpl_ilogbf 1235 # endif 1236 _GL_FUNCDECL_RPL (ilogbf, int, (float x)); 1237 _GL_CXXALIAS_RPL (ilogbf, int, (float x)); 1238 # else 1239 # if !@HAVE_ILOGBF@ 1240 _GL_FUNCDECL_SYS (ilogbf, int, (float x)); 1241 # endif 1242 _GL_CXXALIAS_SYS (ilogbf, int, (float x)); 1243 # endif 1244 _GL_CXXALIASWARN (ilogbf); 1245 #elif defined GNULIB_POSIXCHECK 1246 # undef ilogbf 1247 # if HAVE_RAW_DECL_ILOGBF 1248 _GL_WARN_ON_USE (ilogbf, "ilogbf is unportable - " 1249 "use gnulib module ilogbf for portability"); 1250 # endif 1251 #endif 1252 1253 #if @GNULIB_ILOGB@ 1254 # if @REPLACE_ILOGB@ 1255 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1256 # undef ilogb 1257 # define ilogb rpl_ilogb 1258 # endif 1259 _GL_FUNCDECL_RPL (ilogb, int, (double x)); 1260 _GL_CXXALIAS_RPL (ilogb, int, (double x)); 1261 # else 1262 # if !@HAVE_ILOGB@ 1263 _GL_FUNCDECL_SYS (ilogb, int, (double x)); 1264 # endif 1265 _GL_CXXALIAS_SYS (ilogb, int, (double x)); 1266 # endif 1267 # if __GLIBC__ >= 2 1268 _GL_CXXALIASWARN (ilogb); 1269 # endif 1270 #elif defined GNULIB_POSIXCHECK 1271 # undef ilogb 1272 # if HAVE_RAW_DECL_ILOGB 1273 _GL_WARN_ON_USE (ilogb, "ilogb is unportable - " 1274 "use gnulib module ilogb for portability"); 1275 # endif 1276 #endif 1277 1278 #if @GNULIB_ILOGBL@ 1279 # if @REPLACE_ILOGBL@ 1280 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1281 # undef ilogbl 1282 # define ilogbl rpl_ilogbl 1283 # endif 1284 _GL_FUNCDECL_RPL (ilogbl, int, (long double x)); 1285 _GL_CXXALIAS_RPL (ilogbl, int, (long double x)); 1286 # else 1287 # if !@HAVE_ILOGBL@ 1288 _GL_FUNCDECL_SYS (ilogbl, int, (long double x)); 1289 # endif 1290 _GL_CXXALIAS_SYS (ilogbl, int, (long double x)); 1291 # endif 1292 _GL_CXXALIASWARN (ilogbl); 1293 #elif defined GNULIB_POSIXCHECK 1294 # undef ilogbl 1295 # if HAVE_RAW_DECL_ILOGBL 1296 _GL_WARN_ON_USE (ilogbl, "ilogbl is unportable - " 1297 "use gnulib module ilogbl for portability"); 1298 # endif 1299 #endif 1300 1301 1302 /* Return x * 2^exp. */ 1303 #if @GNULIB_LDEXPF@ 1304 # if !@HAVE_LDEXPF@ 1305 # undef ldexpf 1306 _GL_FUNCDECL_SYS (ldexpf, float, (float x, int exp)); 1307 # endif 1308 _GL_CXXALIAS_SYS (ldexpf, float, (float x, int exp)); 1309 _GL_CXXALIASWARN (ldexpf); 1310 #elif defined GNULIB_POSIXCHECK 1311 # undef ldexpf 1312 # if HAVE_RAW_DECL_LDEXPF 1313 _GL_WARN_ON_USE (ldexpf, "ldexpf is unportable - " 1314 "use gnulib module ldexpf for portability"); 1315 # endif 1316 #endif 1317 1318 /* Return x * 2^exp. */ 1319 #if @GNULIB_LDEXPL@ && @REPLACE_LDEXPL@ 1320 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1321 # undef ldexpl 1322 # define ldexpl rpl_ldexpl 1323 # endif 1324 _GL_FUNCDECL_RPL (ldexpl, long double, (long double x, int exp)); 1325 _GL_CXXALIAS_RPL (ldexpl, long double, (long double x, int exp)); 1326 #else 1327 # if !@HAVE_DECL_LDEXPL@ 1328 _GL_FUNCDECL_SYS (ldexpl, long double, (long double x, int exp)); 1329 # endif 1330 # if @GNULIB_LDEXPL@ 1331 _GL_CXXALIAS_SYS (ldexpl, long double, (long double x, int exp)); 1332 # endif 1333 #endif 1334 #if @GNULIB_LDEXPL@ 1335 _GL_CXXALIASWARN (ldexpl); 1336 #endif 1337 #if !@GNULIB_LDEXPL@ && defined GNULIB_POSIXCHECK 1338 # undef ldexpl 1339 # if HAVE_RAW_DECL_LDEXPL 1340 _GL_WARN_ON_USE (ldexpl, "ldexpl is unportable - " 1341 "use gnulib module ldexpl for portability"); 1342 # endif 1343 #endif 1344 1345 1346 #if @GNULIB_LOGF@ 1347 # if @REPLACE_LOGF@ 1348 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1349 # undef logf 1350 # define logf rpl_logf 1351 # endif 1352 _GL_FUNCDECL_RPL (logf, float, (float x)); 1353 _GL_CXXALIAS_RPL (logf, float, (float x)); 1354 # else 1355 # if !@HAVE_LOGF@ 1356 # undef logf 1357 _GL_FUNCDECL_SYS (logf, float, (float x)); 1358 # endif 1359 _GL_CXXALIAS_SYS (logf, float, (float x)); 1360 # endif 1361 _GL_CXXALIASWARN (logf); 1362 #elif defined GNULIB_POSIXCHECK 1363 # undef logf 1364 # if HAVE_RAW_DECL_LOGF 1365 _GL_WARN_ON_USE (logf, "logf is unportable - " 1366 "use gnulib module logf for portability"); 1367 # endif 1368 #endif 1369 1370 #if @GNULIB_LOG@ 1371 # if @REPLACE_LOG@ 1372 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1373 # undef log 1374 # define log rpl_log 1375 # endif 1376 _GL_FUNCDECL_RPL (log, double, (double x)); 1377 _GL_CXXALIAS_RPL (log, double, (double x)); 1378 # else 1379 _GL_CXXALIAS_SYS (log, double, (double x)); 1380 # endif 1381 # if __GLIBC__ >= 2 1382 _GL_CXXALIASWARN (log); 1383 # endif 1384 #elif defined GNULIB_POSIXCHECK 1385 # undef log 1386 # if HAVE_RAW_DECL_LOG 1387 _GL_WARN_ON_USE (log, "log has portability problems - " 1388 "use gnulib module log for portability"); 1389 # endif 1390 #endif 1391 1392 #if @GNULIB_LOGL@ 1393 # if @REPLACE_LOGL@ 1394 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1395 # undef logl 1396 # define logl rpl_logl 1397 # endif 1398 _GL_FUNCDECL_RPL (logl, long double, (long double x)); 1399 _GL_CXXALIAS_RPL (logl, long double, (long double x)); 1400 # else 1401 # if !@HAVE_LOGL@ || !@HAVE_DECL_LOGL@ 1402 # undef logl 1403 _GL_FUNCDECL_SYS (logl, long double, (long double x)); 1404 # endif 1405 _GL_CXXALIAS_SYS (logl, long double, (long double x)); 1406 # endif 1407 _GL_CXXALIASWARN (logl); 1408 #elif defined GNULIB_POSIXCHECK 1409 # undef logl 1410 # if HAVE_RAW_DECL_LOGL 1411 _GL_WARN_ON_USE (logl, "logl is unportable - " 1412 "use gnulib module logl for portability"); 1413 # endif 1414 #endif 1415 1416 1417 #if @GNULIB_LOG10F@ 1418 # if @REPLACE_LOG10F@ 1419 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1420 # undef log10f 1421 # define log10f rpl_log10f 1422 # endif 1423 _GL_FUNCDECL_RPL (log10f, float, (float x)); 1424 _GL_CXXALIAS_RPL (log10f, float, (float x)); 1425 # else 1426 # if !@HAVE_LOG10F@ 1427 # undef log10f 1428 _GL_FUNCDECL_SYS (log10f, float, (float x)); 1429 # endif 1430 _GL_CXXALIAS_SYS (log10f, float, (float x)); 1431 # endif 1432 _GL_CXXALIASWARN (log10f); 1433 #elif defined GNULIB_POSIXCHECK 1434 # undef log10f 1435 # if HAVE_RAW_DECL_LOG10F 1436 _GL_WARN_ON_USE (log10f, "log10f is unportable - " 1437 "use gnulib module log10f for portability"); 1438 # endif 1439 #endif 1440 1441 #if @GNULIB_LOG10@ 1442 # if @REPLACE_LOG10@ 1443 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1444 # undef log10 1445 # define log10 rpl_log10 1446 # endif 1447 _GL_FUNCDECL_RPL (log10, double, (double x)); 1448 _GL_CXXALIAS_RPL (log10, double, (double x)); 1449 # else 1450 _GL_CXXALIAS_SYS (log10, double, (double x)); 1451 # endif 1452 # if __GLIBC__ >= 2 1453 _GL_CXXALIASWARN (log10); 1454 # endif 1455 #elif defined GNULIB_POSIXCHECK 1456 # undef log10 1457 # if HAVE_RAW_DECL_LOG10 1458 _GL_WARN_ON_USE (log10, "log10 has portability problems - " 1459 "use gnulib module log10 for portability"); 1460 # endif 1461 #endif 1462 1463 #if @GNULIB_LOG10L@ 1464 # if @REPLACE_LOG10L@ 1465 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1466 # undef log10l 1467 # define log10l rpl_log10l 1468 # endif 1469 _GL_FUNCDECL_RPL (log10l, long double, (long double x)); 1470 _GL_CXXALIAS_RPL (log10l, long double, (long double x)); 1471 # else 1472 # if !@HAVE_LOG10L@ || !@HAVE_DECL_LOG10L@ 1473 # undef log10l 1474 _GL_FUNCDECL_SYS (log10l, long double, (long double x)); 1475 # endif 1476 _GL_CXXALIAS_SYS (log10l, long double, (long double x)); 1477 # endif 1478 _GL_CXXALIASWARN (log10l); 1479 #elif defined GNULIB_POSIXCHECK 1480 # undef log10l 1481 # if HAVE_RAW_DECL_LOG10L 1482 _GL_WARN_ON_USE (log10l, "log10l is unportable - " 1483 "use gnulib module log10l for portability"); 1484 # endif 1485 #endif 1486 1487 1488 #if @GNULIB_LOG1PF@ 1489 # if @REPLACE_LOG1PF@ 1490 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1491 # undef log1pf 1492 # define log1pf rpl_log1pf 1493 # endif 1494 _GL_FUNCDECL_RPL (log1pf, float, (float x)); 1495 _GL_CXXALIAS_RPL (log1pf, float, (float x)); 1496 # else 1497 # if !@HAVE_LOG1PF@ 1498 _GL_FUNCDECL_SYS (log1pf, float, (float x)); 1499 # endif 1500 _GL_CXXALIAS_SYS (log1pf, float, (float x)); 1501 # endif 1502 _GL_CXXALIASWARN (log1pf); 1503 #elif defined GNULIB_POSIXCHECK 1504 # undef log1pf 1505 # if HAVE_RAW_DECL_LOG1PF 1506 _GL_WARN_ON_USE (log1pf, "log1pf is unportable - " 1507 "use gnulib module log1pf for portability"); 1508 # endif 1509 #endif 1510 1511 #if @GNULIB_LOG1P@ 1512 # if @REPLACE_LOG1P@ 1513 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1514 # undef log1p 1515 # define log1p rpl_log1p 1516 # endif 1517 _GL_FUNCDECL_RPL (log1p, double, (double x)); 1518 _GL_CXXALIAS_RPL (log1p, double, (double x)); 1519 # else 1520 # if !@HAVE_LOG1P@ 1521 _GL_FUNCDECL_SYS (log1p, double, (double x)); 1522 # endif 1523 _GL_CXXALIAS_SYS (log1p, double, (double x)); 1524 # endif 1525 # if __GLIBC__ >= 2 1526 _GL_CXXALIASWARN (log1p); 1527 # endif 1528 #elif defined GNULIB_POSIXCHECK 1529 # undef log1p 1530 # if HAVE_RAW_DECL_LOG1P 1531 _GL_WARN_ON_USE (log1p, "log1p has portability problems - " 1532 "use gnulib module log1p for portability"); 1533 # endif 1534 #endif 1535 1536 #if @GNULIB_LOG1PL@ 1537 # if @REPLACE_LOG1PL@ 1538 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1539 # undef log1pl 1540 # define log1pl rpl_log1pl 1541 # endif 1542 _GL_FUNCDECL_RPL (log1pl, long double, (long double x)); 1543 _GL_CXXALIAS_RPL (log1pl, long double, (long double x)); 1544 # else 1545 # if !@HAVE_LOG1PL@ 1546 _GL_FUNCDECL_SYS (log1pl, long double, (long double x)); 1547 # endif 1548 _GL_CXXALIAS_SYS (log1pl, long double, (long double x)); 1549 # endif 1550 _GL_CXXALIASWARN (log1pl); 1551 #elif defined GNULIB_POSIXCHECK 1552 # undef log1pl 1553 # if HAVE_RAW_DECL_LOG1PL 1554 _GL_WARN_ON_USE (log1pl, "log1pl has portability problems - " 1555 "use gnulib module log1pl for portability"); 1556 # endif 1557 #endif 1558 1559 1560 #if @GNULIB_LOG2F@ 1561 # if @REPLACE_LOG2F@ 1562 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1563 # undef log2f 1564 # define log2f rpl_log2f 1565 # endif 1566 _GL_FUNCDECL_RPL (log2f, float, (float x)); 1567 _GL_CXXALIAS_RPL (log2f, float, (float x)); 1568 # else 1569 # if !@HAVE_DECL_LOG2F@ 1570 # undef log2f 1571 _GL_FUNCDECL_SYS (log2f, float, (float x)); 1572 # endif 1573 _GL_CXXALIAS_SYS (log2f, float, (float x)); 1574 # endif 1575 _GL_CXXALIASWARN (log2f); 1576 #elif defined GNULIB_POSIXCHECK 1577 # undef log2f 1578 # if HAVE_RAW_DECL_LOG2F 1579 _GL_WARN_ON_USE (log2f, "log2f is unportable - " 1580 "use gnulib module log2f for portability"); 1581 # endif 1582 #endif 1583 1584 #if @GNULIB_LOG2@ 1585 # if @REPLACE_LOG2@ 1586 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1587 # undef log2 1588 # define log2 rpl_log2 1589 # endif 1590 _GL_FUNCDECL_RPL (log2, double, (double x)); 1591 _GL_CXXALIAS_RPL (log2, double, (double x)); 1592 # else 1593 # if !@HAVE_DECL_LOG2@ 1594 # undef log2 1595 _GL_FUNCDECL_SYS (log2, double, (double x)); 1596 # endif 1597 _GL_CXXALIAS_SYS (log2, double, (double x)); 1598 # endif 1599 # if __GLIBC__ >= 2 1600 _GL_CXXALIASWARN (log2); 1601 # endif 1602 #elif defined GNULIB_POSIXCHECK 1603 # undef log2 1604 # if HAVE_RAW_DECL_LOG2 1605 _GL_WARN_ON_USE (log2, "log2 is unportable - " 1606 "use gnulib module log2 for portability"); 1607 # endif 1608 #endif 1609 1610 #if @GNULIB_LOG2L@ 1611 # if @REPLACE_LOG2L@ 1612 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1613 # undef log2l 1614 # define log2l rpl_log2l 1615 # endif 1616 _GL_FUNCDECL_RPL (log2l, long double, (long double x)); 1617 _GL_CXXALIAS_RPL (log2l, long double, (long double x)); 1618 # else 1619 # if !@HAVE_DECL_LOG2L@ 1620 _GL_FUNCDECL_SYS (log2l, long double, (long double x)); 1621 # endif 1622 _GL_CXXALIAS_SYS (log2l, long double, (long double x)); 1623 # endif 1624 _GL_CXXALIASWARN (log2l); 1625 #elif defined GNULIB_POSIXCHECK 1626 # undef log2l 1627 # if HAVE_RAW_DECL_LOG2L 1628 _GL_WARN_ON_USE (log2l, "log2l is unportable - " 1629 "use gnulib module log2l for portability"); 1630 # endif 1631 #endif 1632 1633 1634 #if @GNULIB_LOGBF@ 1635 # if @REPLACE_LOGBF@ 1636 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1637 # undef logbf 1638 # define logbf rpl_logbf 1639 # endif 1640 _GL_FUNCDECL_RPL (logbf, float, (float x)); 1641 _GL_CXXALIAS_RPL (logbf, float, (float x)); 1642 # else 1643 # if !@HAVE_LOGBF@ 1644 _GL_FUNCDECL_SYS (logbf, float, (float x)); 1645 # endif 1646 _GL_CXXALIAS_SYS (logbf, float, (float x)); 1647 # endif 1648 _GL_CXXALIASWARN (logbf); 1649 #elif defined GNULIB_POSIXCHECK 1650 # undef logbf 1651 # if HAVE_RAW_DECL_LOGBF 1652 _GL_WARN_ON_USE (logbf, "logbf is unportable - " 1653 "use gnulib module logbf for portability"); 1654 # endif 1655 #endif 1656 1657 #if @GNULIB_LOGB@ 1658 # if @REPLACE_LOGB@ 1659 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1660 # undef logb 1661 # define logb rpl_logb 1662 # endif 1663 _GL_FUNCDECL_RPL (logb, double, (double x)); 1664 _GL_CXXALIAS_RPL (logb, double, (double x)); 1665 # else 1666 # if !@HAVE_DECL_LOGB@ 1667 _GL_FUNCDECL_SYS (logb, double, (double x)); 1668 # endif 1669 _GL_CXXALIAS_SYS (logb, double, (double x)); 1670 # endif 1671 # if __GLIBC__ >= 2 1672 _GL_CXXALIASWARN (logb); 1673 # endif 1674 #elif defined GNULIB_POSIXCHECK 1675 # undef logb 1676 # if HAVE_RAW_DECL_LOGB 1677 _GL_WARN_ON_USE (logb, "logb is unportable - " 1678 "use gnulib module logb for portability"); 1679 # endif 1680 #endif 1681 1682 #if @GNULIB_LOGBL@ 1683 # if @REPLACE_LOGBL@ 1684 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1685 # undef logbl 1686 # define logbl rpl_logbl 1687 # endif 1688 _GL_FUNCDECL_RPL (logbl, long double, (long double x)); 1689 _GL_CXXALIAS_RPL (logbl, long double, (long double x)); 1690 # else 1691 # if !@HAVE_LOGBL@ 1692 _GL_FUNCDECL_SYS (logbl, long double, (long double x)); 1693 # endif 1694 _GL_CXXALIAS_SYS (logbl, long double, (long double x)); 1695 # endif 1696 _GL_CXXALIASWARN (logbl); 1697 #elif defined GNULIB_POSIXCHECK 1698 # undef logbl 1699 # if HAVE_RAW_DECL_LOGBL 1700 _GL_WARN_ON_USE (logbl, "logbl is unportable - " 1701 "use gnulib module logbl for portability"); 1702 # endif 1703 #endif 1704 1705 1706 #if @GNULIB_MODFF@ 1707 # if @REPLACE_MODFF@ 1708 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1709 # undef modff 1710 # define modff rpl_modff 1711 # endif 1712 _GL_FUNCDECL_RPL (modff, float, (float x, float *iptr) _GL_ARG_NONNULL ((2))); 1713 _GL_CXXALIAS_RPL (modff, float, (float x, float *iptr)); 1714 # else 1715 # if !@HAVE_MODFF@ 1716 # undef modff 1717 _GL_FUNCDECL_SYS (modff, float, (float x, float *iptr) _GL_ARG_NONNULL ((2))); 1718 # endif 1719 _GL_CXXALIAS_SYS (modff, float, (float x, float *iptr)); 1720 # endif 1721 _GL_CXXALIASWARN (modff); 1722 #elif defined GNULIB_POSIXCHECK 1723 # undef modff 1724 # if HAVE_RAW_DECL_MODFF 1725 _GL_WARN_ON_USE (modff, "modff is unportable - " 1726 "use gnulib module modff for portability"); 1727 # endif 1728 #endif 1729 1730 #if @GNULIB_MODF@ 1731 # if @REPLACE_MODF@ 1732 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1733 # undef modf 1734 # define modf rpl_modf 1735 # endif 1736 _GL_FUNCDECL_RPL (modf, double, (double x, double *iptr) _GL_ARG_NONNULL ((2))); 1737 _GL_CXXALIAS_RPL (modf, double, (double x, double *iptr)); 1738 # else 1739 _GL_CXXALIAS_SYS (modf, double, (double x, double *iptr)); 1740 # endif 1741 # if __GLIBC__ >= 2 1742 _GL_CXXALIASWARN (modf); 1743 # endif 1744 #elif defined GNULIB_POSIXCHECK 1745 # undef modf 1746 # if HAVE_RAW_DECL_MODF 1747 _GL_WARN_ON_USE (modf, "modf has portability problems - " 1748 "use gnulib module modf for portability"); 1749 # endif 1750 #endif 1751 1752 #if @GNULIB_MODFL@ 1753 # if @REPLACE_MODFL@ 1754 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1755 # undef modfl 1756 # define modfl rpl_modfl 1757 # endif 1758 _GL_FUNCDECL_RPL (modfl, long double, (long double x, long double *iptr) 1759 _GL_ARG_NONNULL ((2))); 1760 _GL_CXXALIAS_RPL (modfl, long double, (long double x, long double *iptr)); 1761 # else 1762 # if !@HAVE_MODFL@ 1763 # undef modfl 1764 _GL_FUNCDECL_SYS (modfl, long double, (long double x, long double *iptr) 1765 _GL_ARG_NONNULL ((2))); 1766 # endif 1767 _GL_CXXALIAS_SYS (modfl, long double, (long double x, long double *iptr)); 1768 # endif 1769 _GL_CXXALIASWARN (modfl); 1770 #elif defined GNULIB_POSIXCHECK 1771 # undef modfl 1772 # if HAVE_RAW_DECL_MODFL 1773 _GL_WARN_ON_USE (modfl, "modfl is unportable - " 1774 "use gnulib module modfl for portability"); 1775 # endif 1776 #endif 1777 1778 1779 #if @GNULIB_POWF@ 1780 # if !@HAVE_POWF@ 1781 # undef powf 1782 _GL_FUNCDECL_SYS (powf, float, (float x, float y)); 1783 # endif 1784 _GL_CXXALIAS_SYS (powf, float, (float x, float y)); 1785 _GL_CXXALIASWARN (powf); 1786 #elif defined GNULIB_POSIXCHECK 1787 # undef powf 1788 # if HAVE_RAW_DECL_POWF 1789 _GL_WARN_ON_USE (powf, "powf is unportable - " 1790 "use gnulib module powf for portability"); 1791 # endif 1792 #endif 1793 1794 1795 #if @GNULIB_REMAINDERF@ 1796 # if @REPLACE_REMAINDERF@ 1797 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1798 # undef remainderf 1799 # define remainderf rpl_remainderf 1800 # endif 1801 _GL_FUNCDECL_RPL (remainderf, float, (float x, float y)); 1802 _GL_CXXALIAS_RPL (remainderf, float, (float x, float y)); 1803 # else 1804 # if !@HAVE_REMAINDERF@ 1805 _GL_FUNCDECL_SYS (remainderf, float, (float x, float y)); 1806 # endif 1807 _GL_CXXALIAS_SYS (remainderf, float, (float x, float y)); 1808 # endif 1809 _GL_CXXALIASWARN (remainderf); 1810 #elif defined GNULIB_POSIXCHECK 1811 # undef remainderf 1812 # if HAVE_RAW_DECL_REMAINDERF 1813 _GL_WARN_ON_USE (remainderf, "remainderf is unportable - " 1814 "use gnulib module remainderf for portability"); 1815 # endif 1816 #endif 1817 1818 #if @GNULIB_REMAINDER@ 1819 # if @REPLACE_REMAINDER@ 1820 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1821 # undef remainder 1822 # define remainder rpl_remainder 1823 # endif 1824 _GL_FUNCDECL_RPL (remainder, double, (double x, double y)); 1825 _GL_CXXALIAS_RPL (remainder, double, (double x, double y)); 1826 # else 1827 # if !@HAVE_REMAINDER@ || !@HAVE_DECL_REMAINDER@ 1828 _GL_FUNCDECL_SYS (remainder, double, (double x, double y)); 1829 # endif 1830 _GL_CXXALIAS_SYS (remainder, double, (double x, double y)); 1831 # endif 1832 # if __GLIBC__ >= 2 1833 _GL_CXXALIASWARN (remainder); 1834 # endif 1835 #elif defined GNULIB_POSIXCHECK 1836 # undef remainder 1837 # if HAVE_RAW_DECL_REMAINDER 1838 _GL_WARN_ON_USE (remainder, "remainder is unportable - " 1839 "use gnulib module remainder for portability"); 1840 # endif 1841 #endif 1842 1843 #if @GNULIB_REMAINDERL@ 1844 # if @REPLACE_REMAINDERL@ 1845 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1846 # undef remainderl 1847 # define remainderl rpl_remainderl 1848 # endif 1849 _GL_FUNCDECL_RPL (remainderl, long double, (long double x, long double y)); 1850 _GL_CXXALIAS_RPL (remainderl, long double, (long double x, long double y)); 1851 # else 1852 # if !@HAVE_DECL_REMAINDERL@ 1853 # undef remainderl 1854 # if !(defined __cplusplus && defined _AIX) 1855 _GL_FUNCDECL_SYS (remainderl, long double, (long double x, long double y)); 1856 # endif 1857 # endif 1858 _GL_CXXALIAS_SYS (remainderl, long double, (long double x, long double y)); 1859 # endif 1860 _GL_CXXALIASWARN (remainderl); 1861 #elif defined GNULIB_POSIXCHECK 1862 # undef remainderl 1863 # if HAVE_RAW_DECL_REMAINDERL 1864 _GL_WARN_ON_USE (remainderl, "remainderl is unportable - " 1865 "use gnulib module remainderl for portability"); 1866 # endif 1867 #endif 1868 1869 1870 #if @GNULIB_RINTF@ 1871 # if !@HAVE_DECL_RINTF@ 1872 _GL_FUNCDECL_SYS (rintf, float, (float x)); 1873 # endif 1874 _GL_CXXALIAS_SYS (rintf, float, (float x)); 1875 _GL_CXXALIASWARN (rintf); 1876 #elif defined GNULIB_POSIXCHECK 1877 # undef rintf 1878 # if HAVE_RAW_DECL_RINTF 1879 _GL_WARN_ON_USE (rintf, "rintf is unportable - " 1880 "use gnulib module rintf for portability"); 1881 # endif 1882 #endif 1883 1884 #if @GNULIB_RINT@ 1885 # if !@HAVE_RINT@ 1886 _GL_FUNCDECL_SYS (rint, double, (double x)); 1887 # endif 1888 _GL_CXXALIAS_SYS (rint, double, (double x)); 1889 # if __GLIBC__ >= 2 1890 _GL_CXXALIASWARN (rint); 1891 # endif 1892 #elif defined GNULIB_POSIXCHECK 1893 # undef rint 1894 # if HAVE_RAW_DECL_RINT 1895 _GL_WARN_ON_USE (rint, "rint is unportable - " 1896 "use gnulib module rint for portability"); 1897 # endif 1898 #endif 1899 1900 #if @GNULIB_RINTL@ 1901 # if @REPLACE_RINTL@ 1902 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1903 # undef rintl 1904 # define rintl rpl_rintl 1905 # endif 1906 _GL_FUNCDECL_RPL (rintl, long double, (long double x)); 1907 _GL_CXXALIAS_RPL (rintl, long double, (long double x)); 1908 # else 1909 # if !@HAVE_RINTL@ 1910 _GL_FUNCDECL_SYS (rintl, long double, (long double x)); 1911 # endif 1912 _GL_CXXALIAS_SYS (rintl, long double, (long double x)); 1913 # endif 1914 _GL_CXXALIASWARN (rintl); 1915 #elif defined GNULIB_POSIXCHECK 1916 # undef rintl 1917 # if HAVE_RAW_DECL_RINTL 1918 _GL_WARN_ON_USE (rintl, "rintl is unportable - " 1919 "use gnulib module rintl for portability"); 1920 # endif 1921 #endif 1922 1923 1924 #if @GNULIB_ROUNDF@ 1925 # if @REPLACE_ROUNDF@ 1926 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1927 # undef roundf 1928 # define roundf rpl_roundf 1929 # endif 1930 _GL_FUNCDECL_RPL (roundf, float, (float x)); 1931 _GL_CXXALIAS_RPL (roundf, float, (float x)); 1932 # else 1933 # if !@HAVE_DECL_ROUNDF@ 1934 _GL_FUNCDECL_SYS (roundf, float, (float x)); 1935 # endif 1936 _GL_CXXALIAS_SYS (roundf, float, (float x)); 1937 # endif 1938 _GL_CXXALIASWARN (roundf); 1939 #elif defined GNULIB_POSIXCHECK 1940 # undef roundf 1941 # if HAVE_RAW_DECL_ROUNDF 1942 _GL_WARN_ON_USE (roundf, "roundf is unportable - " 1943 "use gnulib module roundf for portability"); 1944 # endif 1945 #endif 1946 1947 #if @GNULIB_ROUND@ 1948 # if @REPLACE_ROUND@ 1949 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1950 # undef round 1951 # define round rpl_round 1952 # endif 1953 _GL_FUNCDECL_RPL (round, double, (double x)); 1954 _GL_CXXALIAS_RPL (round, double, (double x)); 1955 # else 1956 # if !@HAVE_DECL_ROUND@ 1957 _GL_FUNCDECL_SYS (round, double, (double x)); 1958 # endif 1959 _GL_CXXALIAS_SYS (round, double, (double x)); 1960 # endif 1961 # if __GLIBC__ >= 2 1962 _GL_CXXALIASWARN (round); 1963 # endif 1964 #elif defined GNULIB_POSIXCHECK 1965 # undef round 1966 # if HAVE_RAW_DECL_ROUND 1967 _GL_WARN_ON_USE (round, "round is unportable - " 1968 "use gnulib module round for portability"); 1969 # endif 1970 #endif 1971 1972 #if @GNULIB_ROUNDL@ 1973 # if @REPLACE_ROUNDL@ 1974 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1975 # undef roundl 1976 # define roundl rpl_roundl 1977 # endif 1978 _GL_FUNCDECL_RPL (roundl, long double, (long double x)); 1979 _GL_CXXALIAS_RPL (roundl, long double, (long double x)); 1980 # else 1981 # if !@HAVE_DECL_ROUNDL@ 1982 # undef roundl 1983 # if !(defined __cplusplus && defined _AIX) 1984 _GL_FUNCDECL_SYS (roundl, long double, (long double x)); 1985 # endif 1986 # endif 1987 _GL_CXXALIAS_SYS (roundl, long double, (long double x)); 1988 # endif 1989 _GL_CXXALIASWARN (roundl); 1990 #elif defined GNULIB_POSIXCHECK 1991 # undef roundl 1992 # if HAVE_RAW_DECL_ROUNDL 1993 _GL_WARN_ON_USE (roundl, "roundl is unportable - " 1994 "use gnulib module roundl for portability"); 1995 # endif 1996 #endif 1997 1998 1999 #if @GNULIB_SINF@ 2000 # if @REPLACE_SINF@ 2001 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2002 # undef sinf 2003 # define sinf rpl_sinf 2004 # endif 2005 _GL_FUNCDECL_RPL (sinf, float, (float x)); 2006 _GL_CXXALIAS_RPL (sinf, float, (float x)); 2007 # else 2008 # if !@HAVE_SINF@ 2009 # undef sinf 2010 _GL_FUNCDECL_SYS (sinf, float, (float x)); 2011 # endif 2012 _GL_CXXALIAS_SYS (sinf, float, (float x)); 2013 # endif 2014 _GL_CXXALIASWARN (sinf); 2015 #elif defined GNULIB_POSIXCHECK 2016 # undef sinf 2017 # if HAVE_RAW_DECL_SINF 2018 _GL_WARN_ON_USE (sinf, "sinf is unportable - " 2019 "use gnulib module sinf for portability"); 2020 # endif 2021 #endif 2022 2023 #if @GNULIB_SINL@ 2024 # if !@HAVE_SINL@ || !@HAVE_DECL_SINL@ 2025 # undef sinl 2026 _GL_FUNCDECL_SYS (sinl, long double, (long double x)); 2027 # endif 2028 _GL_CXXALIAS_SYS (sinl, long double, (long double x)); 2029 _GL_CXXALIASWARN (sinl); 2030 #elif defined GNULIB_POSIXCHECK 2031 # undef sinl 2032 # if HAVE_RAW_DECL_SINL 2033 _GL_WARN_ON_USE (sinl, "sinl is unportable - " 2034 "use gnulib module sinl for portability"); 2035 # endif 2036 #endif 2037 2038 2039 #if @GNULIB_SINHF@ 2040 # if @REPLACE_SINHF@ 2041 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2042 # undef sinhf 2043 # define sinhf rpl_sinhf 2044 # endif 2045 _GL_FUNCDECL_RPL (sinhf, float, (float x)); 2046 _GL_CXXALIAS_RPL (sinhf, float, (float x)); 2047 # else 2048 # if !@HAVE_SINHF@ 2049 # undef sinhf 2050 _GL_FUNCDECL_SYS (sinhf, float, (float x)); 2051 # endif 2052 _GL_CXXALIAS_SYS (sinhf, float, (float x)); 2053 # endif 2054 _GL_CXXALIASWARN (sinhf); 2055 #elif defined GNULIB_POSIXCHECK 2056 # undef sinhf 2057 # if HAVE_RAW_DECL_SINHF 2058 _GL_WARN_ON_USE (sinhf, "sinhf is unportable - " 2059 "use gnulib module sinhf for portability"); 2060 # endif 2061 #endif 2062 2063 2064 #if @GNULIB_SQRTF@ 2065 # if @REPLACE_SQRTF@ 2066 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2067 # undef sqrtf 2068 # define sqrtf rpl_sqrtf 2069 # endif 2070 _GL_FUNCDECL_RPL (sqrtf, float, (float x)); 2071 _GL_CXXALIAS_RPL (sqrtf, float, (float x)); 2072 # else 2073 # if !@HAVE_SQRTF@ 2074 # undef sqrtf 2075 _GL_FUNCDECL_SYS (sqrtf, float, (float x)); 2076 # endif 2077 _GL_CXXALIAS_SYS (sqrtf, float, (float x)); 2078 # endif 2079 _GL_CXXALIASWARN (sqrtf); 2080 #elif defined GNULIB_POSIXCHECK 2081 # undef sqrtf 2082 # if HAVE_RAW_DECL_SQRTF 2083 _GL_WARN_ON_USE (sqrtf, "sqrtf is unportable - " 2084 "use gnulib module sqrtf for portability"); 2085 # endif 2086 #endif 2087 2088 #if @GNULIB_SQRTL@ 2089 # if @REPLACE_SQRTL@ 2090 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2091 # undef sqrtl 2092 # define sqrtl rpl_sqrtl 2093 # endif 2094 _GL_FUNCDECL_RPL (sqrtl, long double, (long double x)); 2095 _GL_CXXALIAS_RPL (sqrtl, long double, (long double x)); 2096 # else 2097 # if !@HAVE_SQRTL@ || !@HAVE_DECL_SQRTL@ 2098 # undef sqrtl 2099 _GL_FUNCDECL_SYS (sqrtl, long double, (long double x)); 2100 # endif 2101 _GL_CXXALIAS_SYS (sqrtl, long double, (long double x)); 2102 # endif 2103 _GL_CXXALIASWARN (sqrtl); 2104 #elif defined GNULIB_POSIXCHECK 2105 # undef sqrtl 2106 # if HAVE_RAW_DECL_SQRTL 2107 _GL_WARN_ON_USE (sqrtl, "sqrtl is unportable - " 2108 "use gnulib module sqrtl for portability"); 2109 # endif 2110 #endif 2111 2112 2113 #if @GNULIB_TANF@ 2114 # if @REPLACE_TANF@ 2115 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2116 # undef tanf 2117 # define tanf rpl_tanf 2118 # endif 2119 _GL_FUNCDECL_RPL (tanf, float, (float x)); 2120 _GL_CXXALIAS_RPL (tanf, float, (float x)); 2121 # else 2122 # if !@HAVE_TANF@ 2123 # undef tanf 2124 _GL_FUNCDECL_SYS (tanf, float, (float x)); 2125 # endif 2126 _GL_CXXALIAS_SYS (tanf, float, (float x)); 2127 # endif 2128 _GL_CXXALIASWARN (tanf); 2129 #elif defined GNULIB_POSIXCHECK 2130 # undef tanf 2131 # if HAVE_RAW_DECL_TANF 2132 _GL_WARN_ON_USE (tanf, "tanf is unportable - " 2133 "use gnulib module tanf for portability"); 2134 # endif 2135 #endif 2136 2137 #if @GNULIB_TANL@ 2138 # if !@HAVE_TANL@ || !@HAVE_DECL_TANL@ 2139 # undef tanl 2140 _GL_FUNCDECL_SYS (tanl, long double, (long double x)); 2141 # endif 2142 _GL_CXXALIAS_SYS (tanl, long double, (long double x)); 2143 _GL_CXXALIASWARN (tanl); 2144 #elif defined GNULIB_POSIXCHECK 2145 # undef tanl 2146 # if HAVE_RAW_DECL_TANL 2147 _GL_WARN_ON_USE (tanl, "tanl is unportable - " 2148 "use gnulib module tanl for portability"); 2149 # endif 2150 #endif 2151 2152 2153 #if @GNULIB_TANHF@ 2154 # if @REPLACE_TANHF@ 2155 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2156 # undef tanhf 2157 # define tanhf rpl_tanhf 2158 # endif 2159 _GL_FUNCDECL_RPL (tanhf, float, (float x)); 2160 _GL_CXXALIAS_RPL (tanhf, float, (float x)); 2161 # else 2162 # if !@HAVE_TANHF@ 2163 # undef tanhf 2164 _GL_FUNCDECL_SYS (tanhf, float, (float x)); 2165 # endif 2166 _GL_CXXALIAS_SYS (tanhf, float, (float x)); 2167 # endif 2168 _GL_CXXALIASWARN (tanhf); 2169 #elif defined GNULIB_POSIXCHECK 2170 # undef tanhf 2171 # if HAVE_RAW_DECL_TANHF 2172 _GL_WARN_ON_USE (tanhf, "tanhf is unportable - " 2173 "use gnulib module tanhf for portability"); 2174 # endif 2175 #endif 2176 2177 2178 #if @GNULIB_TRUNCF@ 2179 # if @REPLACE_TRUNCF@ 2180 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2181 # undef truncf 2182 # define truncf rpl_truncf 2183 # endif 2184 _GL_FUNCDECL_RPL (truncf, float, (float x)); 2185 _GL_CXXALIAS_RPL (truncf, float, (float x)); 2186 # else 2187 # if !@HAVE_DECL_TRUNCF@ 2188 _GL_FUNCDECL_SYS (truncf, float, (float x)); 2189 # endif 2190 _GL_CXXALIAS_SYS (truncf, float, (float x)); 2191 # endif 2192 _GL_CXXALIASWARN (truncf); 2193 #elif defined GNULIB_POSIXCHECK 2194 # undef truncf 2195 # if HAVE_RAW_DECL_TRUNCF 2196 _GL_WARN_ON_USE (truncf, "truncf is unportable - " 2197 "use gnulib module truncf for portability"); 2198 # endif 2199 #endif 2200 2201 #if @GNULIB_TRUNC@ 2202 # if @REPLACE_TRUNC@ 2203 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2204 # undef trunc 2205 # define trunc rpl_trunc 2206 # endif 2207 _GL_FUNCDECL_RPL (trunc, double, (double x)); 2208 _GL_CXXALIAS_RPL (trunc, double, (double x)); 2209 # else 2210 # if !@HAVE_DECL_TRUNC@ 2211 _GL_FUNCDECL_SYS (trunc, double, (double x)); 2212 # endif 2213 _GL_CXXALIAS_SYS (trunc, double, (double x)); 2214 # endif 2215 # if __GLIBC__ >= 2 2216 _GL_CXXALIASWARN (trunc); 2217 # endif 2218 #elif defined GNULIB_POSIXCHECK 2219 # undef trunc 2220 # if HAVE_RAW_DECL_TRUNC 2221 _GL_WARN_ON_USE (trunc, "trunc is unportable - " 2222 "use gnulib module trunc for portability"); 2223 # endif 2224 #endif 2225 2226 #if @GNULIB_TRUNCL@ 2227 # if @REPLACE_TRUNCL@ 2228 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2229 # undef truncl 2230 # define truncl rpl_truncl 2231 # endif 2232 _GL_FUNCDECL_RPL (truncl, long double, (long double x)); 2233 _GL_CXXALIAS_RPL (truncl, long double, (long double x)); 2234 # else 2235 # if !@HAVE_DECL_TRUNCL@ 2236 _GL_FUNCDECL_SYS (truncl, long double, (long double x)); 2237 # endif 2238 _GL_CXXALIAS_SYS (truncl, long double, (long double x)); 2239 # endif 2240 _GL_CXXALIASWARN (truncl); 2241 #elif defined GNULIB_POSIXCHECK 2242 # undef truncl 2243 # if HAVE_RAW_DECL_TRUNCL 2244 _GL_WARN_ON_USE (truncl, "truncl is unportable - " 2245 "use gnulib module truncl for portability"); 2246 # endif 2247 #endif 2248 2249 2250 /* Definitions of function-like macros come here, after the function 2251 declarations. */ 2252 2253 2254 #if @GNULIB_ISFINITE@ 2255 # if @REPLACE_ISFINITE@ 2256 _GL_EXTERN_C int gl_isfinitef (float x); 2257 _GL_EXTERN_C int gl_isfinited (double x); 2258 _GL_EXTERN_C int gl_isfinitel (long double x); 2259 # undef isfinite 2260 # define isfinite(x) \ 2261 (sizeof (x) == sizeof (long double) ? gl_isfinitel (x) : \ 2262 sizeof (x) == sizeof (double) ? gl_isfinited (x) : \ 2263 gl_isfinitef (x)) 2264 # endif 2265 # ifdef __cplusplus 2266 # if defined isfinite || defined GNULIB_NAMESPACE 2267 _GL_MATH_CXX_REAL_FLOATING_DECL_1 (isfinite) 2268 # undef isfinite 2269 # if __GNUC__ >= 6 || (defined __clang__ && !((defined __APPLE__ && defined __MACH__) || defined __FreeBSD__ || defined _AIX)) 2270 /* This platform's <cmath> possibly defines isfinite through a set of inline 2271 functions. */ 2272 _GL_MATH_CXX_REAL_FLOATING_DECL_2 (isfinite, rpl_isfinite, bool) 2273 # define isfinite rpl_isfinite 2274 # else 2275 _GL_MATH_CXX_REAL_FLOATING_DECL_2 (isfinite, isfinite, bool) 2276 # endif 2277 # endif 2278 # endif 2279 #elif defined GNULIB_POSIXCHECK 2280 # if defined isfinite 2281 _GL_WARN_REAL_FLOATING_DECL (isfinite); 2282 # undef isfinite 2283 # define isfinite(x) _GL_WARN_REAL_FLOATING_IMPL (isfinite, x) 2284 # endif 2285 #endif 2286 2287 2288 #if @GNULIB_ISINF@ 2289 # if @REPLACE_ISINF@ 2290 _GL_EXTERN_C int gl_isinff (float x); 2291 _GL_EXTERN_C int gl_isinfd (double x); 2292 _GL_EXTERN_C int gl_isinfl (long double x); 2293 # undef isinf 2294 # define isinf(x) \ 2295 (sizeof (x) == sizeof (long double) ? gl_isinfl (x) : \ 2296 sizeof (x) == sizeof (double) ? gl_isinfd (x) : \ 2297 gl_isinff (x)) 2298 # endif 2299 # ifdef __cplusplus 2300 # if defined isinf || defined GNULIB_NAMESPACE 2301 _GL_MATH_CXX_REAL_FLOATING_DECL_1 (isinf) 2302 # undef isinf 2303 # if __GNUC__ >= 6 || (defined __clang__ && !((defined __APPLE__ && defined __MACH__) || defined __FreeBSD__)) 2304 /* This platform's <cmath> possibly defines isinf through a set of inline 2305 functions. */ 2306 _GL_MATH_CXX_REAL_FLOATING_DECL_2 (isinf, rpl_isinf, bool) 2307 # define isinf rpl_isinf 2308 # else 2309 _GL_MATH_CXX_REAL_FLOATING_DECL_2 (isinf, isinf, bool) 2310 # endif 2311 # endif 2312 # endif 2313 #elif defined GNULIB_POSIXCHECK 2314 # if defined isinf 2315 _GL_WARN_REAL_FLOATING_DECL (isinf); 2316 # undef isinf 2317 # define isinf(x) _GL_WARN_REAL_FLOATING_IMPL (isinf, x) 2318 # endif 2319 #endif 2320 2321 2322 #if @GNULIB_ISNANF@ 2323 /* Test for NaN for 'float' numbers. */ 2324 # if @HAVE_ISNANF@ 2325 /* The original <math.h> included above provides a declaration of isnan macro 2326 or (older) isnanf function. */ 2327 # if __GNUC__ >= 4 && (!defined __clang__ || __has_builtin (__builtin_isnanf)) 2328 /* GCC 4.0 and newer provides three built-ins for isnan. */ 2329 # undef isnanf 2330 # define isnanf(x) __builtin_isnanf ((float)(x)) 2331 # elif defined isnan 2332 # undef isnanf 2333 # define isnanf(x) isnan ((float)(x)) 2334 # endif 2335 # else 2336 /* Test whether X is a NaN. */ 2337 # undef isnanf 2338 # define isnanf rpl_isnanf 2339 _GL_EXTERN_C int isnanf (float x); 2340 # endif 2341 #endif 2342 2343 #if @GNULIB_ISNAND@ 2344 /* Test for NaN for 'double' numbers. 2345 This function is a gnulib extension, unlike isnan() which applied only 2346 to 'double' numbers earlier but now is a type-generic macro. */ 2347 # if @HAVE_ISNAND@ 2348 /* The original <math.h> included above provides a declaration of isnan 2349 macro. */ 2350 # if __GNUC__ >= 4 2351 /* GCC 4.0 and newer provides three built-ins for isnan. */ 2352 # undef isnand 2353 # define isnand(x) __builtin_isnan ((double)(x)) 2354 # else 2355 # undef isnand 2356 # define isnand(x) isnan ((double)(x)) 2357 # endif 2358 # else 2359 /* Test whether X is a NaN. */ 2360 # undef isnand 2361 # define isnand rpl_isnand 2362 _GL_EXTERN_C int isnand (double x); 2363 # endif 2364 #endif 2365 2366 #if @GNULIB_ISNANL@ 2367 /* Test for NaN for 'long double' numbers. */ 2368 # if @HAVE_ISNANL@ 2369 /* The original <math.h> included above provides a declaration of isnan 2370 macro or (older) isnanl function. */ 2371 # if __GNUC__ >= 4 && (!defined __clang__ || __has_builtin (__builtin_isnanl)) 2372 /* GCC 4.0 and newer provides three built-ins for isnan. */ 2373 # undef isnanl 2374 # define isnanl(x) __builtin_isnanl ((long double)(x)) 2375 # elif defined isnan 2376 # undef isnanl 2377 # define isnanl(x) isnan ((long double)(x)) 2378 # endif 2379 # else 2380 /* Test whether X is a NaN. */ 2381 # undef isnanl 2382 # define isnanl rpl_isnanl 2383 _GL_EXTERN_C int isnanl (long double x) _GL_ATTRIBUTE_CONST; 2384 # endif 2385 #endif 2386 2387 /* This must come *after* the snippets for GNULIB_ISNANF and GNULIB_ISNANL! */ 2388 #if @GNULIB_ISNAN@ 2389 # if @REPLACE_ISNAN@ 2390 /* We can't just use the isnanf macro (e.g.) as exposed by 2391 isnanf.h (e.g.) here, because those may end up being macros 2392 that recursively expand back to isnan. So use the gnulib 2393 replacements for them directly. */ 2394 # if @HAVE_ISNANF@ && __GNUC__ >= 4 && (!defined __clang__ || __has_builtin (__builtin_isnanf)) 2395 # define gl_isnan_f(x) __builtin_isnanf ((float)(x)) 2396 # else 2397 _GL_EXTERN_C int rpl_isnanf (float x); 2398 # define gl_isnan_f(x) rpl_isnanf (x) 2399 # endif 2400 # if @HAVE_ISNAND@ && __GNUC__ >= 4 2401 # define gl_isnan_d(x) __builtin_isnan ((double)(x)) 2402 # else 2403 _GL_EXTERN_C int rpl_isnand (double x); 2404 # define gl_isnan_d(x) rpl_isnand (x) 2405 # endif 2406 # if @HAVE_ISNANL@ && __GNUC__ >= 4 && (!defined __clang__ || __has_builtin (__builtin_isnanl)) 2407 # define gl_isnan_l(x) __builtin_isnanl ((long double)(x)) 2408 # else 2409 _GL_EXTERN_C int rpl_isnanl (long double x) _GL_ATTRIBUTE_CONST; 2410 # define gl_isnan_l(x) rpl_isnanl (x) 2411 # endif 2412 # undef isnan 2413 # define isnan(x) \ 2414 (sizeof (x) == sizeof (long double) ? gl_isnan_l (x) : \ 2415 sizeof (x) == sizeof (double) ? gl_isnan_d (x) : \ 2416 gl_isnan_f (x)) 2417 # elif __GNUC__ >= 4 && (!defined __clang__ || (__has_builtin (__builtin_isnanf) && __has_builtin (__builtin_isnanl))) 2418 # undef isnan 2419 # define isnan(x) \ 2420 (sizeof (x) == sizeof (long double) ? __builtin_isnanl ((long double)(x)) : \ 2421 sizeof (x) == sizeof (double) ? __builtin_isnan ((double)(x)) : \ 2422 __builtin_isnanf ((float)(x))) 2423 # endif 2424 # ifdef __cplusplus 2425 # if defined isnan || defined GNULIB_NAMESPACE 2426 _GL_MATH_CXX_REAL_FLOATING_DECL_1 (isnan) 2427 # undef isnan 2428 # if __GNUC__ >= 6 || (defined __clang__ && !((defined __APPLE__ && defined __MACH__) || defined __FreeBSD__)) 2429 /* This platform's <cmath> possibly defines isnan through a set of inline 2430 functions. */ 2431 _GL_MATH_CXX_REAL_FLOATING_DECL_2 (isnan, rpl_isnan, bool) 2432 # define isnan rpl_isnan 2433 # else 2434 _GL_MATH_CXX_REAL_FLOATING_DECL_2 (isnan, isnan, bool) 2435 # endif 2436 # endif 2437 # else 2438 /* Ensure isnan is a macro. */ 2439 # ifndef isnan 2440 # define isnan isnan 2441 # endif 2442 # endif 2443 #elif defined GNULIB_POSIXCHECK 2444 # if defined isnan 2445 _GL_WARN_REAL_FLOATING_DECL (isnan); 2446 # undef isnan 2447 # define isnan(x) _GL_WARN_REAL_FLOATING_IMPL (isnan, x) 2448 # endif 2449 #endif 2450 2451 2452 #if @GNULIB_SIGNBIT@ 2453 # if (@REPLACE_SIGNBIT_USING_GCC@ \ 2454 && (!defined __cplusplus || __cplusplus < 201103)) 2455 # undef signbit 2456 /* GCC 4.0 and newer provides three built-ins for signbit. */ 2457 # define signbit(x) \ 2458 (sizeof (x) == sizeof (long double) ? __builtin_signbitl (x) : \ 2459 sizeof (x) == sizeof (double) ? __builtin_signbit (x) : \ 2460 __builtin_signbitf (x)) 2461 # endif 2462 # if @REPLACE_SIGNBIT@ && !GNULIB_defined_signbit 2463 # undef signbit 2464 _GL_EXTERN_C int gl_signbitf (float arg); 2465 _GL_EXTERN_C int gl_signbitd (double arg); 2466 _GL_EXTERN_C int gl_signbitl (long double arg); 2467 # if __GNUC__ >= 2 && !defined __STRICT_ANSI__ 2468 # define _GL_NUM_UINT_WORDS(type) \ 2469 ((sizeof (type) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) 2470 # if defined FLT_SIGNBIT_WORD && defined FLT_SIGNBIT_BIT && !defined gl_signbitf 2471 # define gl_signbitf_OPTIMIZED_MACRO 2472 # define gl_signbitf(arg) \ 2473 ({ union { float _value; \ 2474 unsigned int _word[_GL_NUM_UINT_WORDS (float)]; \ 2475 } _m; \ 2476 _m._value = (arg); \ 2477 (_m._word[FLT_SIGNBIT_WORD] >> FLT_SIGNBIT_BIT) & 1; \ 2478 }) 2479 # endif 2480 # if defined DBL_SIGNBIT_WORD && defined DBL_SIGNBIT_BIT && !defined gl_signbitd 2481 # define gl_signbitd_OPTIMIZED_MACRO 2482 # define gl_signbitd(arg) \ 2483 ({ union { double _value; \ 2484 unsigned int _word[_GL_NUM_UINT_WORDS (double)]; \ 2485 } _m; \ 2486 _m._value = (arg); \ 2487 (_m._word[DBL_SIGNBIT_WORD] >> DBL_SIGNBIT_BIT) & 1; \ 2488 }) 2489 # endif 2490 # if defined LDBL_SIGNBIT_WORD && defined LDBL_SIGNBIT_BIT && !defined gl_signbitl 2491 # define gl_signbitl_OPTIMIZED_MACRO 2492 # define gl_signbitl(arg) \ 2493 ({ union { long double _value; \ 2494 unsigned int _word[_GL_NUM_UINT_WORDS (long double)]; \ 2495 } _m; \ 2496 _m._value = (arg); \ 2497 (_m._word[LDBL_SIGNBIT_WORD] >> LDBL_SIGNBIT_BIT) & 1; \ 2498 }) 2499 # endif 2500 # endif 2501 # define signbit(x) \ 2502 (sizeof (x) == sizeof (long double) ? gl_signbitl (x) : \ 2503 sizeof (x) == sizeof (double) ? gl_signbitd (x) : \ 2504 gl_signbitf (x)) 2505 # define GNULIB_defined_signbit 1 2506 # endif 2507 # ifdef __cplusplus 2508 # if defined signbit || defined GNULIB_NAMESPACE 2509 _GL_MATH_CXX_REAL_FLOATING_DECL_1 (signbit) 2510 # undef signbit 2511 # if __GNUC__ >= 6 || (defined __clang__ && !((defined __APPLE__ && defined __MACH__) || defined __FreeBSD__ || defined _AIX)) 2512 /* This platform's <cmath> possibly defines signbit through a set of inline 2513 functions. */ 2514 _GL_MATH_CXX_REAL_FLOATING_DECL_2 (signbit, rpl_signbit, bool) 2515 # define signbit rpl_signbit 2516 # else 2517 _GL_MATH_CXX_REAL_FLOATING_DECL_2 (signbit, signbit, bool) 2518 # endif 2519 # endif 2520 # endif 2521 #elif defined GNULIB_POSIXCHECK 2522 # if defined signbit 2523 _GL_WARN_REAL_FLOATING_DECL (signbit); 2524 # undef signbit 2525 # define signbit(x) _GL_WARN_REAL_FLOATING_IMPL (signbit, x) 2526 # endif 2527 #endif 2528 2529 _GL_INLINE_HEADER_END 2530 2531 #endif /* _@GUARD_PREFIX@_MATH_H */ 2532 #endif /* _@GUARD_PREFIX@_MATH_H */ 2533