1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2011 Nexenta Systems, Inc. All rights reserved. 23 */ 24 /* 25 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 26 * Use is subject to license terms. 27 */ 28 29 #ifndef _ISO_MATH_C99_H 30 #define _ISO_MATH_C99_H 31 32 #include <sys/isa_defs.h> 33 #include <sys/feature_tests.h> 34 35 #ifdef __cplusplus 36 extern "C" { 37 #endif 38 39 #undef FP_ZERO 40 #define FP_ZERO 0 41 #undef FP_SUBNORMAL 42 #define FP_SUBNORMAL 1 43 #undef FP_NORMAL 44 #define FP_NORMAL 2 45 #undef FP_INFINITE 46 #define FP_INFINITE 3 47 #undef FP_NAN 48 #define FP_NAN 4 49 50 #if defined(_STDC_C99) || _XOPEN_SOURCE - 0 >= 600 || defined(__C99FEATURES__) 51 #if defined(__GNUC__) 52 #undef HUGE_VAL 53 #define HUGE_VAL (__builtin_huge_val()) 54 #undef HUGE_VALF 55 #define HUGE_VALF (__builtin_huge_valf()) 56 #undef HUGE_VALL 57 #define HUGE_VALL (__builtin_huge_vall()) 58 #undef INFINITY 59 #define INFINITY (__builtin_inff()) 60 #undef NAN 61 #define NAN (__builtin_nanf("")) 62 63 /* 64 * C99 7.12.3 classification macros 65 */ 66 #undef isnan 67 #undef isinf 68 #if __GNUC__ >= 4 69 #define fpclassify(x) __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, \ 70 FP_SUBNORMAL, FP_ZERO, x) 71 #define isnan(x) __builtin_isnan(x) 72 #define isinf(x) __builtin_isinf(x) 73 #define isfinite(x) (__builtin_isfinite(x) != 0) 74 #define isnormal(x) (__builtin_isnormal(x) != 0) 75 #define signbit(x) (__builtin_signbit(x) != 0) 76 #else /* __GNUC__ >= 4 */ 77 #define isnan(x) __extension__( \ 78 { __typeof(x) __x_n = (x); \ 79 __builtin_isunordered(__x_n, __x_n); }) 80 #define isinf(x) __extension__( \ 81 { __typeof(x) __x_i = (x); \ 82 __x_i == (__typeof(__x_i)) INFINITY || \ 83 __x_i == (__typeof(__x_i)) (-INFINITY); }) 84 #undef isfinite 85 #define isfinite(x) __extension__( \ 86 { __typeof(x) __x_f = (x); \ 87 !isnan(__x_f) && !isinf(__x_f); }) 88 #undef isnormal 89 #define isnormal(x) __extension__( \ 90 { __typeof(x) __x_r = (x); isfinite(__x_r) && \ 91 (sizeof (__x_r) == sizeof (float) ? \ 92 __builtin_fabsf(__x_r) >= __FLT_MIN__ : \ 93 sizeof (__x_r) == sizeof (double) ? \ 94 __builtin_fabs(__x_r) >= __DBL_MIN__ : \ 95 __builtin_fabsl(__x_r) >= __LDBL_MIN__); }) 96 #undef fpclassify 97 #define fpclassify(x) __extension__( \ 98 { __typeof(x) __x_c = (x); \ 99 isnan(__x_c) ? FP_NAN : \ 100 isinf(__x_c) ? FP_INFINITE : \ 101 isnormal(__x_c) ? FP_NORMAL : \ 102 __x_c == (__typeof(__x_c)) 0 ? FP_ZERO : \ 103 FP_SUBNORMAL; }) 104 #undef signbit 105 #if defined(_BIG_ENDIAN) 106 #define signbit(x) __extension__( \ 107 { __typeof(x) __x_s = (x); \ 108 (int)(*(unsigned *)&__x_s >> 31); }) 109 #elif defined(_LITTLE_ENDIAN) 110 #define signbit(x) __extension__( \ 111 { __typeof(x) __x_s = (x); \ 112 (sizeof (__x_s) == sizeof (float) ? \ 113 (int)(*(unsigned *)&__x_s >> 31) : \ 114 sizeof (__x_s) == sizeof (double) ? \ 115 (int)(((unsigned *)&__x_s)[1] >> 31) : \ 116 (int)(((unsigned short *)&__x_s)[4] >> 15)); }) 117 #endif /* defined(_BIG_ENDIAN) */ 118 #endif /* __GNUC__ >= 4 */ 119 120 /* 121 * C99 7.12.14 comparison macros 122 */ 123 #undef isgreater 124 #define isgreater(x, y) __builtin_isgreater(x, y) 125 #undef isgreaterequal 126 #define isgreaterequal(x, y) __builtin_isgreaterequal(x, y) 127 #undef isless 128 #define isless(x, y) __builtin_isless(x, y) 129 #undef islessequal 130 #define islessequal(x, y) __builtin_islessequal(x, y) 131 #undef islessgreater 132 #define islessgreater(x, y) __builtin_islessgreater(x, y) 133 #undef isunordered 134 #define isunordered(x, y) __builtin_isunordered(x, y) 135 #else /* defined(__GNUC__) */ 136 #undef HUGE_VAL 137 #define HUGE_VAL __builtin_huge_val 138 #undef HUGE_VALF 139 #define HUGE_VALF __builtin_huge_valf 140 #undef HUGE_VALL 141 #define HUGE_VALL __builtin_huge_vall 142 #undef INFINITY 143 #define INFINITY __builtin_infinity 144 #undef NAN 145 #define NAN __builtin_nan 146 147 /* 148 * C99 7.12.3 classification macros 149 */ 150 #undef fpclassify 151 #define fpclassify(x) __builtin_fpclassify(x) 152 #undef isfinite 153 #define isfinite(x) __builtin_isfinite(x) 154 #undef isinf 155 #define isinf(x) __builtin_isinf(x) 156 #undef isnan 157 #define isnan(x) __builtin_isnan(x) 158 #undef isnormal 159 #define isnormal(x) __builtin_isnormal(x) 160 #undef signbit 161 #define signbit(x) __builtin_signbit(x) 162 163 /* 164 * C99 7.12.14 comparison macros 165 */ 166 #undef isgreater 167 #define isgreater(x, y) ((x) __builtin_isgreater(y)) 168 #undef isgreaterequal 169 #define isgreaterequal(x, y) ((x) __builtin_isgreaterequal(y)) 170 #undef isless 171 #define isless(x, y) ((x) __builtin_isless(y)) 172 #undef islessequal 173 #define islessequal(x, y) ((x) __builtin_islessequal(y)) 174 #undef islessgreater 175 #define islessgreater(x, y) ((x) __builtin_islessgreater(y)) 176 #undef isunordered 177 #define isunordered(x, y) ((x) __builtin_isunordered(y)) 178 #endif /* defined(__GNUC__) */ 179 #endif /* defined(_STDC_C99) || _XOPEN_SOURCE - 0 >= 600 || ... */ 180 181 #if defined(__EXTENSIONS__) || defined(_STDC_C99) || \ 182 (!defined(_STRICT_STDC) && !defined(__XOPEN_OR_POSIX)) || \ 183 defined(__C99FEATURES__) 184 #if defined(__FLT_EVAL_METHOD__) && __FLT_EVAL_METHOD__ - 0 == 0 185 typedef float float_t; 186 typedef double double_t; 187 #elif __FLT_EVAL_METHOD__ - 0 == 1 188 typedef double float_t; 189 typedef double double_t; 190 #elif __FLT_EVAL_METHOD__ - 0 == 2 191 typedef long double float_t; 192 typedef long double double_t; 193 #elif defined(__sparc) || defined(__amd64) 194 typedef float float_t; 195 typedef double double_t; 196 #elif defined(__i386) 197 typedef long double float_t; 198 typedef long double double_t; 199 #endif 200 201 #undef FP_ILOGB0 202 #define FP_ILOGB0 (-2147483647) 203 #undef FP_ILOGBNAN 204 #define FP_ILOGBNAN 2147483647 205 206 #undef MATH_ERRNO 207 #define MATH_ERRNO 1 208 #undef MATH_ERREXCEPT 209 #define MATH_ERREXCEPT 2 210 #undef math_errhandling 211 #define math_errhandling MATH_ERREXCEPT 212 213 extern double acosh(double); 214 extern double asinh(double); 215 extern double atanh(double); 216 217 extern double exp2(double); 218 extern double expm1(double); 219 extern int ilogb(double); 220 extern double log1p(double); 221 extern double log2(double); 222 extern double logb(double); 223 extern double scalbn(double, int); 224 extern double scalbln(double, long int); 225 226 extern double cbrt(double); 227 extern double hypot(double, double); 228 229 extern double erf(double); 230 extern double erfc(double); 231 extern double lgamma(double); 232 extern double tgamma(double); 233 234 extern double nearbyint(double); 235 extern double rint(double); 236 extern long int lrint(double); 237 extern double round(double); 238 extern long int lround(double); 239 extern double trunc(double); 240 241 extern double remainder(double, double); 242 extern double remquo(double, double, int *); 243 244 extern double copysign(double, double); 245 extern double nan(const char *); 246 extern double nextafter(double, double); 247 extern double nexttoward(double, long double); 248 249 extern double fdim(double, double); 250 extern double fmax(double, double); 251 extern double fmin(double, double); 252 253 extern double fma(double, double, double); 254 255 extern float acosf(float); 256 extern float asinf(float); 257 extern float atanf(float); 258 extern float atan2f(float, float); 259 extern float cosf(float); 260 extern float sinf(float); 261 extern float tanf(float); 262 263 extern float acoshf(float); 264 extern float asinhf(float); 265 extern float atanhf(float); 266 extern float coshf(float); 267 extern float sinhf(float); 268 extern float tanhf(float); 269 270 extern float expf(float); 271 extern float exp2f(float); 272 extern float expm1f(float); 273 extern float frexpf(float, int *); 274 extern int ilogbf(float); 275 extern float ldexpf(float, int); 276 extern float logf(float); 277 extern float log10f(float); 278 extern float log1pf(float); 279 extern float log2f(float); 280 extern float logbf(float); 281 extern float modff(float, float *); 282 extern float scalbnf(float, int); 283 extern float scalblnf(float, long int); 284 285 extern float cbrtf(float); 286 extern float fabsf(float); 287 extern float hypotf(float, float); 288 extern float powf(float, float); 289 extern float sqrtf(float); 290 291 extern float erff(float); 292 extern float erfcf(float); 293 extern float lgammaf(float); 294 extern float tgammaf(float); 295 296 extern float ceilf(float); 297 extern float floorf(float); 298 extern float nearbyintf(float); 299 extern float rintf(float); 300 extern long int lrintf(float); 301 extern float roundf(float); 302 extern long int lroundf(float); 303 extern float truncf(float); 304 305 extern float fmodf(float, float); 306 extern float remainderf(float, float); 307 extern float remquof(float, float, int *); 308 309 extern float copysignf(float, float); 310 extern float nanf(const char *); 311 extern float nextafterf(float, float); 312 extern float nexttowardf(float, long double); 313 314 extern float fdimf(float, float); 315 extern float fmaxf(float, float); 316 extern float fminf(float, float); 317 318 extern float fmaf(float, float, float); 319 320 extern long double acosl(long double); 321 extern long double asinl(long double); 322 extern long double atanl(long double); 323 extern long double atan2l(long double, long double); 324 extern long double cosl(long double); 325 extern long double sinl(long double); 326 extern long double tanl(long double); 327 328 extern long double acoshl(long double); 329 extern long double asinhl(long double); 330 extern long double atanhl(long double); 331 extern long double coshl(long double); 332 extern long double sinhl(long double); 333 extern long double tanhl(long double); 334 335 extern long double expl(long double); 336 extern long double exp2l(long double); 337 extern long double expm1l(long double); 338 extern long double frexpl(long double, int *); 339 extern int ilogbl(long double); 340 extern long double ldexpl(long double, int); 341 extern long double logl(long double); 342 extern long double log10l(long double); 343 extern long double log1pl(long double); 344 extern long double log2l(long double); 345 extern long double logbl(long double); 346 extern long double modfl(long double, long double *); 347 extern long double scalbnl(long double, int); 348 extern long double scalblnl(long double, long int); 349 350 extern long double cbrtl(long double); 351 extern long double fabsl(long double); 352 extern long double hypotl(long double, long double); 353 extern long double powl(long double, long double); 354 extern long double sqrtl(long double); 355 356 extern long double erfl(long double); 357 extern long double erfcl(long double); 358 extern long double lgammal(long double); 359 extern long double tgammal(long double); 360 361 extern long double ceill(long double); 362 extern long double floorl(long double); 363 extern long double nearbyintl(long double); 364 extern long double rintl(long double); 365 extern long int lrintl(long double); 366 extern long double roundl(long double); 367 extern long int lroundl(long double); 368 extern long double truncl(long double); 369 370 extern long double fmodl(long double, long double); 371 extern long double remainderl(long double, long double); 372 extern long double remquol(long double, long double, int *); 373 374 extern long double copysignl(long double, long double); 375 extern long double nanl(const char *); 376 extern long double nextafterl(long double, long double); 377 extern long double nexttowardl(long double, long double); 378 379 extern long double fdiml(long double, long double); 380 extern long double fmaxl(long double, long double); 381 extern long double fminl(long double, long double); 382 383 extern long double fmal(long double, long double, long double); 384 385 #if !defined(_STRICT_STDC) && !defined(_NO_LONGLONG) || \ 386 defined(_STDC_C99) || defined(__C99FEATURES__) 387 388 extern long long int llrint(double); 389 extern long long int llround(double); 390 391 extern long long int llrintf(float); 392 extern long long int llroundf(float); 393 394 extern long long int llrintl(long double); 395 extern long long int llroundl(long double); 396 #endif /* !_STRICT_STDC ... _STDC_C99 */ 397 398 #ifdef __cplusplus 399 } 400 #endif 401 402 #if __cplusplus >= 199711L 403 extern "C++" { namespace std { 404 405 using ::acosh; 406 using ::acoshf; 407 using ::acoshl; 408 using ::acosf; 409 using ::acosl; 410 using ::asinhf; 411 using ::asinhl; 412 using ::asinh; 413 using ::asinf; 414 using ::asinl; 415 using ::atan2f; 416 using ::atan2l; 417 using ::atanf; 418 using ::atanl; 419 using ::atanhf; 420 using ::atanhl; 421 using ::atanh; 422 using ::cbrt; 423 using ::cbrtf; 424 using ::cbrtl; 425 using ::ceilf; 426 using ::ceill; 427 using ::copysign; 428 using ::copysignf; 429 using ::copysignl; 430 using ::cosf; 431 using ::cosl; 432 using ::coshf; 433 using ::coshl; 434 using ::erf; 435 using ::erff; 436 using ::erfl; 437 using ::erfc; 438 using ::erfcf; 439 using ::erfcl; 440 using ::exp2; 441 using ::exp2f; 442 using ::exp2l; 443 using ::expf; 444 using ::expl; 445 using ::expm1; 446 using ::expm1f; 447 using ::expm1l; 448 using ::fabsf; 449 using ::fabsl; 450 using ::fdim; 451 using ::fdimf; 452 using ::fdiml; 453 using ::floorf; 454 using ::floorl; 455 using ::fma; 456 using ::fmaf; 457 using ::fmal; 458 using ::fmax; 459 using ::fmaxf; 460 using ::fmaxl; 461 using ::fmin; 462 using ::fminf; 463 using ::fminl; 464 using ::fmodf; 465 using ::fmodl; 466 using ::frexpf; 467 using ::frexpl; 468 using ::hypot; 469 using ::hypotf; 470 using ::hypotl; 471 using ::ilogb; 472 using ::ilogbf; 473 using ::ilogbl; 474 using ::ldexpf; 475 using ::ldexpl; 476 using ::lgamma; 477 using ::lgammaf; 478 using ::lgammal; 479 using ::log10f; 480 using ::log10l; 481 using ::log1p; 482 using ::log1pf; 483 using ::log1pl; 484 using ::log2; 485 using ::log2f; 486 using ::log2l; 487 using ::logb; 488 using ::logbf; 489 using ::logbl; 490 using ::logf; 491 using ::logl; 492 using ::lrint; 493 using ::lrintf; 494 using ::lrintl; 495 using ::lround; 496 using ::lroundf; 497 using ::lroundl; 498 using ::modff; 499 using ::modfl; 500 using ::nan; 501 using ::nanf; 502 using ::nanl; 503 using ::nearbyint; 504 using ::nearbyintf; 505 using ::nearbyintl; 506 using ::nextafter; 507 using ::nextafterf; 508 using ::nextafterl; 509 using ::nexttoward; 510 using ::nexttowardf; 511 using ::nexttowardl; 512 using ::powf; 513 using ::powl; 514 using ::remainder; 515 using ::remainderf; 516 using ::remainderl; 517 using ::remquo; 518 using ::remquof; 519 using ::remquol; 520 using ::rint; 521 using ::rintf; 522 using ::rintl; 523 using ::round; 524 using ::roundf; 525 using ::roundl; 526 using ::scalbln; 527 using ::scalblnf; 528 using ::scalblnl; 529 using ::scalbn; 530 using ::scalbnf; 531 using ::scalbnl; 532 using ::sinf; 533 using ::sinl; 534 using ::sinhf; 535 using ::sinhl; 536 using ::sqrtf; 537 using ::sqrtl; 538 using ::tanf; 539 using ::tanl; 540 using ::tanhf; 541 using ::tanhl; 542 using ::tgamma; 543 using ::tgammaf; 544 using ::tgammal; 545 using ::trunc; 546 using ::truncf; 547 using ::truncl; 548 549 #if !defined(_STRICT_STDC) && !defined(_NO_LONGLONG) || \ 550 defined(_STDC_C99) || defined(__C99FEATURES__) 551 using ::llrint; 552 using ::llrintf; 553 using ::llrintl; 554 using ::llround; 555 using ::llroundf; 556 using ::llroundl; 557 #endif 558 559 } } /* end of: namespace std; extern "C++" */ 560 #endif /* __cplusplus >= 199711L */ 561 562 #endif /* defined(__EXTENSIONS__) || defined(_STDC_C99) || ... */ 563 564 #endif /* _ISO_MATH_C99_H */ 565