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 nextafter(double, double); 255double remainder(double, double); 256double remquo(double, double, int *); 257double rint(double); 258/* #endif */ /* __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XSI_VISIBLE */ 259 260/* #if __BSD_VISIBLE || __XSI_VISIBLE */ 261double j0(double); 262double j1(double); 263double jn(int, double); 264double scalb(double, double); 265double y0(double); 266double y1(double); 267double yn(int, double); 268 269/* #if __XSI_VISIBLE <= 500 || __BSD_VISIBLE */ 270double gamma(double); 271/* #endif */ 272/* #endif */ /* __BSD_VISIBLE || __XSI_VISIBLE */ 273 274/* #if __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 */ 275double copysign(double, double) __pure2; 276double fdim(double, double); 277double fmax(double, double) __pure2; 278double fmin(double, double) __pure2; 279double nearbyint(double); 280double round(double); 281double scalbln(double, long); 282double scalbn(double, int); 283double tgamma(double); 284double trunc(double); 285/* #endif */ 286 287/* 288 * BSD math library entry points 289 */ 290/* #if __BSD_VISIBLE */ 291double drem(double, double); 292int finite(double) __pure2; 293int isnanf(float) __pure2; 294 295/* 296 * Reentrant version of gamma & lgamma; passes signgam back by reference 297 * as the second argument; user must allocate space for signgam. 298 */ 299double gamma_r(double, int *); 300double lgamma_r(double, int *); 301 302/* 303 * IEEE Test Vector 304 */ 305double significand(double); 306/* #endif */ /* __BSD_VISIBLE */ 307 308/* float versions of ANSI/POSIX functions */ 309/*#if __ISO_C_VISIBLE >= 1999 */ 310float acosf(float); 311float asinf(float); 312float atanf(float); 313float atan2f(float, float); 314float cosf(float); 315float sinf(float); 316float tanf(float); 317 318float coshf(float); 319float sinhf(float); 320float tanhf(float); 321 322float exp2f(float); 323float expf(float); 324float expm1f(float); 325float frexpf(float, int *); /* fundamentally !__pure2 */ 326int ilogbf(float) __pure2; 327float ldexpf(float, int); 328float log10f(float); 329float log1pf(float); 330float logf(float); 331float modff(float, float *); /* fundamentally !__pure2 */ 332 333float powf(float, float); 334float sqrtf(float); 335 336float ceilf(float); 337float fabsf(float) __pure2; 338float floorf(float); 339float fmodf(float, float); 340float roundf(float); 341 342float erff(float); 343float erfcf(float); 344float hypotf(float, float); 345float lgammaf(float); 346 347float acoshf(float); 348float asinhf(float); 349float atanhf(float); 350float cbrtf(float); 351float logbf(float); 352float copysignf(float, float) __pure2; 353long long llrintf(float); 354long long llroundf(float); 355long lrintf(float); 356long lroundf(float); 357float nearbyintf(float); 358float nextafterf(float, float); 359float remainderf(float, float); 360float remquof(float, float, int *); 361float rintf(float); 362float scalblnf(float, long); 363float scalbnf(float, int); 364float truncf(float); 365 366float fdimf(float, float); 367float fmaf(float, float, float); 368float fmaxf(float, float) __pure2; 369float fminf(float, float) __pure2; 370/* #endif */ 371 372/* 373 * float versions of BSD math library entry points 374 */ 375/* #if __BSD_VISIBLE */ 376float dremf(float, float); 377int finitef(float) __pure2; 378float gammaf(float); 379float j0f(float); 380float j1f(float); 381float jnf(int, float); 382float scalbf(float, float); 383float y0f(float); 384float y1f(float); 385float ynf(int, float); 386 387/* 388 * Float versions of reentrant version of gamma & lgamma; passes 389 * signgam back by reference as the second argument; user must 390 * allocate space for signgam. 391 */ 392float gammaf_r(float, int *); 393float lgammaf_r(float, int *); 394 395/* 396 * float version of IEEE Test Vector 397 */ 398float significandf(float); 399/* #endif */ /* __BSD_VISIBLE */ 400 401/* 402 * long double versions of ISO/POSIX math functions 403 */ 404/* #if __ISO_C_VISIBLE >= 1999 */ 405#if 0 406long double acoshl(long double); 407long double acosl(long double); 408long double asinhl(long double); 409long double asinl(long double); 410long double atan2l(long double, long double); 411long double atanhl(long double); 412long double atanl(long double); 413long double cbrtl(long double); 414#endif 415long double ceill(long double); 416long double copysignl(long double, long double) __pure2; 417#if 0 418long double coshl(long double); 419long double cosl(long double); 420long double erfcl(long double); 421long double erfl(long double); 422long double exp2l(long double); 423long double expl(long double); 424long double expm1l(long double); 425#endif 426long double fabsl(long double) __pure2; 427long double fdiml(long double, long double); 428long double floorl(long double); 429long double fmal(long double, long double, long double); 430long double fmaxl(long double, long double) __pure2; 431long double fminl(long double, long double) __pure2; 432#if 0 433long double fmodl(long double, long double); 434#endif 435long double frexpl(long double value, int *); /* fundamentally !__pure2 */ 436#if 0 437long double hypotl(long double, long double); 438#endif 439int ilogbl(long double) __pure2; 440long double ldexpl(long double, int); 441#if 0 442long double lgammal(long double); 443long long llrintl(long double); 444#endif 445long long llroundl(long double); 446#if 0 447long double log10l(long double); 448long double log1pl(long double); 449long double log2l(long double); 450long double logbl(long double); 451long double logl(long double); 452long lrintl(long double); 453#endif 454long lroundl(long double); 455#if 0 456long double modfl(long double, long double *); /* fundamentally !__pure2 */ 457long double nanl(const char *) __pure2; 458long double nearbyintl(long double); 459#endif 460long double nextafterl(long double, long double); 461double nexttoward(double, long double); 462float nexttowardf(float, long double); 463long double nexttowardl(long double, long double); 464#if 0 465long double powl(long double, long double); 466long double remainderl(long double, long double); 467long double remquol(long double, long double, int *); 468long double rintl(long double); 469#endif 470long double roundl(long double); 471long double scalblnl(long double, long); 472long double scalbnl(long double, int); 473#if 0 474long double sinhl(long double); 475long double sinl(long double); 476long double sqrtl(long double); 477long double tanhl(long double); 478long double tanl(long double); 479long double tgammal(long double); 480#endif 481long double truncl(long double); 482 483/* BIONIC: GLibc compatibility - required by the ARM toolchain */ 484#ifdef _GNU_SOURCE 485void sincos(double x, double *sin, double *cos); 486void sincosf(float x, float *sin, float *cos); 487void sincosl(long double x, long double *sin, long double *cos); 488#endif 489 490/* #endif */ /* __ISO_C_VISIBLE >= 1999 */ 491__END_DECLS 492 493#endif /* !_MATH_H_ */ 494