Note that gamma_r is not provided by glibc, perhaps add a SUN specific knob later
/* Arc cosine of Z. */
__MATHCALL (cacos, (_Mdouble_complex_ __z));
+libm_hidden_proto(cacos)
/* Arc sine of Z. */
__MATHCALL (casin, (_Mdouble_complex_ __z));
+libm_hidden_proto(casin)
/* Arc tangent of Z. */
__MATHCALL (catan, (_Mdouble_complex_ __z));
+libm_hidden_proto(catan)
/* Cosine of Z. */
__MATHCALL (ccos, (_Mdouble_complex_ __z));
+libm_hidden_proto(ccos)
/* Sine of Z. */
__MATHCALL (csin, (_Mdouble_complex_ __z));
+libm_hidden_proto(csin)
/* Tangent of Z. */
__MATHCALL (ctan, (_Mdouble_complex_ __z));
+libm_hidden_proto(ctan)
/* Hyperbolic functions. */
/* Hyperbolic arc cosine of Z. */
__MATHCALL (cacosh, (_Mdouble_complex_ __z));
+libm_hidden_proto(cacosh)
/* Hyperbolic arc sine of Z. */
__MATHCALL (casinh, (_Mdouble_complex_ __z));
+libm_hidden_proto(casinh)
/* Hyperbolic arc tangent of Z. */
__MATHCALL (catanh, (_Mdouble_complex_ __z));
+libm_hidden_proto(catanh)
/* Hyperbolic cosine of Z. */
__MATHCALL (ccosh, (_Mdouble_complex_ __z));
+libm_hidden_proto(ccosh)
/* Hyperbolic sine of Z. */
__MATHCALL (csinh, (_Mdouble_complex_ __z));
+libm_hidden_proto(ccosh)
/* Hyperbolic tangent of Z. */
__MATHCALL (ctanh, (_Mdouble_complex_ __z));
+libm_hidden_proto(ctanh)
/* Exponential and logarithmic functions. */
/* Exponential function of Z. */
__MATHCALL (cexp, (_Mdouble_complex_ __z));
+libm_hidden_proto(cexp)
/* Natural logarithm of Z. */
__MATHCALL (clog, (_Mdouble_complex_ __z));
+libm_hidden_proto(clog)
#ifdef __USE_GNU
/* The base 10 logarithm is not defined by the standard but to implement
the standard C++ library it is handy. */
__MATHCALL (clog10, (_Mdouble_complex_ __z));
+libm_hidden_proto(clog10)
#endif
/* Power functions. */
/* Return X to the Y power. */
__MATHCALL (cpow, (_Mdouble_complex_ __x, _Mdouble_complex_ __y));
+libm_hidden_proto(cpow)
/* Return the square root of Z. */
__MATHCALL (csqrt, (_Mdouble_complex_ __z));
+libm_hidden_proto(csqrt)
/* Absolute value, conjugates, and projection. */
/* Absolute value of Z. */
__MATHDECL (_Mdouble_,cabs, (_Mdouble_complex_ __z));
+libm_hidden_proto(cabs)
/* Argument value of Z. */
__MATHDECL (_Mdouble_,carg, (_Mdouble_complex_ __z));
+libm_hidden_proto(carg)
/* Complex conjugate of Z. */
__MATHCALL (conj, (_Mdouble_complex_ __z));
+libm_hidden_proto(conj)
/* Projection of Z onto the Riemann sphere. */
__MATHCALL (cproj, (_Mdouble_complex_ __z));
+libm_hidden_proto(cproj)
/* Decomposing complex values. */
/* Imaginary part of Z. */
__MATHDECL (_Mdouble_,cimag, (_Mdouble_complex_ __z));
+libm_hidden_proto(cimag)
/* Real part of Z. */
__MATHDECL (_Mdouble_,creal, (_Mdouble_complex_ __z));
+libm_hidden_proto(creal)
/* Now some optimized versions. GCC has handy notations for these
_Mdouble_BEGIN_NAMESPACE
/* Arc cosine of X. */
__MATHCALL (acos,, (_Mdouble_ __x));
+libm_hidden_proto(acos)
/* Arc sine of X. */
__MATHCALL (asin,, (_Mdouble_ __x));
+libm_hidden_proto(asin)
/* Arc tangent of X. */
__MATHCALL (atan,, (_Mdouble_ __x));
+libm_hidden_proto(atan)
/* Arc tangent of Y/X. */
__MATHCALL (atan2,, (_Mdouble_ __y, _Mdouble_ __x));
+libm_hidden_proto(atan2)
/* Cosine of X. */
__MATHCALL (cos,, (_Mdouble_ __x));
+libm_hidden_proto(cos)
/* Sine of X. */
__MATHCALL (sin,, (_Mdouble_ __x));
+libm_hidden_proto(sin)
/* Tangent of X. */
__MATHCALL (tan,, (_Mdouble_ __x));
+libm_hidden_proto(tan)
/* Hyperbolic functions. */
/* Hyperbolic cosine of X. */
__MATHCALL (cosh,, (_Mdouble_ __x));
+libm_hidden_proto(cosh)
/* Hyperbolic sine of X. */
__MATHCALL (sinh,, (_Mdouble_ __x));
+libm_hidden_proto(sinh)
/* Hyperbolic tangent of X. */
__MATHCALL (tanh,, (_Mdouble_ __x));
+libm_hidden_proto(tanh)
_Mdouble_END_NAMESPACE
#if 0 /*def __USE_GNU*/
/* Cosine and sine of X. */
__MATHDECL (void,sincos,,
(_Mdouble_ __x, _Mdouble_ *__sinx, _Mdouble_ *__cosx));
+libm_hidden_proto(sincos)
#endif
#if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
__BEGIN_NAMESPACE_C99
/* Hyperbolic arc cosine of X. */
__MATHCALL (acosh,, (_Mdouble_ __x));
+libm_hidden_proto(acosh)
/* Hyperbolic arc sine of X. */
__MATHCALL (asinh,, (_Mdouble_ __x));
+libm_hidden_proto(asinh)
/* Hyperbolic arc tangent of X. */
__MATHCALL (atanh,, (_Mdouble_ __x));
+libm_hidden_proto(atanh)
__END_NAMESPACE_C99
#endif
_Mdouble_BEGIN_NAMESPACE
/* Exponential function of X. */
__MATHCALL (exp,, (_Mdouble_ __x));
+libm_hidden_proto(exp)
/* Break VALUE into a normalized fraction and an integral power of 2. */
__MATHCALL (frexp,, (_Mdouble_ __x, int *__exponent));
+libm_hidden_proto(frexp)
/* X times (two to the EXP power). */
__MATHCALL (ldexp,, (_Mdouble_ __x, int __exponent));
+libm_hidden_proto(ldexp)
/* Natural logarithm of X. */
__MATHCALL (log,, (_Mdouble_ __x));
+libm_hidden_proto(log)
/* Base-ten logarithm of X. */
__MATHCALL (log10,, (_Mdouble_ __x));
+libm_hidden_proto(log10)
/* Break VALUE into integral and fractional parts. */
__MATHCALL (modf,, (_Mdouble_ __x, _Mdouble_ *__iptr));
+libm_hidden_proto(modf)
_Mdouble_END_NAMESPACE
#if 0 /*def __USE_GNU*/
/* A function missing in all standards: compute exponent to base ten. */
__MATHCALL (exp10,, (_Mdouble_ __x));
+libm_hidden_proto(exp10)
/* Another name occasionally used. */
__MATHCALL (pow10,, (_Mdouble_ __x));
+libm_hidden_proto(pow10)
#endif
#if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
__BEGIN_NAMESPACE_C99
/* Return exp(X) - 1. */
__MATHCALL (expm1,, (_Mdouble_ __x));
+libm_hidden_proto(expm1)
/* Return log(1 + X). */
__MATHCALL (log1p,, (_Mdouble_ __x));
+libm_hidden_proto(log1p)
/* Return the base 2 signed integral exponent of X. */
__MATHCALL (logb,, (_Mdouble_ __x));
+libm_hidden_proto(logb)
__END_NAMESPACE_C99
#endif
__BEGIN_NAMESPACE_C99
/* Compute base-2 exponential of X. */
__MATHCALL (exp2,, (_Mdouble_ __x));
+libm_hidden_proto(exp2)
/* Compute base-2 logarithm of X. */
__MATHCALL (log2,, (_Mdouble_ __x));
+libm_hidden_proto(log2)
__END_NAMESPACE_C99
#endif
_Mdouble_BEGIN_NAMESPACE
/* Return X to the Y power. */
__MATHCALL (pow,, (_Mdouble_ __x, _Mdouble_ __y));
+libm_hidden_proto(pow)
/* Return the square root of X. */
__MATHCALL (sqrt,, (_Mdouble_ __x));
+libm_hidden_proto(sqrt)
_Mdouble_END_NAMESPACE
#if defined __USE_MISC || defined __USE_XOPEN || defined __USE_ISOC99
__BEGIN_NAMESPACE_C99
/* Return `sqrt(X*X + Y*Y)'. */
__MATHCALL (hypot,, (_Mdouble_ __x, _Mdouble_ __y));
+libm_hidden_proto(hypot)
__END_NAMESPACE_C99
#endif
__BEGIN_NAMESPACE_C99
/* Return the cube root of X. */
__MATHCALL (cbrt,, (_Mdouble_ __x));
+libm_hidden_proto(cbrt)
__END_NAMESPACE_C99
#endif
_Mdouble_BEGIN_NAMESPACE
/* Smallest integral value not less than X. */
__MATHCALLX (ceil,, (_Mdouble_ __x), (__const__));
+libm_hidden_proto(ceil)
/* Absolute value of X. */
__MATHCALLX (fabs,, (_Mdouble_ __x), (__const__));
+libm_hidden_proto(fabs)
/* Largest integer not greater than X. */
__MATHCALLX (floor,, (_Mdouble_ __x), (__const__));
+libm_hidden_proto(floor)
/* Floating-point modulo remainder of X/Y. */
__MATHCALL (fmod,, (_Mdouble_ __x, _Mdouble_ __y));
+libm_hidden_proto(fmod)
/* Return 0 if VALUE is finite or NaN, +1 if it
is +Infinity, -1 if it is -Infinity. */
__MATHDECL_1 (int,__isinf,, (_Mdouble_ __value)) __attribute__ ((__const__));
+libm_hidden_proto(__isinf)
/* Return nonzero if VALUE is finite and not NaN. */
__MATHDECL_1 (int,__finite,, (_Mdouble_ __value)) __attribute__ ((__const__));
+libm_hidden_proto(__finite)
_Mdouble_END_NAMESPACE
#ifdef __USE_MISC
/* Return 0 if VALUE is finite or NaN, +1 if it
is +Infinity, -1 if it is -Infinity. */
__MATHDECL_1 (int,isinf,, (_Mdouble_ __value)) __attribute__ ((__const__));
+libm_hidden_proto(isinf)
/* Return nonzero if VALUE is finite and not NaN. */
__MATHDECL_1 (int,finite,, (_Mdouble_ __value)) __attribute__ ((__const__));
+libm_hidden_proto(finite)
/* Return the remainder of X/Y. */
__MATHCALL (drem,, (_Mdouble_ __x, _Mdouble_ __y));
+libm_hidden_proto(drem)
/* Return the fractional part of X after dividing out `ilogb (X)'. */
__MATHCALL (significand,, (_Mdouble_ __x));
+libm_hidden_proto(significand)
#endif /* Use misc. */
#if defined __USE_MISC || defined __USE_ISOC99
__BEGIN_NAMESPACE_C99
/* Return X with its signed changed to Y's. */
__MATHCALLX (copysign,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
+libm_hidden_proto(copysign)
__END_NAMESPACE_C99
#endif
__BEGIN_NAMESPACE_C99
/* Return representation of NaN for double type. */
__MATHCALLX (nan,, (__const char *__tagb), (__const__));
+libm_hidden_proto(nan)
__END_NAMESPACE_C99
#endif
/* Return nonzero if VALUE is not a number. */
__MATHDECL_1 (int,__isnan,, (_Mdouble_ __value)) __attribute__ ((__const__));
+libm_hidden_proto(__isnan)
#if defined __USE_MISC || defined __USE_XOPEN
/* Return nonzero if VALUE is not a number. */
__MATHDECL_1 (int,isnan,, (_Mdouble_ __value)) __attribute__ ((__const__));
+libm_hidden_proto(isnan)
/* Bessel functions. */
__MATHCALL (j0,, (_Mdouble_));
+libm_hidden_proto(j0)
__MATHCALL (j1,, (_Mdouble_));
+libm_hidden_proto(j1)
__MATHCALL (jn,, (int, _Mdouble_));
+libm_hidden_proto(jn)
__MATHCALL (y0,, (_Mdouble_));
+libm_hidden_proto(y0)
__MATHCALL (y1,, (_Mdouble_));
+libm_hidden_proto(y1)
__MATHCALL (yn,, (int, _Mdouble_));
+libm_hidden_proto(yn)
#endif
__BEGIN_NAMESPACE_C99
/* Error and gamma functions. */
__MATHCALL (erf,, (_Mdouble_));
+libm_hidden_proto(erf)
__MATHCALL (erfc,, (_Mdouble_));
+libm_hidden_proto(erfc)
__MATHCALL (lgamma,, (_Mdouble_));
+libm_hidden_proto(lgamma)
__END_NAMESPACE_C99
#endif
__BEGIN_NAMESPACE_C99
/* True gamma function. */
__MATHCALL (tgamma,, (_Mdouble_));
+libm_hidden_proto(tgamma)
__END_NAMESPACE_C99
#endif
#if defined __USE_MISC || defined __USE_XOPEN
/* Obsolete alias for `lgamma'. */
__MATHCALL (gamma,, (_Mdouble_));
+libm_hidden_proto(gamma)
#endif
#ifdef __USE_MISC
`signgam'. The reentrant version instead takes a pointer and stores
the value through it. */
__MATHCALL (lgamma,_r, (_Mdouble_, int *__signgamp));
+libm_hidden_proto(lgamma_r)
#endif
/* Return the integer nearest X in the direction of the
prevailing rounding mode. */
__MATHCALL (rint,, (_Mdouble_ __x));
+libm_hidden_proto(rint)
/* Return X + epsilon if X < Y, X - epsilon if X > Y. */
__MATHCALLX (nextafter,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
+libm_hidden_proto(nextafter)
# if defined __USE_ISOC99 && !defined __LDBL_COMPAT
__MATHCALLX (nexttoward,, (_Mdouble_ __x, long double __y), (__const__));
+libm_hidden_proto(nexttoward)
# endif
/* Return the remainder of integer divison X / Y with infinite precision. */
__MATHCALL (remainder,, (_Mdouble_ __x, _Mdouble_ __y));
+libm_hidden_proto(remainder)
# if defined __USE_MISC || defined __USE_ISOC99
/* Return X times (2 to the Nth power). */
__MATHCALL (scalbn,, (_Mdouble_ __x, int __n));
+libm_hidden_proto(scalbn)
# endif
/* Return the binary exponent of X, which must be nonzero. */
__MATHDECL (int,ilogb,, (_Mdouble_ __x));
+libm_hidden_proto(ilogb)
#endif
#ifdef __USE_ISOC99
/* Return X times (2 to the Nth power). */
__MATHCALL (scalbln,, (_Mdouble_ __x, long int __n));
+libm_hidden_proto(scalbln)
/* Round X to integral value in floating-point format using current
rounding direction, but do not raise inexact exception. */
__MATHCALL (nearbyint,, (_Mdouble_ __x));
+libm_hidden_proto(nearbyint)
/* Round X to nearest integral value, rounding halfway cases away from
zero. */
__MATHCALLX (round,, (_Mdouble_ __x), (__const__));
+libm_hidden_proto(round)
/* Round X to the integral value in floating-point format nearest but
not larger in magnitude. */
__MATHCALLX (trunc,, (_Mdouble_ __x), (__const__));
+libm_hidden_proto(trunc)
/* Compute remainder of X and Y and put in *QUO a value with sign of x/y
and magnitude congruent `mod 2^n' to the magnitude of the integral
quotient x/y, with n >= 3. */
__MATHCALL (remquo,, (_Mdouble_ __x, _Mdouble_ __y, int *__quo));
+libm_hidden_proto(remquo)
/* Conversion functions. */
/* Round X to nearest integral value according to current rounding
direction. */
__MATHDECL (long int,lrint,, (_Mdouble_ __x));
+libm_hidden_proto(lrint)
__MATHDECL (long long int,llrint,, (_Mdouble_ __x));
+libm_hidden_proto(llrint)
/* Round X to nearest integral value, rounding halfway cases away from
zero. */
__MATHDECL (long int,lround,, (_Mdouble_ __x));
+libm_hidden_proto(lround)
__MATHDECL (long long int,llround,, (_Mdouble_ __x));
+libm_hidden_proto(llround)
/* Return positive difference between X and Y. */
__MATHCALL (fdim,, (_Mdouble_ __x, _Mdouble_ __y));
+libm_hidden_proto(fdim)
/* Return maximum numeric value from X and Y. */
__MATHCALL (fmax,, (_Mdouble_ __x, _Mdouble_ __y));
+libm_hidden_proto(fmax)
/* Return minimum numeric value from X and Y. */
__MATHCALL (fmin,, (_Mdouble_ __x, _Mdouble_ __y));
+libm_hidden_proto(fmin)
/* Classify given number. */
__MATHDECL_1 (int, __fpclassify,, (_Mdouble_ __value))
__attribute__ ((__const__));
+libm_hidden_proto(__fpclassify)
/* Test for negative number. */
__MATHDECL_1 (int, __signbit,, (_Mdouble_ __value))
__attribute__ ((__const__));
+libm_hidden_proto(__signbit)
/* Multiply-add function computed as a ternary operation. */
__MATHCALL (fma,, (_Mdouble_ __x, _Mdouble_ __y, _Mdouble_ __z));
+libm_hidden_proto(fma)
#endif /* Use ISO C99. */
#if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
#if defined __USE_MISC || defined __USE_XOPEN_EXTENDED
/* Return X times (2 to the Nth power). */
__MATHCALL (scalb,, (_Mdouble_ __x, _Mdouble_ __n));
+libm_hidden_proto(scalb)
#endif
s_log1p.c s_logb.c s_matherr.c s_modf.c s_nextafter.c s_round.c \
s_rint.c s_scalbn.c s_signgam.c s_significand.c s_sin.c s_tan.c \
s_tanh.c s_trunc.c w_acos.c w_acosh.c w_asin.c w_atan2.c w_atanh.c \
- w_cabs.c w_cosh.c w_drem.c w_exp.c w_fmod.c w_gamma.c w_gamma_r.c \
+ w_cabs.c w_cosh.c w_drem.c w_exp.c w_fmod.c w_gamma.c \
w_hypot.c w_j0.c w_j1.c w_jn.c w_lgamma.c w_lgamma_r.c \
w_log.c w_log10.c w_pow.c w_remainder.c w_scalb.c w_sinh.c \
w_sqrt.c nan.c carg.c s_llrint.c \
s_fpclassify.c s_fpclassifyf.c s_signbit.c s_signbitf.c \
- s_isnan.c s_isnanf.c s_isinf.c s_isinff.c \
+ s_isnan.c s_isnanf.c s_isinf.c s_isinff.c s_finitef.c \
s_fdim.c s_fma.c s_fmax.c s_fmin.c s_nearbyint.c \
s_remquo.c s_scalbln.c w_exp2.c w_tgamma.c
+# REMOVED: w_gamma_r.c
FL_MOBJ := \
acosf.o acoshf.o asinf.o asinhf.o atan2f.o atanf.o atanhf.o cbrtf.o \
ceilf.o copysignf.o cosf.o coshf.o erfcf.o erff.o exp2f.o expf.o \
#include <complex.h>
#include <math.h>
-libm_hidden_proto(atan2)
-libm_hidden_proto(carg)
-
double
carg (__complex__ double x)
{
return atan2 (__imag__ x, __real__ x);
}
-
libm_hidden_def(carg)
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(log1p)
-libm_hidden_proto(sqrt)
#ifdef __STDC__
static const double
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(fabs)
#ifdef __STDC__
static const double
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(atan)
-libm_hidden_proto(fabs)
#ifdef __STDC__
static const double
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(log1p)
#ifdef __STDC__
static const double one = 1.0, huge = 1e300;
#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;
#include "math_private.h"
libm_hidden_proto(signgam)
-
#ifdef __STDC__
//__private_extern__
double attribute_hidden __ieee754_gamma(double x)
#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);
#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);
#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
#include "math_private.h"
libm_hidden_proto(signgam)
-
#ifdef __STDC__
//__private_extern__
double attribute_hidden __ieee754_lgamma(double x)
#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
#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;
#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__
#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;
#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_cargf
-libm_hidden_proto(carg)
float cargf (float complex x)
{
return (float) carg( (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 (int) 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 (long long) llrint( (double)x );
#ifdef L_llroundf
-libm_hidden_proto(llround)
long long llroundf (float x)
{
return (long long) 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 (long) lrint( (double)x );
#ifdef L_lroundf
-libm_hidden_proto(lround)
long lroundf (float x)
{
return (long) 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 );
#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 */
#ifndef _IEEE_LIBM
-libm_hidden_proto(copysign)
-libm_hidden_proto(matherr)
-libm_hidden_proto(rint)
#ifndef _USE_WRITE
#include <stdio.h> /* fputs(), stderr */
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(fabs)
#ifdef __STDC__
static const double
}
return NAN;
}
+libm_hidden_def(nan)
+libm_hidden_proto(nanf)
float nanf (const char *tagp)
{
if (tagp[0] != '\0') {
}
return NAN;
}
+libm_hidden_def(nanf)
-#if 0
+#if defined __UCLIBC_HAS_LONG_DOUBLE_MATH__
long double nanl (const char *tagp)
{
if (tagp[0] != '\0') {
}
return NAN;
}
+libm_hidden_def(nanl)
#endif
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(log1p)
-libm_hidden_proto(fabs)
#ifdef __STDC__
static const double
ln2 = 6.93147180559945286227e-01, /* 0x3FE62E42, 0xFEFA39EF */
huge= 1.00000000000000000000e+300;
-libm_hidden_proto(asinh)
#ifdef __STDC__
double asinh(double x)
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(fabs)
#ifdef __STDC__
static const double atanhi[] = {
1.62858201153657823623e-02, /* 0x3F90AD3A, 0xE322DA11 */
};
-libm_hidden_proto(atan)
#ifdef __STDC__
static const double
#else
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
static double huge = 1.0e300;
#endif
-libm_hidden_proto(ceil)
#ifdef __STDC__
double ceil(double x)
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(copysign)
#ifdef __STDC__
double copysign(double x, double y)
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(cos)
#ifdef __STDC__
double cos(double x)
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(fabs)
#ifdef __STDC__
static const double
sb6 = 4.74528541206955367215e+02, /* 0x407DA874, 0xE79FE763 */
sb7 = -2.24409524465858183362e+01; /* 0xC03670E2, 0x42712D62 */
-libm_hidden_proto(erf)
#ifdef __STDC__
double erf(double x)
#else
}
libm_hidden_def(erf)
-libm_hidden_proto(erfc)
#ifdef __STDC__
double erfc(double x)
#else
Q4 = 4.00821782732936239552e-06, /* 3ED0CFCA 86E65239 */
Q5 = -2.01099218183624371326e-07; /* BE8AFDB7 6E09C32D */
-libm_hidden_proto(expm1)
#ifdef __STDC__
double expm1(double x)
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(fabs)
#ifdef __STDC__
double fabs(double x)
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(fdim)
#ifdef __STDC__
double fdim(double x, double y)
#else
* ====================================================
*/
-#if defined(LIBM_SCCS) && !defined(lint)
-static char rcsid[] = "$NetBSD: s_finite.c,v 1.8 1995/05/10 20:47:17 jtc Exp $";
-#endif
-
/*
* finite(x) returns 1 is x is finite, else 0;
* no branching!
#include "math.h"
#include "math_private.h"
-#ifdef __STDC__
- int __finite(double x)
-#else
- int __finite(x)
- double x;
-#endif
+int __finite(double x)
{
int32_t hx;
GET_HIGH_WORD(hx,x);
return (int)((u_int32_t)((hx&0x7fffffff)-0x7ff00000)>>31);
}
-libm_hidden_proto(finite)
-strong_alias(__finite,finite)
-libm_hidden_def(finite)
+libm_hidden_def(__finite)
+weak_alias(__finite,finite)
+libm_hidden_weak(finite)
--- /dev/null
+/* s_finitef.c -- float version of s_finite.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+/*
+ * finitef(x) returns 1 is x is finite, else 0;
+ * no branching!
+ */
+
+#include "math.h"
+#include "math_private.h"
+
+libm_hidden_proto(__finitef)
+int __finitef(float x)
+{
+ int32_t ix;
+ GET_FLOAT_WORD(ix,x);
+ return (int)((u_int32_t)((ix&0x7fffffff)-0x7f800000)>>31);
+}
+libm_hidden_def(__finitef)
+strong_alias(__finitef,finitef)
static double huge = 1.0e300;
#endif
-libm_hidden_proto(floor)
#ifdef __STDC__
double floor(double x)
#else
#include <math.h>
+libm_hidden_proto(__fma)
double
__fma (double x, double y, double z)
{
return (x * y) + z;
}
-weak_alias (__fma, fma)
-
-#ifdef NO_LONG_DOUBLE
-strong_alias (__fma, __fmal)
-weak_alias (__fmal, fmal)
-#endif
+libm_hidden_def(__fma)
+strong_alias (__fma, fma)
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(fmax)
#ifdef __STDC__
double fmax(double x, double y)
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(fmin)
#ifdef __STDC__
double fmin(double x, double y)
#else
#include "math_private.h"
-libm_hidden_proto (__fpclassify)
int
__fpclassify (double x)
{
02111-1307 USA. */
#include <math.h>
-
#include "math_private.h"
-
libm_hidden_proto (__fpclassifyf)
int
__fpclassifyf (float x)
#endif
two54 = 1.80143985094819840000e+16; /* 0x43500000, 0x00000000 */
-libm_hidden_proto(frexp)
#ifdef __STDC__
double frexp(double x, int *eptr)
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(ilogb)
#ifdef __STDC__
int ilogb(double x)
#else
* Public domain.
*/
-#if defined(LIBM_SCCS) && !defined(lint)
-static char rcsid[] = "$NetBSD: s_isinf.c,v 1.3 1995/05/11 23:20:14 jtc Exp $";
-#endif
-
/*
* isinf(x) returns 1 is x is inf, -1 if x is -inf, else 0;
* no branching!
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(__isinf)
int
__isinf (double x)
{
lx |= -lx;
return ~(lx >> 31) & (hx >> 30);
}
-libm_hidden_def (__isinf)
+libm_hidden_def(__isinf)
weak_alias (__isinf, isinf)
-#ifdef NO_LONG_DOUBLE
-strong_alias (__isinf, __isinfl)
-weak_alias (__isinf, isinfl)
-#endif
+libm_hidden_weak(isinf)
* Public domain.
*/
-#if defined(LIBM_SCCS) && !defined(lint)
-static char rcsid[] = "$NetBSD: s_isinff.c,v 1.3 1995/05/11 23:20:21 jtc Exp $";
-#endif
-
/*
* isinff(x) returns 1 if x is inf, -1 if x is -inf, else 0;
* no branching!
t |= -t;
return ~(t >> 31) & (ix >> 30);
}
-libm_hidden_def (__isinff)
-weak_alias (__isinff, isinff)
+libm_hidden_def(__isinff)
+strong_alias (__isinff, isinff)
* ====================================================
*/
-#if defined(LIBM_SCCS) && !defined(lint)
-static char rcsid[] = "$NetBSD: s_isnan.c,v 1.8 1995/05/10 20:47:36 jtc Exp $";
-#endif
-
/*
* isnan(x) returns 1 is x is nan, else 0;
* no branching!
#include "math.h"
#include "math_private.h"
-libm_hidden_proto (__isnan)
#ifdef __STDC__
int __isnan(double x)
#else
hx = 0x7ff00000 - hx;
return (int)(((u_int32_t)hx)>>31);
}
-libm_hidden_def (__isnan)
-weak_alias (__isnan, isnan)
-#ifdef NO_LONG_DOUBLE
-strong_alias (__isnan, __isnanl)
-weak_alias (__isnan, isnanl)
-#endif
+libm_hidden_def(__isnan)
+weak_alias(__isnan,isnan)
+libm_hidden_weak(isnan)
* ====================================================
*/
-#if defined(LIBM_SCCS) && !defined(lint)
-static char rcsid[] = "$NetBSD: s_isnanf.c,v 1.4 1995/05/10 20:47:38 jtc Exp $";
-#endif
-
/*
* isnanf(x) returns 1 is x is nan, else 0;
* no branching!
#include "math_private.h"
libm_hidden_proto (__isnanf)
-#ifdef __STDC__
- int __isnanf(float x)
-#else
- int __isnanf(x)
- float x;
-#endif
+int __isnanf(float x)
{
int32_t ix;
GET_FLOAT_WORD(ix,x);
#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
-4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
};
-libm_hidden_proto(llrint)
-
long long int
llrint (double x)
{
#include "math_private.h"
-libm_hidden_proto(llround)
long long int
llround (double x)
{
static double zero = 0.0;
#endif
-libm_hidden_proto(log1p)
#ifdef __STDC__
double log1p(double x)
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(fabs)
-libm_hidden_proto(logb)
#ifdef __STDC__
double logb(double x)
#else
};
-libm_hidden_proto(lrint)
long int
lrint (double x)
{
#include "math_private.h"
-libm_hidden_proto(lround)
long int
lround (double x)
{
#ifndef _IEEE_LIBM
-libm_hidden_proto(matherr)
#ifdef __STDC__
int matherr(struct exception *x)
#else
static double one = 1.0;
#endif
-libm_hidden_proto(modf)
#ifdef __STDC__
double modf(double x, double *iptr)
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(nearbyint)
#ifdef __STDC__
double nearbyint(double x)
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(nextafter)
#ifdef __STDC__
double nextafter(double x, double y)
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(remquo)
#ifdef __STDC__
double remquo(double x, double y, int *quo) /* wrapper remquo */
#else
-4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
};
-libm_hidden_proto(rint)
#ifdef __STDC__
double rint(double x)
#else
static const double huge = 1.0e300;
-libm_hidden_proto(round)
double
round (double x)
{
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(scalbln)
#ifdef __STDC__
static const double
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(copysign)
#ifdef __STDC__
static const double
huge = 1.0e+300,
tiny = 1.0e-300;
-libm_hidden_proto(scalbn)
#ifdef __STDC__
double scalbn (double x, int n)
#else
#include "math_private.h"
-libm_hidden_proto(__signbit)
int
__signbit (double x)
{
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(ilogb)
#ifdef __STDC__
double significand(double x)
{
return __ieee754_scalb(x,(double) -ilogb(x));
}
+libm_hidden_def(significand)
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(sin)
#ifdef __STDC__
double sin(double x)
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(tan)
#ifdef __STDC__
double tan(double x)
#else
#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;
static double one=1.0, two=2.0, tiny = 1.0e-300;
#endif
-libm_hidden_proto(tanh)
#ifdef __STDC__
double tanh(double x)
#else
#include "math_private.h"
-libm_hidden_proto(trunc)
double
trunc (double x)
{
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(acos)
#ifdef __STDC__
double acos(double x) /* wrapper acos */
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(acosh)
#ifdef __STDC__
double acosh(double x) /* wrapper acosh */
#else
#include "math_private.h"
-libm_hidden_proto(asin)
#ifdef __STDC__
double asin(double x) /* wrapper asin */
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(atan2)
#ifdef __STDC__
double atan2(double y, double x) /* wrapper atan2 */
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(atanh)
#ifdef __STDC__
double atanh(double x) /* wrapper atanh */
#else
#include <complex.h>
#include <math.h>
-libm_hidden_proto(hypot)
double cabs(double _Complex z)
{
return hypot(__real__ z, __imag__ z);
}
+libm_hidden_def(cabs)
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(cosh)
#ifdef __STDC__
double cosh(double x) /* wrapper cosh */
#else
#include <math.h>
-libm_hidden_proto(remainder)
double drem(double x, double y)
{
return remainder(x, y);
}
+libm_hidden_def(drem)
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
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(exp2)
#ifdef __STDC__
double exp2(double x)
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(fmod)
#ifdef __STDC__
double fmod(double x, double y) /* wrapper fmod */
#else
#include "math_private.h"
libm_hidden_proto(signgam)
-
#ifdef __STDC__
double gamma(double x)
#else
return y;
#endif
}
+libm_hidden_def(gamma)
double gamma_r(double x, int *signgamp);
+libm_hidden_proto(gamma_r)
#ifdef __STDC__
double gamma_r(double x, int *signgamp) /* wrapper lgamma_r */
#else
return y;
#endif
}
+libm_hidden_def(gamma_r)
#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(j0)
#ifdef __STDC__
double y0(double x) /* wrapper y0 */
return z;
#endif
}
+libm_hidden_def(y0)
return z;
#endif
}
+libm_hidden_def(j1)
#ifdef __STDC__
double y1(double x) /* wrapper y1 */
return z;
#endif
}
+libm_hidden_def(y1)
return z;
#endif
}
+libm_hidden_def(jn)
#ifdef __STDC__
double yn(int n, double x) /* wrapper yn */
return z;
#endif
}
+libm_hidden_def(yn)
#include "math_private.h"
libm_hidden_proto(signgam)
-
-libm_hidden_proto(lgamma)
#ifdef __STDC__
double lgamma(double x)
#else
#include "math.h"
#include "math_private.h"
-
#ifdef __STDC__
double lgamma_r(double x, int *signgamp) /* wrapper lgamma_r */
#else
return y;
#endif
}
+libm_hidden_def(lgamma_r)
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(log)
#ifdef __STDC__
double log(double x) /* wrapper log */
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(log10)
#ifdef __STDC__
double log10(double x) /* wrapper log10 */
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(pow)
#ifdef __STDC__
double pow(double x, double y) /* wrapper pow */
#else
#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(scalb)
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(sinh)
#ifdef __STDC__
double sinh(double x) /* wrapper sinh */
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(sqrt)
#ifdef __STDC__
double sqrt(double x) /* wrapper sqrt */
#else
#include "math.h"
#include "math_private.h"
-libm_hidden_proto(tgamma)
+libm_hidden_proto(signgam)
#ifdef __STDC__
double tgamma(double x)
#else