#include "math.h"
#include "math_private.h"
+libm_hidden_proto(log1p)
+libm_hidden_proto(sqrt)
+
#ifdef __STDC__
static const double
#else
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(fabs)
+
#ifdef __STDC__
static const double
#else
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(atan)
+libm_hidden_proto(fabs)
+
#ifdef __STDC__
static const double
#else
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(log1p)
+
#ifdef __STDC__
static const double one = 1.0, huge = 1e300;
#else
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(expm1)
+libm_hidden_proto(fabs)
+
#ifdef __STDC__
static const double one = 1.0, half=0.5, huge = 1.0e300;
#else
#include "math_private.h"
extern int signgam;
+libm_hidden_proto(signgam)
#ifdef __STDC__
//__private_extern__
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(sin)
+libm_hidden_proto(cos)
+libm_hidden_proto(sqrt)
+libm_hidden_proto(fabs)
+
#ifdef __STDC__
static double pzero(double), qzero(double);
#else
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(sin)
+libm_hidden_proto(cos)
+libm_hidden_proto(sqrt)
+libm_hidden_proto(fabs)
+
#ifdef __STDC__
static double pone(double), qone(double);
#else
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(sin)
+libm_hidden_proto(cos)
+libm_hidden_proto(sqrt)
+libm_hidden_proto(fabs)
+
#ifdef __STDC__
static const double
#else
#include "math_private.h"
extern int signgam;
+libm_hidden_proto(signgam)
#ifdef __STDC__
//__private_extern__
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(floor)
+libm_hidden_proto(fabs)
+
#ifdef __STDC__
static const double
#else
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(scalbn)
+libm_hidden_proto(fabs)
+
#ifdef __STDC__
static const double
#else
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(fabs)
+
/*
* Table of constants for 2/pi, 396 Hex digits (476 decimal) of 2/pi
*/
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(fabs)
+
#ifdef __STDC__
static const double zero = 0.0;
#else
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(scalbn)
+libm_hidden_proto(finite)
+libm_hidden_proto(rint)
+libm_hidden_proto(__isnan)
+
#ifdef _SCALB_INT
#ifdef __STDC__
double attribute_hidden __ieee754_scalb(double x, int fn)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(expm1)
+libm_hidden_proto(fabs)
+
#ifdef __STDC__
static const double one = 1.0, shuge = 1.0e307;
#else
#ifdef L_acosf
+libm_hidden_proto(acos)
float acosf (float x)
{
return (float) acos( (double)x );
#ifdef L_acoshf
+libm_hidden_proto(acosh)
float acoshf (float x)
{
return (float) acosh( (double)x );
#ifdef L_asinf
+libm_hidden_proto(asin)
float asinf (float x)
{
return (float) asin( (double)x );
#ifdef L_asinhf
+libm_hidden_proto(asinh)
float asinhf (float x)
{
return (float) asinh( (double)x );
#ifdef L_atan2f
+libm_hidden_proto(atan2)
float atan2f (float x, float y)
{
return (float) atan2( (double)x, (double)y );
#ifdef L_atanf
+libm_hidden_proto(atan)
float atanf (float x)
{
return (float) atan( (double)x );
#ifdef L_atanhf
+libm_hidden_proto(atanh)
float atanhf (float x)
{
return (float) atanh( (double)x );
#ifdef L_cbrtf
+libm_hidden_proto(cbrt)
float cbrtf (float x)
{
return (float) cbrt( (double)x );
#ifdef L_ceilf
+libm_hidden_proto(ceil)
float ceilf (float x)
{
return (float) ceil( (double)x );
#ifdef L_copysignf
+libm_hidden_proto(copysign)
float copysignf (float x, float y)
{
return (float) copysign( (double)x, (double)y );
#ifdef L_cosf
+libm_hidden_proto(cos)
float cosf (float x)
{
return (float) cos( (double)x );
#ifdef L_coshf
+libm_hidden_proto(cosh)
float coshf (float x)
{
return (float) cosh( (double)x );
#ifdef L_erfcf
+libm_hidden_proto(erfc)
float erfcf (float x)
{
return (float) erfc( (double)x );
#ifdef L_erff
+libm_hidden_proto(erf)
float erff (float x)
{
return (float) erf( (double)x );
#ifdef L_exp2f
+libm_hidden_proto(exp2)
float exp2f (float x)
{
return (float) exp2( (double)x );
#ifdef L_expf
+libm_hidden_proto(exp)
float expf (float x)
{
return (float) exp( (double)x );
#ifdef L_expm1f
+libm_hidden_proto(expm1)
float expm1f (float x)
{
return (float) expm1( (double)x );
#ifdef L_fabsf
+libm_hidden_proto(fabs)
float fabsf (float x)
{
return (float) fabs( (double)x );
#ifdef L_fdimf
+libm_hidden_proto(fdim)
float fdimf (float x, float y)
{
return (float) fdim( (double)x, (double)y );
#ifdef L_floorf
+libm_hidden_proto(floor)
float floorf (float x)
{
return (float) floor( (double)x );
#ifdef L_fmaf
+libm_hidden_proto(fma)
float fmaf (float x, float y, float z)
{
return (float) fma( (double)x, (double)y, (double)z );
#ifdef L_fmaxf
+libm_hidden_proto(fmax)
float fmaxf (float x, float y)
{
return (float) fmax( (double)x, (double)y );
#ifdef L_fminf
+libm_hidden_proto(fmin)
float fminf (float x, float y)
{
return (float) fmin( (double)x, (double)y );
#ifdef L_fmodf
+libm_hidden_proto(fmod)
float fmodf (float x, float y)
{
return (float) fmod( (double)x, (double)y );
#ifdef L_frexpf
+libm_hidden_proto(frexp)
float frexpf (float x, int *exp)
{
return (float) frexp( (double)x, exp );
#ifdef L_hypotf
+libm_hidden_proto(hypot)
float hypotf (float x, float y)
{
return (float) hypot( (double)x, (double)y );
#ifdef L_ilogbf
+libm_hidden_proto(ilogb)
int ilogbf (float x)
{
return (float) ilogb( (double)x );
#ifdef L_ldexpf
+libm_hidden_proto(ldexp)
float ldexpf (float x, int exp)
{
return (float) ldexp( (double)x, exp );
#ifdef L_lgammaf
+libm_hidden_proto(lgamma)
float lgammaf (float x)
{
return (float) lgamma( (double)x );
#ifdef L_llrintf
+libm_hidden_proto(llrint)
long long llrintf (float x)
{
return (float) llrint( (double)x );
#ifdef L_llroundf
+libm_hidden_proto(llround)
long long llroundf (float x)
{
return (float) llround( (double)x );
#ifdef L_log10f
+libm_hidden_proto(log10)
float log10f (float x)
{
return (float) log10( (double)x );
#ifdef L_log1pf
+libm_hidden_proto(log1p)
float log1pf (float x)
{
return (float) log1p( (double)x );
#ifdef L_log2f
+libm_hidden_proto(log2)
float log2f (float x)
{
return (float) log2( (double)x );
#ifdef L_logbf
+libm_hidden_proto(logb)
float logbf (float x)
{
return (float) logb( (double)x );
#ifdef L_logf
+libm_hidden_proto(log)
float logf (float x)
{
return (float) log( (double)x );
#ifdef L_lrintf
+libm_hidden_proto(lrint)
long lrintf (float x)
{
return (float) lrint( (double)x );
#ifdef L_lroundf
+libm_hidden_proto(lround)
long lroundf (float x)
{
return (float) lround( (double)x );
#ifdef L_modff
+libm_hidden_proto(modf)
float modff (float x, float *iptr)
{
double y, result;
#ifdef L_nearbyintf
+libm_hidden_proto(nearbyint)
float nearbyintf (float x)
{
return (float) nearbyint( (double)x );
#ifdef L_nextafterf
+libm_hidden_proto(nextafter)
float nextafterf (float x, float y)
{
return (float) nextafter( (double)x, (double)y );
#ifdef L_nexttowardf
+libm_hidden_proto(nexttoward)
float nexttowardf (float x, long double y)
{
return (float) nexttoward( (double)x, (double)y );
#ifdef L_powf
+libm_hidden_proto(pow)
float powf (float x, float y)
{
return (float) pow( (double)x, (double)y );
#ifdef L_remainderf
+libm_hidden_proto(remainder)
float remainderf (float x, float y)
{
return (float) remainder( (double)x, (double)y );
#ifdef L_remquof
+libm_hidden_proto(remquo)
float remquof (float x, float y, int *quo)
{
return (float) remquo( (double)x, (double)y, quo );
#ifdef L_rintf
+libm_hidden_proto(rint)
float rintf (float x)
{
return (float) rint( (double)x );
#ifdef L_roundf
+libm_hidden_proto(round)
float roundf (float x)
{
return (float) round( (double)x );
#ifdef L_scalblnf
+libm_hidden_proto(scalbln)
float scalblnf (float x, long exp)
{
return (float) scalbln( (double)x, exp );
#ifdef L_scalbnf
+libm_hidden_proto(scalbn)
float scalbnf (float x, int exp)
{
return (float) scalbn( (double)x, exp );
#ifdef L_sinf
+libm_hidden_proto(sin)
float sinf (float x)
{
return (float) sin( (double)x );
#ifdef L_sinhf
+libm_hidden_proto(sinh)
float sinhf (float x)
{
return (float) sinh( (double)x );
#ifdef L_sqrtf
+libm_hidden_proto(sqrt)
float sqrtf (float x)
{
return (float) sqrt( (double)x );
#ifdef L_tanf
+libm_hidden_proto(tan)
float tanf (float x)
{
return (float) tan( (double)x );
#ifdef L_tanhf
+libm_hidden_proto(tanh)
float tanhf (float x)
{
return (float) tanh( (double)x );
#ifdef L_tgammaf
+libm_hidden_proto(tgamma)
float tgammaf (float x)
{
return (float) tgamma( (double)x );
#ifdef L_truncf
+libm_hidden_proto(trunc)
float truncf (float x)
{
return (float) trunc( (double)x );
Calls: none
***********************************************************************/
+libm_hidden_proto(__fpclassifyf)
int __fpclassifyf ( float x )
{
unsigned int iexp;
else
return FP_SUBNORMAL; /* must be subnormal */
}
+libm_hidden_def(__fpclassifyf)
/***********************************************************************
Calls: none
***********************************************************************/
+libm_hidden_proto(__fpclassify)
int __fpclassify ( double arg )
{
register unsigned int exponent;
return FP_SUBNORMAL;
}
}
+libm_hidden_def(__fpclassify)
/***********************************************************************
z.fval = x;
return ((z.lval & FEXP_MASK) != FEXP_MASK);
}
-weak_alias (__finitef, finitef)
+strong_alias(__finitef,finitef)
#if 0 /* use __finite in s_finite.c */
int __finite ( double x )
{
return ( __fpclassify ( x ) >= FP_ZERO );
}
-weak_alias (__finite, finite)
+strong_alias(__finite,finite)
#endif
Calls: none
***********************************************************************/
+libm_hidden_proto(__signbitf)
int __signbitf ( float x )
{
union {
z.fval = x;
return ((z.lval & SIGN_MASK) != 0);
}
+libm_hidden_def(__signbitf)
/***********************************************************************
Calls: none
***********************************************************************/
+libm_hidden_proto(__signbit)
int __signbit ( double arg )
{
union
sign = ( ( x.hex.high & dSgnMask ) == dSgnMask ) ? 1 : 0;
return sign;
}
+libm_hidden_def(__signbit)
/***********************************************************************
}
return 0;
}
-weak_alias (__isinff, isinff)
+strong_alias(__isinff,isinff)
int __isinf ( double x )
{
}
return 0;
}
-weak_alias (__isinf, isinf)
+strong_alias(__isinf,isinf)
#if 0
int __isinfl ( long double x )
}
return 0;
}
-weak_alias (__isinfl, isinfl)
+strong_alias(__isinfl,isinfl)
#endif
/***********************************************************************
z.fval = x;
return (((z.lval&FEXP_MASK) == FEXP_MASK) && ((z.lval&FFRAC_MASK) != 0));
}
-weak_alias (__isnanf, isnanf)
+strong_alias(__isnanf,isnanf)
+libm_hidden_proto(__isnan)
int __isnan ( double x )
{
int class = __fpclassify(x);
return ( class == FP_NAN );
}
-weak_alias (__isnan, isnan)
+libm_hidden_def(__isnan)
+strong_alias(__isnan,isnan)
#if 0
int __isnanl ( long double x )
int class = __fpclassify(x);
return ( class == FP_NAN );
}
-weak_alias (__isnanl, isnanl)
+strong_alias(__isnanl,isnanl)
#endif
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(scalbn)
+libm_hidden_proto(floor)
+
#ifdef __STDC__
static const int init_jk[] = {2,3,4,6}; /* initial value for jk */
#else
#include "math_private.h"
#include <errno.h>
+libm_hidden_proto(copysign)
+libm_hidden_proto(matherr)
+libm_hidden_proto(rint)
+
#ifndef _USE_WRITE
#include <stdio.h> /* fputs(), stderr */
#define WRITE2(u,v) fputs(u, stderr)
#include "math.h"
#include "math_private.h"
+
+libm_hidden_proto(fabs)
+
#ifdef __STDC__
static const double
#else
* Ceil(x) returns the smallest integer not less than x. *
*******************************************************************************/
+libm_hidden_proto(ceil)
double ceil ( double x )
{
DblInHex xInHex,OldEnvironment;
*******************************************************************************/
return ( x );
}
-
+libm_hidden_def(ceil)
* suggested in the IEEE standard 754. *
*******************************************************************************/
+libm_hidden_proto(copysign)
double copysign ( double arg2, double arg1 )
{
union
return y.dbl;
}
+libm_hidden_def(copysign)
* Floor(x) returns the largest integer not greater than x. *
*******************************************************************************/
+libm_hidden_proto(floor)
double floor ( double x )
{
DblInHex xInHex,OldEnvironment;
*******************************************************************************/
return ( x );
}
-
+libm_hidden_def(floor)
double dbl;
} DblInHex;
+libm_hidden_proto(frexp)
double frexp ( double value, int *eptr )
{
DblInHex argument;
argument.words.hi = ( argument.words.hi & 0x800fffff ) | 0x3fe00000;
return argument.dbl;
}
-
+libm_hidden_def(frexp)
double dbl;
} DblInHex;
+libm_hidden_proto(ldexp)
double ldexp ( double value, int exp )
{
if ( exp > SHRT_MAX )
exp = -SHRT_MAX;
return scalb ( value, exp );
}
-
+libm_hidden_def(ldexp)
********************************************************************************
*******************************************************************************/
+libm_hidden_proto(logb)
double logb ( double x )
{
DblInHex xInHex;
return ( xInHex.dbl - klTod );
}
}
-
+libm_hidden_def(logb)
* modf is the double implementation. *
*******************************************************************************/
+libm_hidden_proto(modf)
double modf ( double x, double *iptr )
{
register double OldEnvironment, xtrunc;
return ( argument.dbl );
}
}
+libm_hidden_def(modf)
static const double twoTo52 = 4503599627370496.0;
+libm_hidden_proto(nearbyint)
double nearbyint ( double x )
{
double y;
asm ("mtfsf 255,%0" : /*NULLOUT*/ : /*IN*/ "f" ( OldEnvironment ));
return ( y );
}
+libm_hidden_def(nearbyint)
static const DblInHex Huge = {{ 0x7FF00000, 0x00000000 }};
static const DblInHex TOWARDZERO = {{ 0x00000000, 0x00000001 }};
+libm_hidden_proto(rint)
/*******************************************************************************
* *
* The function rint rounds its double argument to integral value *
*******************************************************************************/
return ( x );
}
-
+libm_hidden_def(rint)
* *
*******************************************************************************/
+libm_hidden_proto(round)
double round ( double x )
{
DblInHex argument, OldEnvironment;
*******************************************************************************/
return ( x );
}
+libm_hidden_def(round)
* *
*******************************************************************************/
+libm_hidden_proto(trunc)
double trunc ( double x )
{
DblInHex argument,OldEnvironment;
*******************************************************************************/
return ( x );
}
+libm_hidden_def(trunc)
Calls: none.
***********************************************************************/
+libm_hidden_proto(scalb)
double scalb ( double x, int n )
{
DblInHex xInHex;
xInHex.words.hi = ( ( unsigned long ) ( n + 1023 ) ) << 20;
return ( x * xInHex.dbl );
}
+libm_hidden_def(scalb)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(log1p)
+libm_hidden_proto(fabs)
+
#ifdef __STDC__
static const double
#else
ln2 = 6.93147180559945286227e-01, /* 0x3FE62E42, 0xFEFA39EF */
huge= 1.00000000000000000000e+300;
+libm_hidden_proto(asinh)
#ifdef __STDC__
double asinh(double x)
#else
}
if(hx>0) return w; else return -w;
}
+libm_hidden_def(asinh)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(fabs)
+
#ifdef __STDC__
static const double atanhi[] = {
#else
1.62858201153657823623e-02, /* 0x3F90AD3A, 0xE322DA11 */
};
+libm_hidden_proto(atan)
#ifdef __STDC__
static const double
#else
return (hx<0)? -z:z;
}
}
+libm_hidden_def(atan)
F = 1.60714285714285720630e+00, /* 45/28 = 0x3FF9B6DB, 0x6DB6DB6E */
G = 3.57142857142857150787e-01; /* 5/14 = 0x3FD6DB6D, 0xB6DB6DB7 */
+libm_hidden_proto(cbrt)
#ifdef __STDC__
double cbrt(double x)
#else
SET_HIGH_WORD(t,high|sign);
return(t);
}
+libm_hidden_def(cbrt)
static double huge = 1.0e300;
#endif
+libm_hidden_proto(ceil)
#ifdef __STDC__
double ceil(double x)
#else
INSERT_WORDS(x,i0,i1);
return x;
}
-
+libm_hidden_def(ceil)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(copysign)
#ifdef __STDC__
double copysign(double x, double y)
#else
SET_HIGH_WORD(x,(hx&0x7fffffff)|(hy&0x80000000));
return x;
}
-
+libm_hidden_def(copysign)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(cos)
#ifdef __STDC__
double cos(double x)
#else
}
}
}
+libm_hidden_def(cos)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(fabs)
+
#ifdef __STDC__
static const double
#else
sb6 = 4.74528541206955367215e+02, /* 0x407DA874, 0xE79FE763 */
sb7 = -2.24409524465858183362e+01; /* 0xC03670E2, 0x42712D62 */
+libm_hidden_proto(erf)
#ifdef __STDC__
double erf(double x)
#else
r = __ieee754_exp(-z*z-0.5625)*__ieee754_exp((z-x)*(z+x)+R/S);
if(hx>=0) return one-r/x; else return r/x-one;
}
+libm_hidden_def(erf)
+libm_hidden_proto(erfc)
#ifdef __STDC__
double erfc(double x)
#else
if(hx>0) return tiny*tiny; else return two-tiny;
}
}
+libm_hidden_def(erfc)
Q4 = 4.00821782732936239552e-06, /* 3ED0CFCA 86E65239 */
Q5 = -2.01099218183624371326e-07; /* BE8AFDB7 6E09C32D */
+libm_hidden_proto(expm1)
#ifdef __STDC__
double expm1(double x)
#else
}
return y;
}
+libm_hidden_def(expm1)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(fabs)
#ifdef __STDC__
double fabs(double x)
#else
SET_HIGH_WORD(x,high&0x7fffffff);
return x;
}
+libm_hidden_def(fabs)
GET_HIGH_WORD(hx,x);
return (int)((u_int32_t)((hx&0x7fffffff)-0x7ff00000)>>31);
}
-weak_alias(__finite,finite)
+libm_hidden_proto(finite)
+strong_alias(__finite,finite)
+libm_hidden_def(finite)
static double huge = 1.0e300;
#endif
+libm_hidden_proto(floor)
#ifdef __STDC__
double floor(double x)
#else
INSERT_WORDS(x,i0,i1);
return x;
}
+libm_hidden_def(floor)
#endif
two54 = 1.80143985094819840000e+16; /* 0x43500000, 0x00000000 */
+libm_hidden_proto(frexp)
#ifdef __STDC__
double frexp(double x, int *eptr)
#else
SET_HIGH_WORD(x,hx);
return x;
}
+libm_hidden_def(frexp)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(ilogb)
#ifdef __STDC__
int ilogb(double x)
#else
else if (hx<0x7ff00000) return (hx>>20)-1023;
else return 0x7fffffff;
}
+libm_hidden_def(ilogb)
#include "math_private.h"
#include <errno.h>
+libm_hidden_proto(scalbn)
+libm_hidden_proto(finite)
+
+libm_hidden_proto(ldexp)
#ifdef __STDC__
double ldexp(double value, int exp)
#else
if(!finite(value)||value==0.0) errno = ERANGE;
return value;
}
+libm_hidden_def(ldexp)
#include "math_private.h"
-
+libm_hidden_proto(llround)
long long int
llround (double x)
{
return sign * result;
}
+libm_hidden_def(llround)
static double zero = 0.0;
#endif
+libm_hidden_proto(log1p)
#ifdef __STDC__
double log1p(double x)
#else
if(k==0) return f-(hfsq-s*(hfsq+R)); else
return k*ln2_hi-((hfsq-(s*(hfsq+R)+(k*ln2_lo+c)))-f);
}
+libm_hidden_def(log1p)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(fabs)
+
+libm_hidden_proto(logb)
#ifdef __STDC__
double logb(double x)
#else
else
return (double) (ix-1023);
}
+libm_hidden_def(logb)
#include "math_private.h"
-
+libm_hidden_proto(lround)
long int
lround (double x)
{
return sign * result;
}
+libm_hidden_def(lround)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(matherr)
#ifdef __STDC__
int matherr(struct exception *x)
#else
if(x->arg1!=x->arg1) return 0;
return n;
}
+libm_hidden_def(matherr)
static double one = 1.0;
#endif
+libm_hidden_proto(modf)
#ifdef __STDC__
double modf(double x, double *iptr)
#else
}
}
}
+libm_hidden_def(modf)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(nextafter)
#ifdef __STDC__
double nextafter(double x, double y)
#else
INSERT_WORDS(x,hx,lx);
return x;
}
+libm_hidden_def(nextafter)
-4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
};
+libm_hidden_proto(rint)
#ifdef __STDC__
double rint(double x)
#else
w = TWO52[sx]+x;
return w-TWO52[sx];
}
+libm_hidden_def(rint)
static const double huge = 1.0e300;
-
+libm_hidden_proto(round)
double
round (double x)
{
INSERT_WORDS (x, i0, i1);
return x;
}
+libm_hidden_def(round)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(copysign)
+
#ifdef __STDC__
static const double
#else
huge = 1.0e+300,
tiny = 1.0e-300;
+libm_hidden_proto(scalbn)
#ifdef __STDC__
double scalbn (double x, int n)
#else
SET_HIGH_WORD(x,(hx&0x800fffff)|(k<<20));
return x*twom54;
}
+libm_hidden_def(scalbn)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(signgam)
int signgam = 0;
+libm_hidden_def(signgam)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(ilogb)
+
#ifdef __STDC__
double significand(double x)
#else
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(sin)
#ifdef __STDC__
double sin(double x)
#else
}
}
}
+libm_hidden_def(sin)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(tan)
#ifdef __STDC__
double tan(double x)
#else
-1 -- n odd */
}
}
+libm_hidden_def(tan)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(expm1)
+libm_hidden_proto(fabs)
+
#ifdef __STDC__
static const double one=1.0, two=2.0, tiny = 1.0e-300;
#else
static double one=1.0, two=2.0, tiny = 1.0e-300;
#endif
+libm_hidden_proto(tanh)
#ifdef __STDC__
double tanh(double x)
#else
}
return (jx>=0)? z: -z;
}
+libm_hidden_def(tanh)
#include "math.h"
#include "math_private.h"
-
+libm_hidden_proto(acos)
#ifdef __STDC__
double acos(double x) /* wrapper acos */
#else
return z;
#endif
}
+libm_hidden_def(acos)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(acosh)
#ifdef __STDC__
double acosh(double x) /* wrapper acosh */
#else
return z;
#endif
}
+libm_hidden_def(acosh)
#include "math_private.h"
+libm_hidden_proto(asin)
#ifdef __STDC__
double asin(double x) /* wrapper asin */
#else
return z;
#endif
}
+libm_hidden_def(asin)
#include "math.h"
#include "math_private.h"
-
+libm_hidden_proto(atan2)
#ifdef __STDC__
double atan2(double y, double x) /* wrapper atan2 */
#else
return z;
#endif
}
+libm_hidden_def(atan2)
#include "math.h"
#include "math_private.h"
-
+libm_hidden_proto(atanh)
#ifdef __STDC__
double atanh(double x) /* wrapper atanh */
#else
return z;
#endif
}
+libm_hidden_def(atanh)
#include <complex.h>
#include <math.h>
+libm_hidden_proto(hypot)
+
double cabs(double _Complex z)
{
return hypot(__real__ z, __imag__ z);
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(cosh)
#ifdef __STDC__
double cosh(double x) /* wrapper cosh */
#else
return z;
#endif
}
+libm_hidden_def(cosh)
#include <math.h>
+libm_hidden_proto(remainder)
+
double
drem(x, y)
double x, y;
o_threshold= 7.09782712893383973096e+02, /* 0x40862E42, 0xFEFA39EF */
u_threshold= -7.45133219101941108420e+02; /* 0xc0874910, 0xD52D3051 */
+libm_hidden_proto(exp)
#ifdef __STDC__
double exp(double x) /* wrapper exp */
#else
return z;
#endif
}
+libm_hidden_def(exp)
#include "math.h"
#include "math_private.h"
-
+libm_hidden_proto(fmod)
#ifdef __STDC__
double fmod(double x, double y) /* wrapper fmod */
#else
return z;
#endif
}
+libm_hidden_def(fmod)
#include "math_private.h"
extern int signgam;
+libm_hidden_proto(signgam)
#ifdef __STDC__
double gamma(double x)
#include "math.h"
#include "math_private.h"
-
+libm_hidden_proto(hypot)
#ifdef __STDC__
double hypot(double x, double y)/* wrapper hypot */
#else
return z;
#endif
}
+libm_hidden_def(hypot)
#include "math_private.h"
extern int signgam;
+libm_hidden_proto(signgam)
+libm_hidden_proto(lgamma)
#ifdef __STDC__
double lgamma(double x)
#else
return y;
#endif
}
+libm_hidden_def(lgamma)
#include "math.h"
#include "math_private.h"
-
+libm_hidden_proto(log)
#ifdef __STDC__
double log(double x) /* wrapper log */
#else
return __kernel_standard(x,x,17); /* log(x<0) */
#endif
}
+libm_hidden_def(log)
#include "math.h"
#include "math_private.h"
-
+libm_hidden_proto(log10)
#ifdef __STDC__
double log10(double x) /* wrapper log10 */
#else
return z;
#endif
}
+libm_hidden_def(log10)
#include "math.h"
#include "math_private.h"
-
+libm_hidden_proto(pow)
#ifdef __STDC__
double pow(double x, double y) /* wrapper pow */
#else
return z;
#endif
}
+libm_hidden_def(pow)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(remainder)
#ifdef __STDC__
double remainder(double x, double y) /* wrapper remainder */
#else
return z;
#endif
}
+libm_hidden_def(remainder)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(sinh)
#ifdef __STDC__
double sinh(double x) /* wrapper sinh */
#else
return z;
#endif
}
+libm_hidden_def(sinh)
#include "math.h"
#include "math_private.h"
+libm_hidden_proto(sqrt)
#ifdef __STDC__
double sqrt(double x) /* wrapper sqrt */
#else
return z;
#endif
}
+libm_hidden_def(sqrt)