1/* 2 * ==================================================== 3 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. 4 * 5 * Developed at SunPro, a Sun Microsystems, Inc. business. 6 * Permission to use, copy, modify, and distribute this 7 * software is freely granted, provided that this notice 8 * is preserved. 9 * ==================================================== 10 */ 11 12/* 13 * from: @(#)fdlibm.h 5.1 93/09/24 14 * $FreeBSD: src/lib/msun/src/math.h,v 1.61 2005/04/16 21:12:47 das Exp $ 15 */ 16 17#ifndef _MATH_H_ 18#define _MATH_H_ 19 20#include <sys/cdefs.h> 21#include <sys/types.h> 22#include <limits.h> 23 24#define __pure2 25 26/* 27 * ANSI/POSIX 28 */ 29extern const union __infinity_un { 30 unsigned char __uc[8]; 31 double __ud; 32} __infinity; 33 34extern const union __nan_un { 35 unsigned char __uc[sizeof(float)]; 36 float __uf; 37} __nan; 38 39/* #if __GNUC_PREREQ__(3, 3) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 800) */ 40#if 1 41#define __MATH_BUILTIN_CONSTANTS 42#endif 43 44/* #if __GNUC_PREREQ__(3, 0) && !defined(__INTEL_COMPILER) */ 45#if 1 46#define __MATH_BUILTIN_RELOPS 47#endif 48 49/* #ifdef __MATH_BUILTIN_CONSTANTS */ 50#if 1 51#define HUGE_VAL __builtin_huge_val() 52#else 53#define HUGE_VAL (__infinity.__ud) 54#endif 55 56/* #if __ISO_C_VISIBLE >= 1999 */ 57#if 0 58#define FP_ILOGB0 (-__INT_MAX) 59#define FP_ILOGBNAN __INT_MAX 60#else 61#define FP_ILOGB0 (-INT_MAX) 62#define FP_ILOGBNAN INT_MAX 63#endif 64 65#ifdef __MATH_BUILTIN_CONSTANTS 66#define HUGE_VALF __builtin_huge_valf() 67#define HUGE_VALL __builtin_huge_vall() 68#define INFINITY __builtin_inf() 69#define NAN __builtin_nan("") 70#else 71#define HUGE_VALF (float)HUGE_VAL 72#define HUGE_VALL (long double)HUGE_VAL 73#define INFINITY HUGE_VALF 74#define NAN (__nan.__uf) 75#endif /* __MATH_BUILTIN_CONSTANTS */ 76 77#define MATH_ERRNO 1 78#define MATH_ERREXCEPT 2 79#define math_errhandling MATH_ERREXCEPT 80 81/* XXX We need a <machine/math.h>. */ 82#if defined(__ia64__) || defined(__sparc64__) 83#define FP_FAST_FMA 84#endif 85#ifdef __ia64__ 86#define FP_FAST_FMAL 87#endif 88#define FP_FAST_FMAF 89 90/* Symbolic constants to classify floating point numbers. */ 91#define FP_INFINITE 0x01 92#define FP_NAN 0x02 93#define FP_NORMAL 0x04 94#define FP_SUBNORMAL 0x08 95#define FP_ZERO 0x10 96#define fpclassify(x) \ 97 ((sizeof (x) == sizeof (float)) ? __fpclassifyf(x) \ 98 : (sizeof (x) == sizeof (double)) ? __fpclassifyd(x) \ 99 : __fpclassifyl(x)) 100 101#define isfinite(x) \ 102 ((sizeof (x) == sizeof (float)) ? __isfinitef(x) \ 103 : (sizeof (x) == sizeof (double)) ? __isfinite(x) \ 104 : __isfinitel(x)) 105#define isinf(x) \ 106 ((sizeof (x) == sizeof (float)) ? __isinff(x) \ 107 : (sizeof (x) == sizeof (double)) ? __isinf(x) \ 108 : __isinfl(x)) 109#define isnan(x) \ 110 ((sizeof (x) == sizeof (float)) ? isnanf(x) \ 111 : (sizeof (x) == sizeof (double)) ? isnan(x) \ 112 : __isnanl(x)) 113#define isnormal(x) \ 114 ((sizeof (x) == sizeof (float)) ? __isnormalf(x) \ 115 : (sizeof (x) == sizeof (double)) ? __isnormal(x) \ 116 : __isnormall(x)) 117 118#ifdef __MATH_BUILTIN_RELOPS 119#define isgreater(x, y) __builtin_isgreater((x), (y)) 120#define isgreaterequal(x, y) __builtin_isgreaterequal((x), (y)) 121#define isless(x, y) __builtin_isless((x), (y)) 122#define islessequal(x, y) __builtin_islessequal((x), (y)) 123#define islessgreater(x, y) __builtin_islessgreater((x), (y)) 124#define isunordered(x, y) __builtin_isunordered((x), (y)) 125#else 126#define isgreater(x, y) (!isunordered((x), (y)) && (x) > (y)) 127#define isgreaterequal(x, y) (!isunordered((x), (y)) && (x) >= (y)) 128#define isless(x, y) (!isunordered((x), (y)) && (x) < (y)) 129#define islessequal(x, y) (!isunordered((x), (y)) && (x) <= (y)) 130#define islessgreater(x, y) (!isunordered((x), (y)) && \ 131 ((x) > (y) || (y) > (x))) 132#define isunordered(x, y) (isnan(x) || isnan(y)) 133#endif /* __MATH_BUILTIN_RELOPS */ 134 135#define signbit(x) \ 136 ((sizeof (x) == sizeof (float)) ? __signbitf(x) \ 137 : (sizeof (x) == sizeof (double)) ? __signbit(x) \ 138 : __signbitl(x)) 139 140#if 0 141typedef __double_t double_t; 142typedef __float_t float_t; 143#endif 144/* #endif */ /* __ISO_C_VISIBLE >= 1999 */ 145 146/* 147 * XOPEN/SVID 148 */ 149/* #if __BSD_VISIBLE || __XSI_VISIBLE */ 150#define M_E 2.7182818284590452354 /* e */ 151#define M_LOG2E 1.4426950408889634074 /* log 2e */ 152#define M_LOG10E 0.43429448190325182765 /* log 10e */ 153#define M_LN2 0.69314718055994530942 /* log e2 */ 154#define M_LN10 2.30258509299404568402 /* log e10 */ 155#define M_PI 3.14159265358979323846 /* pi */ 156#define M_PI_2 1.57079632679489661923 /* pi/2 */ 157#define M_PI_4 0.78539816339744830962 /* pi/4 */ 158#define M_1_PI 0.31830988618379067154 /* 1/pi */ 159#define M_2_PI 0.63661977236758134308 /* 2/pi */ 160#define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */ 161#define M_SQRT2 1.41421356237309504880 /* sqrt(2) */ 162#define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */ 163 164#define MAXFLOAT ((float)3.40282346638528860e+38) 165extern int signgam; 166/* #endif */ /* __BSD_VISIBLE || __XSI_VISIBLE */ 167 168#if __BSD_VISIBLE 169#if 0 170/* Old value from 4.4BSD-Lite math.h; this is probably better. */ 171#define HUGE HUGE_VAL 172#else 173#define HUGE MAXFLOAT 174#endif 175#endif /* __BSD_VISIBLE */ 176 177/* 178 * Most of these functions depend on the rounding mode and have the side 179 * effect of raising floating-point exceptions, so they are not declared 180 * as __pure2. In C99, FENV_ACCESS affects the purity of these functions. 181 */ 182__BEGIN_DECLS 183/* 184 * ANSI/POSIX 185 */ 186int __fpclassifyd(double) __pure2; 187int __fpclassifyf(float) __pure2; 188int __fpclassifyl(long double) __pure2; 189int __isfinitef(float) __pure2; 190int __isfinite(double) __pure2; 191int __isfinitel(long double) __pure2; 192int __isinff(float) __pure2; 193int __isinf(double) __pure2; 194int __isinfl(long double) __pure2; 195int __isnanl(long double) __pure2; 196int __isnormalf(float) __pure2; 197int __isnormal(double) __pure2; 198int __isnormall(long double) __pure2; 199int __signbit(double) __pure2; 200int __signbitf(float) __pure2; 201int __signbitl(long double) __pure2; 202 203double acos(double); 204double asin(double); 205double atan(double); 206double atan2(double, double); 207double cos(double); 208double sin(double); 209double tan(double); 210 211double cosh(double); 212double sinh(double); 213double tanh(double); 214 215double exp(double); 216double frexp(double, int *); /* fundamentally !__pure2 */ 217double ldexp(double, int); 218double log(double); 219double log10(double); 220double modf(double, double *); /* fundamentally !__pure2 */ 221 222double pow(double, double); 223double sqrt(double); 224 225double ceil(double); 226double fabs(double) __pure2; 227double floor(double); 228double fmod(double, double); 229 230/* 231 * These functions are not in C90. 232 */ 233/* #if __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XSI_VISIBLE */ 234double acosh(double); 235double asinh(double); 236double atanh(double); 237double cbrt(double); 238double erf(double); 239double erfc(double); 240double exp2(double); 241double expm1(double); 242double fma(double, double, double); 243double hypot(double, double); 244int ilogb(double) __pure2; 245/* int (isinf)(double) __pure2; */ 246int (isnan)(double) __pure2; 247double lgamma(double); 248long long llrint(double); 249long long llround(double); 250double log1p(double); 251double logb(double); 252long lrint(double); 253long lround(double); 254double nan(const char *) __pure2; 255double nextafter(double, double); 256double remainder(double, double); 257double remquo(double, double, int *); 258double rint(double); 259/* #endif */ /* __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XSI_VISIBLE */ 260 261/* #if __BSD_VISIBLE || __XSI_VISIBLE */ 262double j0(double); 263double j1(double); 264double jn(int, double); 265double scalb(double, double); 266double y0(double); 267double y1(double); 268double yn(int, double); 269 270/* #if __XSI_VISIBLE <= 500 || __BSD_VISIBLE */ 271double gamma(double); 272/* #endif */ 273/* #endif */ /* __BSD_VISIBLE || __XSI_VISIBLE */ 274 275/* #if __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 */ 276double copysign(double, double) __pure2; 277double fdim(double, double); 278double fmax(double, double) __pure2; 279double fmin(double, double) __pure2; 280double nearbyint(double); 281double round(double); 282double scalbln(double, long); 283double scalbn(double, int); 284double tgamma(double); 285double trunc(double); 286/* #endif */ 287 288/* 289 * BSD math library entry points 290 */ 291/* #if __BSD_VISIBLE */ 292double drem(double, double); 293int finite(double) __pure2; 294int isnanf(float) __pure2; 295 296/* 297 * Reentrant version of gamma & lgamma; passes signgam back by reference 298 * as the second argument; user must allocate space for signgam. 299 */ 300double gamma_r(double, int *); 301double lgamma_r(double, int *); 302 303/* 304 * IEEE Test Vector 305 */ 306double significand(double); 307/* #endif */ /* __BSD_VISIBLE */ 308 309/* float versions of ANSI/POSIX functions */ 310/*#if __ISO_C_VISIBLE >= 1999 */ 311float acosf(float); 312float asinf(float); 313float atanf(float); 314float atan2f(float, float); 315float cosf(float); 316float sinf(float); 317float tanf(float); 318 319float coshf(float); 320float sinhf(float); 321float tanhf(float); 322 323float exp2f(float); 324float expf(float); 325float expm1f(float); 326float frexpf(float, int *); /* fundamentally !__pure2 */ 327int ilogbf(float) __pure2; 328float ldexpf(float, int); 329float log10f(float); 330float log1pf(float); 331float logf(float); 332float modff(float, float *); /* fundamentally !__pure2 */ 333 334float powf(float, float); 335float sqrtf(float); 336 337float ceilf(float); 338float fabsf(float) __pure2; 339float floorf(float); 340float fmodf(float, float); 341float roundf(float); 342 343float erff(float); 344float erfcf(float); 345float hypotf(float, float); 346float lgammaf(float); 347float tgammaf(float); 348 349float acoshf(float); 350float asinhf(float); 351float atanhf(float); 352float cbrtf(float); 353float logbf(float); 354float copysignf(float, float) __pure2; 355long long llrintf(float); 356long long llroundf(float); 357long lrintf(float); 358long lroundf(float); 359float nanf(const char *) __pure2; 360float nearbyintf(float); 361float nextafterf(float, float); 362float remainderf(float, float); 363float remquof(float, float, int *); 364float rintf(float); 365float scalblnf(float, long); 366float scalbnf(float, int); 367float truncf(float); 368 369float fdimf(float, float); 370float fmaf(float, float, float); 371float fmaxf(float, float) __pure2; 372float fminf(float, float) __pure2; 373/* #endif */ 374 375/* 376 * float versions of BSD math library entry points 377 */ 378/* #if __BSD_VISIBLE */ 379float dremf(float, float); 380int finitef(float) __pure2; 381float gammaf(float); 382float j0f(float); 383float j1f(float); 384float jnf(int, float); 385float scalbf(float, float); 386float y0f(float); 387float y1f(float); 388float ynf(int, float); 389 390/* 391 * Float versions of reentrant version of gamma & lgamma; passes 392 * signgam back by reference as the second argument; user must 393 * allocate space for signgam. 394 */ 395float gammaf_r(float, int *); 396float lgammaf_r(float, int *); 397 398/* 399 * float version of IEEE Test Vector 400 */ 401float significandf(float); 402/* #endif */ /* __BSD_VISIBLE */ 403 404/* 405 * long double versions of ISO/POSIX math functions 406 */ 407/* #if __ISO_C_VISIBLE >= 1999 */ 408#if 0 409long double acoshl(long double); 410long double acosl(long double); 411long double asinhl(long double); 412long double asinl(long double); 413long double atan2l(long double, long double); 414long double atanhl(long double); 415long double atanl(long double); 416long double cbrtl(long double); 417#endif 418long double ceill(long double); 419long double copysignl(long double, long double) __pure2; 420#if 0 421long double coshl(long double); 422long double cosl(long double); 423long double erfcl(long double); 424long double erfl(long double); 425long double exp2l(long double); 426long double expl(long double); 427long double expm1l(long double); 428#endif 429long double fabsl(long double) __pure2; 430long double fdiml(long double, long double); 431long double floorl(long double); 432long double fmal(long double, long double, long double); 433long double fmaxl(long double, long double) __pure2; 434long double fminl(long double, long double) __pure2; 435#if 0 436long double fmodl(long double, long double); 437#endif 438long double frexpl(long double value, int *); /* fundamentally !__pure2 */ 439#if 0 440long double hypotl(long double, long double); 441#endif 442int ilogbl(long double) __pure2; 443long double ldexpl(long double, int); 444#if 0 445long double lgammal(long double); 446long long llrintl(long double); 447#endif 448long long llroundl(long double); 449#if 0 450long double log10l(long double); 451long double log1pl(long double); 452long double log2l(long double); 453long double logbl(long double); 454long double logl(long double); 455long lrintl(long double); 456#endif 457long lroundl(long double); 458#if 0 459long double modfl(long double, long double *); /* fundamentally !__pure2 */ 460long double nanl(const char *) __pure2; 461long double nearbyintl(long double); 462#endif 463long double nextafterl(long double, long double); 464double nexttoward(double, long double); 465float nexttowardf(float, long double); 466long double nexttowardl(long double, long double); 467#if 0 468long double powl(long double, long double); 469long double remainderl(long double, long double); 470long double remquol(long double, long double, int *); 471long double rintl(long double); 472#endif 473long double roundl(long double); 474long double scalblnl(long double, long); 475long double scalbnl(long double, int); 476#if 0 477long double sinhl(long double); 478long double sinl(long double); 479long double sqrtl(long double); 480long double tanhl(long double); 481long double tanl(long double); 482long double tgammal(long double); 483#endif 484long double truncl(long double); 485 486/* BIONIC: GLibc compatibility - required by the ARM toolchain */ 487#ifdef _GNU_SOURCE 488void sincos(double x, double *sin, double *cos); 489void sincosf(float x, float *sin, float *cos); 490void sincosl(long double x, long double *sin, long double *cos); 491#endif 492 493/* #endif */ /* __ISO_C_VISIBLE >= 1999 */ 494__END_DECLS 495 496#endif /* !_MATH_H_ */ 497