/* mconf.h * * ISO/IEC 9899:1999 -- Programming Languages C: 7.12 Mathematics * Derived from the Cephes Math Library Release 2.3 * Copyright 1984, 1987, 1989, 1995 by Stephen L. Moshier * * * DESCRIPTION: * * The file also includes a conditional assembly definition * for the type of computer arithmetic (IEEE, DEC, Motorola * IEEE, or UNKnown). * * For Digital Equipment PDP-11 and VAX computers, certain * IBM systems, and others that use numbers with a 56-bit * significand, the symbol DEC should be defined. In this * mode, most floating point constants are given as arrays * of octal integers to eliminate decimal to binary conversion * errors that might be introduced by the compiler. * * For little-endian computers, such as IBM PC, that follow the * IEEE Standard for Binary Floating Point Arithmetic (ANSI/IEEE * Std 754-1985), the symbol IBMPC should be defined. These * numbers have 53-bit significands. In this mode, constants * are provided as arrays of hexadecimal 16 bit integers. * * Big-endian IEEE format is denoted MIEEE. On some RISC * systems such as Sun SPARC, double precision constants * must be stored on 8-byte address boundaries. Since integer * arrays may be aligned differently, the MIEEE configuration * may fail on such machines. * * To accommodate other types of computer arithmetic, all * constants are also provided in a normal decimal radix * which one can hope are correctly converted to a suitable * format by the available C language compiler. To invoke * this mode, define the symbol UNK. * * An important difference among these modes is a predefined * set of machine arithmetic constants for each. The numbers * MACHEP (the machine roundoff error), MAXNUM (largest number * represented), and several other parameters are preset by * the configuration symbol. Check the file const.c to * ensure that these values are correct for your computer. * * Configurations NANS, INFINITIES, MINUSZERO, and DENORMAL * may fail on many systems. Verify that they are supposed * to work on your computer. */ #ifndef _MATH_H #define _MATH_H 1 #include #include /* Type of computer arithmetic */ /* PDP-11, Pro350, VAX: */ /* #define DEC 1 */ /* Intel IEEE, low order words come first: */ /* #define IBMPC 1 */ /* Motorola IEEE, high order words come first * (Sun 680x0 workstation): */ /* #define MIEEE 1 */ /* UNKnown arithmetic, invokes coefficients given in * normal decimal format. Beware of range boundary * problems (MACHEP, MAXLOG, etc. in const.c) and * roundoff problems in pow.c: * (Sun SPARCstation) */ #define UNK 1 /* Define if the `long double' type works. */ #define HAVE_LONG_DOUBLE 1 /* Define as the return type of signal handlers (int or void). */ #define RETSIGTYPE void /* Define if you have the ANSI C header files. */ #define STDC_HEADERS 1 /* Define if your processor stores words with the most significant byte first (like Motorola and SPARC, unlike Intel and VAX). */ /* #undef WORDS_BIGENDIAN */ /* Define if floating point words are bigendian. */ /* #undef FLOAT_WORDS_BIGENDIAN */ /* The number of bytes in a int. */ #define SIZEOF_INT 4 /* Define if you have the header file. */ #define HAVE_STRING_H 1 /* Define this `volatile' if your compiler thinks * that floating point arithmetic obeys the associative * and distributive laws. It will defeat some optimizations * (but probably not enough of them). * * #define VOLATILE volatile */ #define VOLATILE /* For 12-byte long doubles on an i386, pad a 16-bit short 0 * to the end of real constants initialized by integer arrays. * * #define XPD 0, * * Otherwise, the type is 10 bytes long and XPD should be * defined blank (e.g., Microsoft C). * * #define XPD */ #define XPD 0, /* Define to support tiny denormal numbers, else undefine. */ #define DENORMAL 1 /* Define to ask for infinity support, else undefine. */ #define INFINITIES 1 /* Define to ask for support of numbers that are Not-a-Number, else undefine. This may automatically define INFINITIES in some files. */ #define NANS 1 /* Define to distinguish between -0.0 and +0.0. */ #define MINUSZERO 1 /* Define 1 for ANSI C atan2() function and ANSI prototypes for float arguments. See atan.c and clog.c. */ #define ANSIC 1 #define ANSIPROT 1 /* Constant definitions for math error conditions */ #define DOMAIN 1 /* argument domain error */ #define SING 2 /* argument singularity */ #define OVERFLOW 3 /* overflow range error */ #define UNDERFLOW 4 /* underflow range error */ #define TLOSS 5 /* total loss of precision */ #define PLOSS 6 /* partial loss of precision */ #define EDOM 33 #define ERANGE 34 /* Complex numeral. */ #ifdef __UCLIBC_HAS_LIBM_DOUBLE__ typedef struct { double r; double i; } cmplx; #endif #ifdef __UCLIBC_HAS_LIBM_FLOAT__ typedef struct { float r; float i; } cmplxf; #endif #ifdef __UCLIBC_HAS_LIBM_LONG_DOUBLE__ /* Long double complex numeral. */ typedef struct { long double r; long double i; } cmplxl; #endif /* Variable for error reporting. See mtherr.c. */ extern int mtherr(char *name, int code); extern int merror; /* If you define UNK, then be sure to set BIGENDIAN properly. */ #include #if __BYTE_ORDER == __BIG_ENDIAN # define BIGENDIAN 1 #else /* __BYTE_ORDER == __LITTLE_ENDIAN */ # define BIGENDIAN 0 #endif #define __USE_ISOC9X /* Get general and ISO C 9X specific information. */ #include #undef INFINITY #undef DECIMAL_DIG #undef FP_ILOGB0 #undef FP_ILOGBNAN /* Get the architecture specific values describing the floating-point evaluation. The following symbols will get defined: float_t floating-point type at least as wide as `float' used to evaluate `float' expressions double_t floating-point type at least as wide as `double' used to evaluate `double' expressions FLT_EVAL_METHOD Defined to 0 if `float_t' is `float' and `double_t' is `double' 1 if `float_t' and `double_t' are `double' 2 if `float_t' and `double_t' are `long double' else `float_t' and `double_t' are unspecified INFINITY representation of the infinity value of type `float' FP_FAST_FMA FP_FAST_FMAF FP_FAST_FMAL If defined it indicates that the `fma' function generally executes about as fast as a multiply and an add. This macro is defined only iff the `fma' function is implemented directly with a hardware multiply-add instructions. FP_ILOGB0 Expands to a value returned by `ilogb (0.0)'. FP_ILOGBNAN Expands to a value returned by `ilogb (NAN)'. DECIMAL_DIG Number of decimal digits supported by conversion between decimal and all internal floating-point formats. */ /* All floating-point numbers can be put in one of these categories. */ enum { FP_NAN, # define FP_NAN FP_NAN FP_INFINITE, # define FP_INFINITE FP_INFINITE FP_ZERO, # define FP_ZERO FP_ZERO FP_SUBNORMAL, # define FP_SUBNORMAL FP_SUBNORMAL FP_NORMAL # define FP_NORMAL FP_NORMAL }; /* Return number of classification appropriate for X. */ #ifdef __UCLIBC_HAS_LIBM_DOUBLE__ # define fpclassify(x) \ (sizeof (x) == sizeof (float) ? \ __fpclassifyf (x) \ : sizeof (x) == sizeof (double) ? \ __fpclassify (x) : __fpclassifyl (x)) #else # define fpclassify(x) \ (sizeof (x) == sizeof (float) ? __fpclassifyf (x) : __fpclassify (x)) #endif #ifdef __UCLIBC_HAS_LIBM_DOUBLE__ /* Return nonzero value if sign of X is negative. */ extern int signbit(double x); /* Return nonzero value if X is not +-Inf or NaN. */ extern int isfinite(double x); /* Return nonzero value if X is neither zero, subnormal, Inf, nor NaN. */ # define isnormal(x) (fpclassify (x) == FP_NORMAL) /* Return nonzero value if X is a NaN */ extern int isnan(double x); #define isinf(x) \ (sizeof (x) == sizeof (float) ? \ __isinff (x) \ : sizeof (x) == sizeof (double) ? \ __isinf (x) : __isinfl (x)) #else # define isinf(x) \ (sizeof (x) == sizeof (float) ? __isinff (x) : __isinf (x)) #endif #ifdef __UCLIBC_HAS_LIBM_LONG_DOUBLE__ /* Return nonzero value if sign of X is negative. */ extern int signbitl(long double x); /* Return nonzero value if X is not +-Inf or NaN. */ extern int isfinitel(long double x); /* Return nonzero value if X is a NaN */ extern int isnanl(long double x); #endif /* Some useful constants. */ #if defined __USE_BSD || defined __USE_XOPEN # define M_E 2.7182818284590452354 /* e */ # define M_LOG2E 1.4426950408889634074 /* log_2 e */ # define M_LOG10E 0.43429448190325182765 /* log_10 e */ # define M_LN2 0.69314718055994530942 /* log_e 2 */ # define M_LN10 2.30258509299404568402 /* log_e 10 */ # define M_PI 3.14159265358979323846 /* pi */ # define M_PI_2 1.57079632679489661923 /* pi/2 */ # define M_PI_4 0.78539816339744830962 /* pi/4 */ # define M_1_PI 0.31830988618379067154 /* 1/pi */ # define M_2_PI 0.63661977236758134308 /* 2/pi */ # define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */ # define M_SQRT2 1.41421356237309504880 /* sqrt(2) */ # define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */ #endif #ifdef __USE_GNU # define M_El M_E # define M_LOG2El M_LOG2E # define M_LOG10El M_LOG10E # define M_LN2l M_LN2 # define M_LN10l M_LN10 # define M_PIl M_PI # define M_PI_2l M_PI_2 # define M_PI_4l M_PI_4 # define M_1_PIl M_1_PI # define M_2_PIl M_2_PI # define M_2_SQRTPIl M_2_SQRTPI # define M_SQRT2l M_SQRT2 # define M_SQRT1_2l M_SQRT1_2 #endif #ifdef __UCLIBC_HAS_LIBM_DOUBLE__ /* 7.12.4 Trigonometric functions */ extern double acos(double x); extern double asin(double x); extern double atan(double x); extern double atan2(double y, double x); extern double cos(double x); extern double sin(double x); extern double tan(double x); /* 7.12.5 Hyperbolic functions */ extern double acosh(double x); extern double asinh(double x); extern double atanh(double x); extern double cosh(double x); extern double sinh(double x); extern double tanh(double x); /* 7.12.6 Exponential and logarithmic functions */ extern double exp(double x); extern double exp2(double x); extern double expm1(double x); extern double frexp(double value, int *exp); extern int ilogb(double x); extern double ldexp(double x, int exp); extern double log(double x); extern double log10(double x); extern double log1p(double x); extern double log2(double x); extern double logb(double x); extern double modf(double value, double *iptr); extern double scalbn(double x, int n); extern double scalbln(double x, long int n); /* 7.12.7 Power and absolute-value functions */ extern double fabs(double x); extern double hypot(double x, double y); extern double pow(double x, double y); extern double sqrt(double x); /* 7.12.8 Error and gamma functions */ extern double erf(double x); extern double erfc(double x); extern double lgamma(double x); extern double tgamma(double x); /* 7.12.9 Nearest integer functions */ extern double ceil(double x); extern double floor(double x); extern double nearbyint(double x); extern double rint(double x); extern long int lrint(double x); extern long long int llrint(double x); extern double round(double x); extern long int lround(double x); extern long long int llround(double x); extern double trunc(double x); /* 7.12.10 Remainder functions */ extern double fmod(double x, double y); extern double remainder(double x, double y); extern double remquo(double x, double y, int *quo); /* 7.12.11 Manipulation functions */ extern double copysign(double x, double y); extern double nan(const char *tagp); extern double nextafter(double x, double y); /* 7.12.12 Maximum, minimum, and positive difference functions */ extern double fdim(double x, double y); extern double fmax(double x, double y); extern double fmin(double x, double y); /* 7.12.13 Floating multiply-add */ extern double fma(double x, double y, double z); #endif #ifdef __UCLIBC_HAS_LIBM_FLOAT__ /* 7.12.4 Trigonometric functions */ extern float acosf(float x); extern float asinf(float x); extern float atanf(float x); extern float atan2f(float y, float x); extern float cosf(float x); extern float sinf(float x); extern float tanf(float x); /* 7.12.5 Hyperbolic functions */ extern float acoshf(float x); extern float asinhf(float x); extern float atanhf(float x); extern float coshf(float x); extern float sinhf(float x); extern float tanhf(float x); /* 7.12.6 Exponential and logarithmic functions */ extern float expf(float x); extern float exp2f(float x); extern float expm1f(float x); extern float frexpf(float value, int *exp); extern int ilogbf(float x); extern float ldexpf(float x, int exp); extern float logf(float x); extern float log10f(float x); extern float log1pf(float x); extern float log2f(float x); extern float logbf(float x); extern float modff(float value, float *iptr); extern float scalbnf(float x, int n); extern float scalblnf(float x, long int n); /* 7.12.7 Power and absolute-value functions */ extern float fabsf(float x); extern float hypotf(float x, float y); extern float powf(float x, float y); extern float sqrtf(float x); /* 7.12.8 Error and gamma functions */ extern float erff(float x); extern float erfcf(float x); extern float lgammaf(float x); extern float tgammaf(float x); /* 7.12.9 Nearest integer functions */ extern float ceilf(float x); extern float floorf(float x); extern float nearbyintf(float x); extern float rintf(float x); extern long int lrintf(float x); extern long long int llrintf(float x); extern float roundf(float x); extern long int lroundf(float x); extern long long int llroundf(float x); extern float truncf(float x); /* 7.12.10 Remainder functions */ extern float fmodf(float x, float y); extern float remainderf(float x, float y); extern float remquof(float x, float y, int *quo); /* 7.12.11 Manipulation functions */ extern float copysignf(float x, float y); extern float nanf(const char *tagp); extern float nextafterf(float x, float y); /* 7.12.12 Maximum, minimum, and positive difference functions */ extern float fdimf(float x, float y); extern float fmaxf(float x, float y); extern float fminf(float x, float y); /* 7.12.13 Floating multiply-add */ extern float fmaf(float x, float y, float z); #endif #ifdef __UCLIBC_HAS_LIBM_LONG_DOUBLE__ /* 7.12.4 Trigonometric functions */ extern long double acosl(long double x); extern long double asinl(long double x); extern long double atanl(long double x); extern long double atan2l(long double y, long double x); extern long double cosl(long double x); extern long double sinl(long double x); extern long double tanl(long double x); /* 7.12.5 Hyperbolic functions */ extern long double acoshl(long double x); extern long double asinhl(long double x); extern long double atanhl(long double x); extern long double coshl(long double x); extern long double sinhl(long double x); extern long double tanhl(long double x); /* 7.12.6 Exponential and logarithmic functions */ extern long double expl(long double x); extern long double exp2l(long double x); extern long double expm1l(long double x); extern long double frexpl(long double value, int *exp); extern int ilogbl(long double x); extern long double ldexpl(long double x, int exp); extern long double logl(long double x); extern long double log10l(long double x); extern long double log1pl(long double x); extern long double log2l(long double x); extern long double logbl(long double x); extern long double modfl(long double value, long double *iptr); extern long double scalbnl(long double x, int n); extern long double scalblnl(long double x, long int n); /* 7.12.7 Power and absolute-value functions */ extern long double fabsl(long double x); extern long double hypotl(long double x, long double y); extern long double powl(long double x, long double y); extern long double sqrtl(long double x); /* 7.12.8 Error and gamma functions */ extern long double erfl(long double x); extern long double erfcl(long double x); extern long double lgammal(long double x); extern long double tgammal(long double x); /* 7.12.9 Nearest integer functions */ extern long double ceill(long double x); extern long double floorl(long double x); extern long double nearbyintl(long double x); extern long double rintl(long double x); extern long int lrintl(long double x); extern long long int llrintl(long double x); extern long double roundl(long double x); extern long int lroundl(long double x); extern long long int llroundl(long double x); extern long double truncl(long double x); /* 7.12.10 Remainder functions */ extern long double fmodl(long double x, long double y); extern long double remainderl(long double x, long double y); extern long double remquol(long double x, long double y, int *quo); /* 7.12.11 Manipulation functions */ extern long double copysignl(long double x, long double y); extern long double nanl(const char *tagp); extern long double nextafterl(long double x, long double y); extern long double nexttowardl(long double x, long double y); /* 7.12.12 Maximum, minimum, and positive difference functions */ extern long double fdiml(long double x, long double y); extern long double fmaxl(long double x, long double y); extern long double fminl(long double x, long double y); /* 7.12.13 Floating multiply-add */ extern long double fmal(long double x, long double y, long double z); #endif /* 7.12.14 Comparison macros */ # ifndef isgreater # define isgreater(x, y) \ (__extension__ \ ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \ !isunordered (__x, __y) && __x > __y; })) # endif /* Return nonzero value if X is greater than or equal to Y. */ # ifndef isgreaterequal # define isgreaterequal(x, y) \ (__extension__ \ ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \ !isunordered (__x, __y) && __x >= __y; })) # endif /* Return nonzero value if X is less than Y. */ # ifndef isless # define isless(x, y) \ (__extension__ \ ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \ !isunordered (__x, __y) && __x < __y; })) # endif /* Return nonzero value if X is less than or equal to Y. */ # ifndef islessequal # define islessequal(x, y) \ (__extension__ \ ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \ !isunordered (__x, __y) && __x <= __y; })) # endif /* Return nonzero value if either X is less than Y or Y is less than X. */ # ifndef islessgreater # define islessgreater(x, y) \ (__extension__ \ ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \ !isunordered (__x, __y) && (__x < __y || __y < __x); })) # endif /* Return nonzero value if arguments are unordered. */ # ifndef isunordered # define isunordered(u, v) \ (__extension__ \ ({ __typeof__(u) __u = (u); __typeof__(v) __v = (v); \ fpclassify (__u) == FP_NAN || fpclassify (__v) == FP_NAN; })) # endif #endif /* math.h */