math.h revision 1.57
1/* $NetBSD: math.h,v 1.57 2012/02/05 17:57:17 matt Exp $ */ 2 3/* 4 * ==================================================== 5 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. 6 * 7 * Developed at SunPro, a Sun Microsystems, Inc. business. 8 * Permission to use, copy, modify, and distribute this 9 * software is freely granted, provided that this notice 10 * is preserved. 11 * ==================================================== 12 */ 13 14/* 15 * @(#)fdlibm.h 5.1 93/09/24 16 */ 17 18#ifndef _MATH_H_ 19#define _MATH_H_ 20 21#include <sys/cdefs.h> 22#include <sys/featuretest.h> 23 24union __float_u { 25 unsigned char __dummy[sizeof(float)]; 26 float __val; 27}; 28 29union __double_u { 30 unsigned char __dummy[sizeof(double)]; 31 double __val; 32}; 33 34union __long_double_u { 35 unsigned char __dummy[sizeof(long double)]; 36 long double __val; 37}; 38 39#include <machine/math.h> /* may use __float_u, __double_u, 40 or __long_double_u */ 41 42#ifdef __HAVE_LONG_DOUBLE 43#define __fpmacro_unary_floating(__name, __arg0) \ 44 /* LINTED */ \ 45 ((sizeof (__arg0) == sizeof (float)) \ 46 ? __ ## __name ## f (__arg0) \ 47 : (sizeof (__arg0) == sizeof (double)) \ 48 ? __ ## __name ## d (__arg0) \ 49 : __ ## __name ## l (__arg0)) 50#else 51#define __fpmacro_unary_floating(__name, __arg0) \ 52 /* LINTED */ \ 53 ((sizeof (__arg0) == sizeof (float)) \ 54 ? __ ## __name ## f (__arg0) \ 55 : __ ## __name ## d (__arg0)) 56#endif /* __HAVE_LONG_DOUBLE */ 57 58/* 59 * ANSI/POSIX 60 */ 61/* 7.12#3 HUGE_VAL, HUGELF, HUGE_VALL */ 62#if __GNUC_PREREQ__(3, 3) 63#define HUGE_VAL __builtin_huge_val() 64#else 65extern const union __double_u __infinity; 66#define HUGE_VAL __infinity.__val 67#endif 68 69/* 70 * ISO C99 71 */ 72#if !defined(_ANSI_SOURCE) && !defined(_POSIX_C_SOURCE) && \ 73 !defined(_XOPEN_SOURCE) || \ 74 ((__STDC_VERSION__ - 0) >= 199901L) || \ 75 ((_POSIX_C_SOURCE - 0) >= 200112L) || \ 76 ((_XOPEN_SOURCE - 0) >= 600) || \ 77 defined(_ISOC99_SOURCE) || defined(_NETBSD_SOURCE) 78/* 7.12#3 HUGE_VAL, HUGELF, HUGE_VALL */ 79#if __GNUC_PREREQ__(3, 3) 80#define HUGE_VALF __builtin_huge_valf() 81#define HUGE_VALL __builtin_huge_vall() 82#else 83extern const union __float_u __infinityf; 84#define HUGE_VALF __infinityf.__val 85 86extern const union __long_double_u __infinityl; 87#define HUGE_VALL __infinityl.__val 88#endif 89 90/* 7.12#4 INFINITY */ 91#if defined(__INFINITY) 92#define INFINITY __INFINITY /* float constant which overflows */ 93#elif __GNUC_PREREQ__(3, 3) 94#define INFINITY __builtin_inff() 95#else 96#define INFINITY HUGE_VALF /* positive infinity */ 97#endif /* __INFINITY */ 98 99/* 7.12#5 NAN: a quiet NaN, if supported */ 100#ifdef __HAVE_NANF 101#if __GNUC_PREREQ__(3,3) 102#define NAN __builtin_nanf("") 103#else 104extern const union __float_u __nanf; 105#define NAN __nanf.__val 106#endif 107#endif /* __HAVE_NANF */ 108 109/* 7.12#6 number classification macros */ 110#define FP_INFINITE 0x00 111#define FP_NAN 0x01 112#define FP_NORMAL 0x02 113#define FP_SUBNORMAL 0x03 114#define FP_ZERO 0x04 115/* NetBSD extensions */ 116#define _FP_LOMD 0x80 /* range for machine-specific classes */ 117#define _FP_HIMD 0xff 118 119#endif /* !_ANSI_SOURCE && ... */ 120 121/* 122 * XOPEN/SVID 123 */ 124#if defined(_XOPEN_SOURCE) || defined(_NETBSD_SOURCE) 125#define M_E 2.7182818284590452354 /* e */ 126#define M_LOG2E 1.4426950408889634074 /* log 2e */ 127#define M_LOG10E 0.43429448190325182765 /* log 10e */ 128#define M_LN2 0.69314718055994530942 /* log e2 */ 129#define M_LN10 2.30258509299404568402 /* log e10 */ 130#define M_PI 3.14159265358979323846 /* pi */ 131#define M_PI_2 1.57079632679489661923 /* pi/2 */ 132#define M_PI_4 0.78539816339744830962 /* pi/4 */ 133#define M_1_PI 0.31830988618379067154 /* 1/pi */ 134#define M_2_PI 0.63661977236758134308 /* 2/pi */ 135#define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */ 136#define M_SQRT2 1.41421356237309504880 /* sqrt(2) */ 137#define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */ 138 139#define MAXFLOAT ((float)3.40282346638528860e+38) 140extern int signgam; 141#endif /* _XOPEN_SOURCE || _NETBSD_SOURCE */ 142 143#if defined(_NETBSD_SOURCE) 144enum fdversion {fdlibm_ieee = -1, fdlibm_svid, fdlibm_xopen, fdlibm_posix}; 145 146#define _LIB_VERSION_TYPE enum fdversion 147#define _LIB_VERSION _fdlib_version 148 149/* if global variable _LIB_VERSION is not desirable, one may 150 * change the following to be a constant by: 151 * #define _LIB_VERSION_TYPE const enum version 152 * In that case, after one initializes the value _LIB_VERSION (see 153 * s_lib_version.c) during compile time, it cannot be modified 154 * in the middle of a program 155 */ 156extern _LIB_VERSION_TYPE _LIB_VERSION; 157 158#define _IEEE_ fdlibm_ieee 159#define _SVID_ fdlibm_svid 160#define _XOPEN_ fdlibm_xopen 161#define _POSIX_ fdlibm_posix 162 163#ifndef __cplusplus 164struct exception { 165 int type; 166 const char *name; 167 double arg1; 168 double arg2; 169 double retval; 170}; 171#endif 172 173#define HUGE MAXFLOAT 174 175/* 176 * set X_TLOSS = pi*2**52, which is possibly defined in <values.h> 177 * (one may replace the following line by "#include <values.h>") 178 */ 179 180#define X_TLOSS 1.41484755040568800000e+16 181 182#define DOMAIN 1 183#define SING 2 184#define OVERFLOW 3 185#define UNDERFLOW 4 186#define TLOSS 5 187#define PLOSS 6 188 189#endif /* _NETBSD_SOURCE */ 190 191__BEGIN_DECLS 192/* 193 * ANSI/POSIX 194 */ 195double acos(double); 196double asin(double); 197double atan(double); 198double atan2(double, double); 199double cos(double); 200double sin(double); 201double tan(double); 202 203double cosh(double); 204double sinh(double); 205double tanh(double); 206 207double exp(double); 208double exp2(double); 209double frexp(double, int *); 210double ldexp(double, int); 211double log(double); 212double log2(double); 213double log10(double); 214double modf(double, double *); 215 216double pow(double, double); 217double sqrt(double); 218 219double ceil(double); 220double fabs(double); 221double floor(double); 222double fmod(double, double); 223 224#if defined(_XOPEN_SOURCE) || defined(_NETBSD_SOURCE) 225double erf(double); 226double erfc(double); 227double gamma(double); 228double hypot(double, double); 229int finite(double); 230double j0(double); 231double j1(double); 232double jn(int, double); 233double lgamma(double); 234double y0(double); 235double y1(double); 236double yn(int, double); 237 238#if (_XOPEN_SOURCE - 0) >= 500 || defined(_NETBSD_SOURCE) 239double acosh(double); 240double asinh(double); 241double atanh(double); 242double cbrt(double); 243double expm1(double); 244int ilogb(double); 245double log1p(double); 246double logb(double); 247double nextafter(double, double); 248double remainder(double, double); 249double rint(double); 250double scalb(double, double); 251#endif /* (_XOPEN_SOURCE - 0) >= 500 || defined(_NETBSD_SOURCE)*/ 252#endif /* _XOPEN_SOURCE || _NETBSD_SOURCE */ 253 254/* 255 * ISO C99 256 */ 257#if !defined(_ANSI_SOURCE) && !defined(_POSIX_C_SOURCE) && \ 258 !defined(_XOPEN_SOURCE) || \ 259 ((__STDC_VERSION__ - 0) >= 199901L) || \ 260 ((_POSIX_C_SOURCE - 0) >= 200112L) || \ 261 ((_XOPEN_SOURCE - 0) >= 600) || \ 262 defined(_ISOC99_SOURCE) || defined(_NETBSD_SOURCE) 263/* 7.12.3.1 int fpclassify(real-floating x) */ 264#define fpclassify(__x) __fpmacro_unary_floating(fpclassify, __x) 265 266/* 7.12.3.2 int isfinite(real-floating x) */ 267#define isfinite(__x) __fpmacro_unary_floating(isfinite, __x) 268 269/* 7.12.3.5 int isnormal(real-floating x) */ 270#define isnormal(__x) (fpclassify(__x) == FP_NORMAL) 271 272/* 7.12.3.6 int signbit(real-floating x) */ 273#define signbit(__x) __fpmacro_unary_floating(signbit, __x) 274 275/* 7.12.4 trigonometric */ 276 277float acosf(float); 278float asinf(float); 279float atanf(float); 280float atan2f(float, float); 281float cosf(float); 282float sinf(float); 283float tanf(float); 284 285/* 7.12.5 hyperbolic */ 286 287float acoshf(float); 288float asinhf(float); 289float atanhf(float); 290float coshf(float); 291float sinhf(float); 292float tanhf(float); 293 294/* 7.12.6 exp / log */ 295 296float expf(float); 297float exp2f(float); 298float expm1f(float); 299float frexpf(float, int *); 300int ilogbf(float); 301float ldexpf(float, int); 302float logf(float); 303float log2f(float); 304float log10f(float); 305float log1pf(float); 306float logbf(float); 307float modff(float, float *); 308float scalbnf(float, int); 309 310/* 7.12.7 power / absolute */ 311 312float cbrtf(float); 313float fabsf(float); 314long double fabsl(long double); 315float hypotf(float, float); 316float powf(float, float); 317float sqrtf(float); 318 319/* 7.12.8 error / gamma */ 320 321float erff(float); 322float erfcf(float); 323float lgammaf(float); 324 325/* 7.12.9 nearest integer */ 326 327float ceilf(float); 328float floorf(float); 329float rintf(float); 330double round(double); 331float roundf(float); 332double trunc(double); 333float truncf(float); 334long int lrint(double); 335long int lrintf(float); 336/* LONGLONG */ 337long long int llrint(double); 338/* LONGLONG */ 339long long int llrintf(float); 340long int lround(double); 341long int lroundf(float); 342/* LONGLONG */ 343long long int llround(double); 344/* LONGLONG */ 345long long int llroundf(float); 346 347/* 7.12.10 remainder */ 348 349float fmodf(float, float); 350float remainderf(float, float); 351 352/* 7.12.10.3 The remquo functions */ 353double remquo(double, double, int *); 354float remquof(float, float, int *); 355 356/* 7.12.11 manipulation */ 357 358float copysignf(float, float); 359long double copysignl(long double, long double); 360double nan(const char *); 361float nanf(const char *); 362long double nanl(const char *); 363float nextafterf(float, float); 364long double nextafterl(long double, long double); 365double nexttoward(double, long double); 366 367/* 7.12.14 comparison */ 368 369#define isunordered(x, y) (isnan(x) || isnan(y)) 370#define isgreater(x, y) (!isunordered((x), (y)) && (x) > (y)) 371#define isgreaterequal(x, y) (!isunordered((x), (y)) && (x) >= (y)) 372#define isless(x, y) (!isunordered((x), (y)) && (x) < (y)) 373#define islessequal(x, y) (!isunordered((x), (y)) && (x) <= (y)) 374#define islessgreater(x, y) (!isunordered((x), (y)) && \ 375 ((x) > (y) || (y) > (x))) 376double fdim(double, double); 377double fmax(double, double); 378double fmin(double, double); 379float fdimf(float, float); 380float fmaxf(float, float); 381float fminf(float, float); 382long double fdiml(long double, long double); 383long double fmaxl(long double, long double); 384long double fminl(long double, long double); 385 386#endif /* !_ANSI_SOURCE && ... */ 387 388#if !defined(_ANSI_SOURCE) && !defined(_POSIX_C_SOURCE) || \ 389 !defined(_XOPEN_SOURCE) || \ 390 ((__STDC_VERSION__ - 0) >= 199901L) || \ 391 ((_POSIX_C_SOURCE - 0) >= 200112L) || \ 392 defined(_ISOC99_SOURCE) || defined(_NETBSD_SOURCE) 393/* 7.12.3.3 int isinf(real-floating x) */ 394#ifdef __isinf 395#define isinf(__x) __isinf(__x) 396#else 397#define isinf(__x) __fpmacro_unary_floating(isinf, __x) 398#endif 399 400/* 7.12.3.4 int isnan(real-floating x) */ 401#ifdef __isnan 402#define isnan(__x) __isnan(__x) 403#else 404#define isnan(__x) __fpmacro_unary_floating(isnan, __x) 405#endif 406#endif /* !_ANSI_SOURCE && ... */ 407 408#if defined(_NETBSD_SOURCE) 409#ifndef __cplusplus 410int matherr(struct exception *); 411#endif 412 413/* 414 * IEEE Test Vector 415 */ 416double significand(double); 417 418/* 419 * Functions callable from C, intended to support IEEE arithmetic. 420 */ 421double copysign(double, double); 422double scalbn(double, int); 423 424/* 425 * BSD math library entry points 426 */ 427double drem(double, double); 428 429#endif /* _NETBSD_SOURCE */ 430 431#if defined(_NETBSD_SOURCE) || defined(_REENTRANT) 432/* 433 * Reentrant version of gamma & lgamma; passes signgam back by reference 434 * as the second argument; user must allocate space for signgam. 435 */ 436double gamma_r(double, int *); 437double lgamma_r(double, int *); 438#endif /* _NETBSD_SOURCE || _REENTRANT */ 439 440 441#if defined(_NETBSD_SOURCE) 442 443/* float versions of ANSI/POSIX functions */ 444 445float gammaf(float); 446int isinff(float); 447int isnanf(float); 448int finitef(float); 449float j0f(float); 450float j1f(float); 451float jnf(int, float); 452float y0f(float); 453float y1f(float); 454float ynf(int, float); 455 456float scalbf(float, float); 457 458/* 459 * float version of IEEE Test Vector 460 */ 461float significandf(float); 462 463/* 464 * float versions of BSD math library entry points 465 */ 466float dremf(float, float); 467#endif /* _NETBSD_SOURCE */ 468 469#if defined(_NETBSD_SOURCE) || defined(_REENTRANT) 470/* 471 * Float versions of reentrant version of gamma & lgamma; passes 472 * signgam back by reference as the second argument; user must 473 * allocate space for signgam. 474 */ 475float gammaf_r(float, int *); 476float lgammaf_r(float, int *); 477#endif /* !... || _REENTRANT */ 478 479/* 480 * Library implementation 481 */ 482int __fpclassifyf(float); 483int __fpclassifyd(double); 484int __isfinitef(float); 485int __isfinited(double); 486int __isinff(float); 487int __isinfd(double); 488int __isnanf(float); 489int __isnand(double); 490int __signbitf(float); 491int __signbitd(double); 492 493#ifdef __HAVE_LONG_DOUBLE 494int __fpclassifyl(long double); 495int __isfinitel(long double); 496int __isinfl(long double); 497int __isnanl(long double); 498int __signbitl(long double); 499#endif 500 501int ilogbl(long double); 502long double logbl(long double); 503long double scalbnl(long double, int); 504 505__END_DECLS 506 507#endif /* _MATH_H_ */ 508