CVS: msp430-libc4/include math_private.h,NONE,1.1 math.h,1.1.1.1,1.2
Dmitry Diky <[email protected]>
| Newsgroups | gmane.comp.hardware.texas-instruments.msp430.gcc.cvs |
|---|---|
| Message-ID | <[email protected]> |
Update of /cvsroot/mspgcc/msp430-libc4/include In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv19837/include Modified Files: math.h Added Files: math_private.h Log Message: 2005-08-31 Dmitry Diky <[email protected]> * include/math.h: Replaced with the new one from BSD * include/math_private.h: New file * src/libm/*: Completely replaced with BSD's one. --- NEW FILE: math_private.h --- /* * ==================================================== * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. * * Developed at SunPro, a Sun Microsystems, Inc. business. * Permission to use, copy, modify, and distribute this * software is freely granted, provided that this notice * is preserved. * ==================================================== */ /* * from: @(#)fdlibm.h 5.1 93/09/24 * $FreeBSD: src/lib/msun/src/math_private.h,v 1.15 2003/07/23 04:53:46 peter Exp $ */ #ifndef _MATH_PRIVATE_H_ #define _MATH_PRIVATE_H_ #include <sys/types.h> #define _LITTLE_ENDIAN 1234 /* LSB first: i386, vax */ #define _BIG_ENDIAN 4321 /* MSB first: 68000, ibm, net */ #define _PDP_ENDIAN 3412 /* LSB first in word, MSW first in long */ #define _BYTE_ORDER _LITTLE_ENDIAN /* * Deprecated variants that don't have enough underscores to be useful in more * strict namespaces. */ #define LITTLE_ENDIAN _LITTLE_ENDIAN #define BIG_ENDIAN _BIG_ENDIAN #define PDP_ENDIAN _PDP_ENDIAN #define BYTE_ORDER _BYTE_ORDER /* * The original fdlibm code used statements like: * n0 = ((*(int*)&one)>>29)^1; * index of high word * * ix0 = *(n0+(int*)&x); * high word of x * * ix1 = *((1-n0)+(int*)&x); * low word of x * * to dig two 32 bit words out of the 64 bit IEEE floating point * value. That is non-ANSI, and, moreover, the gcc instruction * scheduler gets it wrong. We instead use the following macros. * Unlike the original code, we determine the endianness at compile * time, not at run time; I don't see much benefit to selecting * endianness at run time. */ /* * A union which permits us to convert between a double and two 32 bit * ints. */ #if BYTE_ORDER == BIG_ENDIAN typedef union { double value; struct { u_int32_t msw; u_int32_t lsw; } parts; } ieee_double_shape_type; #endif #if BYTE_ORDER == LITTLE_ENDIAN typedef union { double value; struct { u_int32_t lsw; u_int32_t msw; } parts; } ieee_double_shape_type; #endif /* Get two 32 bit ints from a double. */ #define EXTRACT_WORDS(ix0,ix1,d) \ do { \ ieee_double_shape_type ew_u; \ ew_u.value = (d); \ (ix0) = ew_u.parts.msw; \ (ix1) = ew_u.parts.lsw; \ } while (0) /* Get the more significant 32 bit int from a double. */ #define GET_HIGH_WORD(i,d) \ do { \ ieee_double_shape_type gh_u; \ gh_u.value = (d); \ (i) = gh_u.parts.msw; \ } while (0) /* Get the less significant 32 bit int from a double. */ #define GET_LOW_WORD(i,d) \ do { \ ieee_double_shape_type gl_u; \ gl_u.value = (d); \ (i) = gl_u.parts.lsw; \ } while (0) /* Set a double from two 32 bit ints. */ #define INSERT_WORDS(d,ix0,ix1) \ do { \ ieee_double_shape_type iw_u; \ iw_u.parts.msw = (ix0); \ iw_u.parts.lsw = (ix1); \ (d) = iw_u.value; \ } while (0) /* Set the more significant 32 bits of a double from an int. */ #define SET_HIGH_WORD(d,v) \ do { \ ieee_double_shape_type sh_u; \ sh_u.value = (d); \ sh_u.parts.msw = (v); \ (d) = sh_u.value; \ } while (0) /* Set the less significant 32 bits of a double from an int. */ #define SET_LOW_WORD(d,v) \ do { \ ieee_double_shape_type sl_u; \ sl_u.value = (d); \ sl_u.parts.lsw = (v); \ (d) = sl_u.value; \ } while (0) /* * A union which permits us to convert between a float and a 32 bit * int. */ typedef union { float value; /* FIXME: Assumes 32 bit int. */ unsigned int word; } ieee_float_shape_type; /* Get a 32 bit int from a float. */ #define GET_FLOAT_WORD(i,d) \ do { \ ieee_float_shape_type gf_u; \ gf_u.value = (d); \ (i) = gf_u.word; \ } while (0) /* Set a float from a 32 bit int. */ #define SET_FLOAT_WORD(d,i) \ do { \ ieee_float_shape_type sf_u; \ sf_u.word = (i); \ (d) = sf_u.value; \ } while (0) /* ieee style elementary functions */ double __ieee754_sqrt(double); double __ieee754_acos(double); double __ieee754_acosh(double); double __ieee754_log(double); double __ieee754_atanh(double); double __ieee754_asin(double); double __ieee754_atan2(double,double); double __ieee754_exp(double); double __ieee754_cosh(double); double __ieee754_fmod(double,double); double __ieee754_pow(double,double); double __ieee754_lgamma_r(double,int *); double __ieee754_gamma_r(double,int *); double __ieee754_lgamma(double); double __ieee754_gamma(double); double __ieee754_log10(double); double __ieee754_sinh(double); double __ieee754_hypot(double,double); double __ieee754_j0(double); double __ieee754_j1(double); double __ieee754_y0(double); double __ieee754_y1(double); double __ieee754_jn(int,double); double __ieee754_yn(int,double); double __ieee754_remainder(double,double); int __ieee754_rem_pio2(double,double*); double __ieee754_scalb(double,double); /* fdlibm kernel function */ double __kernel_standard(double,double,int); double __kernel_sin(double,double,int); double __kernel_cos(double,double); double __kernel_tan(double,double,int); int __kernel_rem_pio2(double*,double*,int,int,int,const int*); /* ieee style elementary float functions */ float __ieee754_sqrtf(float); float __ieee754_acosf(float); float __ieee754_acoshf(float); float __ieee754_logf(float); float __ieee754_atanhf(float); float __ieee754_asinf(float); float __ieee754_atan2f(float,float); float __ieee754_expf(float); float __ieee754_coshf(float); float __ieee754_fmodf(float,float); float __ieee754_powf(float,float); float __ieee754_lgammaf_r(float,int *); float __ieee754_gammaf_r(float,int *); float __ieee754_lgammaf(float); float __ieee754_gammaf(float); float __ieee754_log10f(float); float __ieee754_sinhf(float); float __ieee754_hypotf(float,float); float __ieee754_j0f(float); float __ieee754_j1f(float); float __ieee754_y0f(float); float __ieee754_y1f(float); float __ieee754_jnf(int,float); float __ieee754_ynf(int,float); float __ieee754_remainderf(float,float); int __ieee754_rem_pio2f(float,float*); float __ieee754_scalbf(float,float); /* float versions of fdlibm kernel functions */ float __kernel_sinf(float,float,int); float __kernel_cosf(float,float); float __kernel_tanf(float,float,int); int __kernel_rem_pio2f(float*,float*,int,int,int,const int*); #endif /* !_MATH_PRIVATE_H_ */ Index: math.h =================================================================== RCS file: /cvsroot/mspgcc/msp430-libc4/include/math.h,v retrieving revision 1.1.1.1 retrieving revision 1.2 diff -u -w -d -r1.1.1.1 -r1.2 --- math.h 29 Aug 2005 16:48:45 -0000 1.1.1.1 +++ math.h 31 Aug 2005 17:59:05 -0000 1.2 @@ -1,285 +1,409 @@ -/* math.h -- Definitions for the math floating point package. */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * from: @(#)fdlibm.h 5.1 93/09/24 + * $FreeBSD: src/lib/msun/src/math.h,v 1.27 2003/10/23 08:23:38 des Exp $ + */ #ifndef _MATH_H_ -#ifdef __cplusplus -extern "C" { -#endif #define _MATH_H_ -#include <sys/reent.h> -#include <sys/ieeefp.h> -#include <sys/_ansi.h> - -#ifndef HUGE_VAL - -/* Define HUGE_VAL as infinity, unless HUGE_VAL is already defined - (which might have been done by something like math-68881.h). */ +#include <sys/_types.h> -union __dmath -{ - __uint32_t i[2]; - double d; -}; +/* + * ANSI/POSIX + */ +extern const union __infinity_un { + unsigned char __uc[8]; + double __ud; +} __infinity; -/* Declare this as an array without bounds so that no matter what small data - support a port and/or library has, this reference will be via the general - method for accessing globals. */ -extern __IMPORT const union __dmath __infinity[]; +extern const union __nan_un { + unsigned char __uc[sizeof(float)]; + float __uf; +} __nan; -#define HUGE_VAL (__infinity[0].d) +#define FP_ILOGB0 (-0x7fffffff - 1) /* INT_MIN */ +#define FP_ILOGBNAN 0x7fffffff /* INT_MAX */ +#define HUGE_VAL (__infinity.__ud) +#define HUGE_VALF (float)HUGE_VAL +#define HUGE_VALL (long double)HUGE_VAL +#define INFINITY HUGE_VALF +#define NAN (__nan.__uf) -#endif /* ! defined (HUGE_VAL) */ +/* Symbolic constants to classify floating point numbers. */ +#define FP_INFINITE 0x01 +#define FP_NAN 0x02 +#define FP_NORMAL 0x04 +#define FP_SUBNORMAL 0x08 +#define FP_ZERO 0x10 +#define fpclassify(x) \ + ((sizeof (x) == sizeof (float)) ? __fpclassifyf(x) \ + : (sizeof (x) == sizeof (double)) ? __fpclassifyd(x) \ + : __fpclassifyl(x)) -/* Reentrant ANSI C functions. */ +#define isfinite(x) ((fpclassify(x) & (FP_INFINITE|FP_NAN)) == 0) +#define isinf(x) (fpclassify(x) == FP_INFINITE) +#define isnan(x) (fpclassify(x) == FP_NAN) +#define isnanf(x) isnan(x) +#define isnormal(x) (fpclassify(x) == FP_NORMAL) -#ifndef __math_68881 -extern double atan _PARAMS((double)); -extern double cos _PARAMS((double)); -extern double sin _PARAMS((double)); -extern double tan _PARAMS((double)); -extern double tanh _PARAMS((double)); -extern double frexp _PARAMS((double, int *)); -extern double modf _PARAMS((double, double *)); -extern double ceil _PARAMS((double)); -extern double fabs _PARAMS((double)); -extern double floor _PARAMS((double)); -#endif /* ! defined (__math_68881) */ +#define isgreater(x, y) (!isunordered((x), (y)) && (x) > (y)) +#define isgreaterequal(x, y) (!isunordered((x), (y)) && (x) >= (y)) +#define isless(x, y) (!isunordered((x), (y)) && (x) < (y)) +#define islessequal(x, y) (!isunordered((x), (y)) && (x) <= (y)) +#define islessgreater(x, y) (!isunordered((x), (y)) && \ + ((x) > (y) || (y) > (x))) +#define isunordered(x, y) (isnan(x) || isnan(y)) -/* Non reentrant ANSI C functions. */ +#define signbit(x) __signbit(x) -#ifndef _REENT_ONLY -#ifndef __math_6881 -extern double acos _PARAMS((double)); -extern double asin _PARAMS((double)); -extern double atan2 _PARAMS((double, double)); -extern double cosh _PARAMS((double)); -extern double sinh _PARAMS((double)); -extern double exp _PARAMS((double)); -extern double ldexp _PARAMS((double, int)); -extern double log _PARAMS((double)); -extern double log10 _PARAMS((double)); -extern double pow _PARAMS((double, double)); -extern double sqrt _PARAMS((double)); -extern double fmod _PARAMS((double, double)); -#endif /* ! defined (__math_68881) */ -#endif /* ! defined (_REENT_ONLY) */ +typedef double double_t; +typedef float float_t; -#ifndef __STRICT_ANSI__ +/* + * XOPEN/SVID + */ +#if !defined(_ANSI_SOURCE) && !defined(_POSIX_SOURCE) +#define M_E 2.7182818284590452354 /* e */ +#define M_LOG2E 1.4426950408889634074 /* log 2e */ +#define M_LOG10E 0.43429448190325182765 /* log 10e */ +#define M_LN2 0.69314718055994530942 /* log e2 */ +#define M_LN10 2.30258509299404568402 /* log e10 */ +#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) */ -/* Non ANSI double precision functions. */ +#define MAXFLOAT ((float)3.40282346638528860e+38) +extern int signgam; -extern double infinity _PARAMS((void)); -extern double nan _PARAMS((void)); -extern int isnan _PARAMS((double)); -extern int isinf _PARAMS((double)); -extern int finite _PARAMS((double)); -extern double copysign _PARAMS((double, double)); -extern int ilogb _PARAMS((double)); +#if !defined(_XOPEN_SOURCE) +enum fdversion {fdlibm_ieee = -1, fdlibm_svid, fdlibm_xopen, fdlibm_posix}; -extern double asinh _PARAMS((double)); -extern double cbrt _PARAMS((double)); -extern double nextafter _PARAMS((double, double)); -extern double rint _PARAMS((double)); -extern double scalbn _PARAMS((double, int)); +#define _LIB_VERSION_TYPE enum fdversion +#define _LIB_VERSION _fdlib_version -#ifndef __math_68881 -extern double log1p _PARAMS((double)); -extern double expm1 _PARAMS((double)); -#endif /* ! defined (__math_68881) */ +/* if global variable _LIB_VERSION is not desirable, one may + * change the following to be a constant by: + * #define _LIB_VERSION_TYPE const enum version + * In that case, after one initializes the value _LIB_VERSION (see + * s_lib_version.c) during compile time, it cannot be modified + * in the middle of a program + */ +extern _LIB_VERSION_TYPE _LIB_VERSION; -#ifndef _REENT_ONLY -extern double acosh _PARAMS((double)); -extern double atanh _PARAMS((double)); -extern double remainder _PARAMS((double, double)); -extern double gamma _PARAMS((double)); -extern double gamma_r _PARAMS((double, int *)); -extern double lgamma _PARAMS((double)); -extern double lgamma_r _PARAMS((double, int *)); -extern double erf _PARAMS((double)); -extern double erfc _PARAMS((double)); -extern double y0 _PARAMS((double)); -extern double y1 _PARAMS((double)); -extern double yn _PARAMS((int, double)); -extern double j0 _PARAMS((double)); -extern double j1 _PARAMS((double)); -extern double jn _PARAMS((int, double)); -#define log2(x) (log (x) / M_LOG2_E) +#define _IEEE_ fdlibm_ieee +#define _SVID_ fdlibm_svid +#define _XOPEN_ fdlibm_xopen +#define _POSIX_ fdlibm_posix -#ifndef __math_68881 -extern double hypot _PARAMS((double, double)); +/* We have a problem when using C++ since `exception' is a reserved + name in C++. */ +#ifndef __cplusplus +struct exception { + int type; + char *name; + double arg1; + double arg2; + double retval; +}; #endif -extern double cabs _PARAMS((void)); -extern double drem _PARAMS((double, double)); +#if 0 +/* Old value from 4.4BSD-Lite math.h; this is probably better. */ +#define HUGE HUGE_VAL +#else +#define HUGE MAXFLOAT +#endif -#endif /* ! defined (_REENT_ONLY) */ +/* + * set X_TLOSS = pi*2**52, which is possibly defined in <values.h> + * (one may replace the following line by "#include <values.h>") + */ -#endif /* ! defined (__STRICT_ANSI__) */ +#define X_TLOSS 1.41484755040568800000e+16 -#if !defined(__STRICT_ANSI__) || defined(__cplusplus) +#define DOMAIN 1 +#define SING 2 +#define OVERFLOW 3 +#define UNDERFLOW 4 +#define TLOSS 5 +#define PLOSS 6 -/* Single precision versions of ANSI functions. */ +#endif /* !_XOPEN_SOURCE */ +#endif /* !_ANSI_SOURCE && !_POSIX_SOURCE */ -extern float atanf _PARAMS((float)); -extern float cosf _PARAMS((float)); -extern float sinf _PARAMS((float)); -extern float tanf _PARAMS((float)); -extern float tanhf _PARAMS((float)); -extern float frexpf _PARAMS((float, int *)); -extern float modff _PARAMS((float, float *)); -extern float ceilf _PARAMS((float)); -extern float fabsf _PARAMS((float)); -extern float floorf _PARAMS((float)); +#include <sys/cdefs.h> +#define __pure2 +/* + * Most of these functions have the side effect of setting errno, so they + * are not declared as __pure2. (XXX: this point needs to be revisited, + * since C99 doesn't require the mistake of setting errno, and we mostly + * don't set it anyway. In C99, pragmas and functions for changing the + * rounding mode affect the purity of these functions.) + */ +__BEGIN_DECLS +/* + * ANSI/POSIX + */ +int __fpclassifyd(double) __pure2; +int __fpclassifyf(float) __pure2; +int __fpclassifyl(long double) __pure2; +int __signbit(double) __pure2; -#ifndef _REENT_ONLY -extern float acosf _PARAMS((float)); -extern float asinf _PARAMS((float)); -extern float atan2f _PARAMS((float, float)); -extern float coshf _PARAMS((float)); -extern float sinhf _PARAMS((float)); -extern float expf _PARAMS((float)); -extern float ldexpf _PARAMS((float, int)); -extern float logf _PARAMS((float)); -extern float log10f _PARAMS((float)); -extern float powf _PARAMS((float, float)); -extern float sqrtf _PARAMS((float)); -extern float fmodf _PARAMS((float, float)); -#endif /* ! defined (_REENT_ONLY) */ +double acos(double); +double asin(double); +double atan(double); +double atan2(double, double); +double cos(double); +double sin(double); +double tan(double); -#endif /* !defined(__STRICT_ANSI__) || defined(__cplusplus) */ +double cosh(double); +double sinh(double); +double tanh(double); -#ifndef __STRICT_ANSI__ +double exp(double); +double frexp(double, int *); /* fundamentally !__pure2 */ +double ldexp(double, int); +double log(double); +double log10(double); +double modf(double, double *); /* fundamentally !__pure2 */ -/* Other single precision functions. */ +double pow(double, double); +double sqrt(double); -extern float infinityf _PARAMS((void)); -extern float nanf _PARAMS((void)); -extern int isnanf _PARAMS((float)); -extern int isinff _PARAMS((float)); -extern int finitef _PARAMS((float)); -extern float copysignf _PARAMS((float, float)); -extern int ilogbf _PARAMS((float)); +double ceil(double); +double fabs(double); +double floor(double); +double fmod(double, double); -extern float asinhf _PARAMS((float)); -extern float cbrtf _PARAMS((float)); -extern float nextafterf _PARAMS((float, float)); -extern float rintf _PARAMS((float)); -extern float scalbnf _PARAMS((float, int)); -extern float log1pf _PARAMS((float)); -extern float expm1f _PARAMS((float)); +/* + * These functions are not in C90 so they can be "right". The ones that + * never set errno in lib/msun are declared as __pure2. + */ +#if !defined(_ANSI_SOURCE) && !defined(_POSIX_SOURCE) +double erf(double); +double erfc(double) __pure2; +int finite(double) __pure2; +double gamma(double); +double hypot(double, double); +double j0(double); +double j1(double); +double jn(int, double); +double lgamma(double); +double y0(double); +double y1(double); +double yn(int, double); -#ifndef _REENT_ONLY -extern float acoshf _PARAMS((float)); -extern float atanhf _PARAMS((float)); -extern float remainderf _PARAMS((float, float)); -extern float gammaf _PARAMS((float)); -extern float gammaf_r _PARAMS((float, int *)); -extern float lgammaf _PARAMS((float)); -extern float lgammaf_r _PARAMS((float, int *)); -extern float erff _PARAMS((float)); -extern float erfcf _PARAMS((float)); -extern float y0f _PARAMS((float)); -extern float y1f _PARAMS((float)); -extern float ynf _PARAMS((int, float)); -extern float j0f _PARAMS((float)); -extern float j1f _PARAMS((float)); -extern float jnf _PARAMS((int, float)); -#define log2f(x) (logf (x) / (float) M_LOG2_E) -extern float hypotf _PARAMS((float, float)); +#if !defined(_XOPEN_SOURCE) +double acosh(double); +double asinh(double); +double atanh(double); +double cbrt(double) __pure2; +double logb(double) __pure2; +double nextafter(double, double); +double remainder(double, double); +double scalb(double, double); +double tgamma(double); -extern float cabsf _PARAMS((void)); -extern float dremf _PARAMS((float, float)); +#ifndef __cplusplus +int matherr(struct exception *); +#endif -#endif /* ! defined (_REENT_ONLY) */ +/* + * IEEE Test Vector + */ +double significand(double); -/* The gamma functions use a global variable, signgam. */ -#ifndef _REENT_ONLY -#define signgam (*__signgam()) -extern int *__signgam _PARAMS((void)); -#endif /* ! defined (_REENT_ONLY) */ +/* + * Functions callable from C, intended to support IEEE arithmetic. + */ +double copysign(double, double) __pure2; +int ilogb(double); +double rint(double) __pure2; +double scalbn(double, int); -#define __signgam_r(ptr) ((ptr)->_new._reent._gamma_signgam) +/* + * BSD math library entry points + */ +double drem(double, double); +double expm1(double) __pure2; +double log1p(double) __pure2; -/* The exception structure passed to the matherr routine. */ +/* + * Reentrant version of gamma & lgamma; passes signgam back by reference + * as the second argument; user must allocate space for signgam. + */ +#if __BSD_VISIBLE +double gamma_r(double, int *); +double lgamma_r(double, int *); +#endif /* __BSD_VISIBLE */ -#ifdef __cplusplus -struct __exception -#else -struct exception -#endif -{ - int type; - char *name; - double arg1; - double arg2; - double retval; - int err; -}; +/* float versions of ANSI/POSIX functions */ +float acosf(float); +float asinf(float); +float atanf(float); +float atan2f(float, float); +float cosf(float); +float sinf(float); +float tanf(float); -#ifdef __cplusplus -extern int matherr _PARAMS((struct __exception *e)); -#else -extern int matherr _PARAMS((struct exception *e)); -#endif +float coshf(float); +float sinhf(float); +float tanhf(float); -/* Values for the type field of struct exception. */ +float expf(float); +float frexpf(float, int *); /* fundamentally !__pure2 */ +float ldexpf(float, int); +float logf(float); +float log10f(float); +float modff(float, float *); /* fundamentally !__pure2 */ -#define DOMAIN 1 -#define SING 2 -#define OVERFLOW 3 -#define UNDERFLOW 4 -#define TLOSS 5 -#define PLOSS 6 +float powf(float, float); +float sqrtf(float); -/* Useful constants. */ +float ceilf(float); +float fabsf(float); +float floorf(float); +float fmodf(float, float); -#define M_E 2.7182818284590452354 -#define M_LOG2E 1.4426950408889634074 -#define M_LOG10E 0.43429448190325182765 -#define M_LN2 0.69314718055994530942 -#define M_LN10 2.30258509299404568402 -#define M_PI 3.14159265358979323846 -#define M_TWOPI (M_PI * 2.0) -#define M_PI_2 1.57079632679489661923 -#define M_PI_4 0.78539816339744830962 -#define M_3PI_4 2.3561944901923448370E0 -#define M_SQRTPI 1.77245385090551602792981 -#define M_1_PI 0.31830988618379067154 -#define M_2_PI 0.63661977236758134308 -#define M_2_SQRTPI 1.12837916709551257390 -#define M_SQRT2 1.41421356237309504880 -#define M_SQRT1_2 0.70710678118654752440 -#define M_LN2LO 1.9082149292705877000E-10 -#define M_LN2HI 6.9314718036912381649E-1 -#define M_SQRT3 1.73205080756887719000 -#define M_IVLN10 0.43429448190325182765 /* 1 / log(10) */ -#define M_LOG2_E 0.693147180559945309417 -#define M_INVLN2 1.4426950408889633870E0 /* 1 / log(2) */ +float erff(float); +float erfcf(float) __pure2; +int finitef(float) __pure2; +float gammaf(float); +float hypotf(float, float) __pure2; +float j0f(float); +float j1f(float); +float jnf(int, float); +float lgammaf(float); +float y0f(float); +float y1f(float); +float ynf(int, float); -/* Global control over fdlibm error handling. */ +float acoshf(float); +float asinhf(float); +float atanhf(float); +float cbrtf(float) __pure2; +float logbf(float) __pure2; +float nextafterf(float, float); +float remainderf(float, float); +float scalbf(float, float); -enum __fdlibm_version -{ - __fdlibm_ieee = -1, - __fdlibm_svid, - __fdlibm_xopen, - __fdlibm_posix -}; +/* + * float version of IEEE Test Vector + */ +float significandf(float); -#define _LIB_VERSION_TYPE enum __fdlibm_version -#define _LIB_VERSION __fdlib_version +/* + * Float versions of functions callable from C, intended to support + * IEEE arithmetic. + */ +float copysignf(float, float) __pure2; +int ilogbf(float); +float rintf(float); +float scalbnf(float, int); -extern __IMPORT _CONST _LIB_VERSION_TYPE _LIB_VERSION; +/* + * float versions of BSD math library entry points + */ +float dremf(float, float); +float expm1f(float) __pure2; +float log1pf(float) __pure2; -#define _IEEE_ __fdlibm_ieee -#define _SVID_ __fdlibm_svid -#define _XOPEN_ __fdlibm_xopen -#define _POSIX_ __fdlibm_posix +/* + * Float versions of reentrant version of gamma & lgamma; passes + * signgam back by reference as the second argument; user must + * allocate space for signgam. + */ +#if __BSD_VISIBLE +float gammaf_r(float, int *); +float lgammaf_r(float, int *); +#endif /* __BSD_VISIBLE */ -#endif /* ! defined (__STRICT_ANSI__) */ +/* + * long double versions of ISO/POSIX math functions + */ +#if 0 +long double acoshl(long double); +long double acosl(long double); +long double asinhl(long double); +long double asinl(long double); +long double atan2l(long double, long double); +long double atanhl(long double); +long double atanl(long double); +long double cbrtl(long double); +long double ceill(long double); +long double copysignl(long double, long double); +long double coshl(long double); +long double cosl(long double); +long double erfcl(long double); +long double erfl(long double); +long double exp2l(long double); +long double expl(long double); +long double expm1l(long double); +#endif +long double fabsl(long double); +#if 0 +long double fdiml(long double, long double); +long double floorl(long double); +long double fmal(long double, long double, long double); +long double fmaxl(long double, long double); +long double fminl(long double, long double); +long double fmodl(long double, long double); +long double frexpl(long double value, int *); +long double hypotl(long double, long double); +int ilogbl(long double); +long double ldexpl(long double, int); +long double lgammal(long double); +long long llrintl(long double); +long long llroundl(long double); +long double log10l(long double); +long double log1pl(long double); +long double log2l(long double); +long double logbl(long double); +long double logl(long double); +long lrintl(long double); +long lroundl(long double); +long double modfl(long double, long double *); +long double nanl(const char *); +long double nearbyintl(long double); +long double nextafterl(long double, long double); +double nexttoward(double, long double); +float nexttowardf(float, long double); +long double nexttowardl(long double, long double); +long double powl(long double, long double); +long double remainderl(long double, long double); +long double remquol(long double, long double, int *); +long double rintl(long double); +long double roundl(long double); +long double scalblnl(long double, long); +long double scalbnl(long double, int); +long double sinhl(long double); +long double sinl(long double); +long double sqrtl(long double); +long double tanhl(long double); +long double tanl(long double); +long double tgammal(long double); +long double truncl(long double); +#endif +#endif /* !_XOPEN_SOURCE */ +#endif /* !_ANSI_SOURCE && !_POSIX_SOURCE */ +__END_DECLS -#ifdef __cplusplus -} -#endif -#endif /* _MATH_H_ */ +#endif /* !_MATH_H_ */ ------------------------------------------------------- SF.Net email is Sponsored by the Better Software Conference & EXPO September 19-22, 2005 * San Francisco, CA * Development Lifecycle Practices Agile & Plan-Driven Development * Managing Projects & Teams * Testing & QA Security * Process Improvement & Measurement * http://www.sqe.com/bsce5sf