[gentoo-commits] gentoo commit in src/patchsets/uclibc/0.9.30/math/libm: e_log2.c ldouble_wrappers.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_log2.c w_nexttoward.c w_tgamma.c

[Ned Ludd (solar)]

solar       08/09/23 20:14:03

  Added:                e_log2.c ldouble_wrappers.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_log2.c w_nexttoward.c
                        w_tgamma.c
  Log:
  - import initial gentoo patchset for 0.9.30_rc1

Revision  Changes    Path
1.1                  src/patchsets/uclibc/0.9.30/math/libm/e_log2.c

file : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/e_log2.c?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/e_log2.c?rev=1.1&content-type=text/plain

Index: e_log2.c
===================================================================
/* Adapted for log2 by Ulrich Drepper <drepper@××××××.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.
 * ====================================================
 */

/* __ieee754_log2(x)
 * Return the logarithm to base 2 of x
 *
 * Method :
 *   1. Argument Reduction: find k and f such that
 *			x = 2^k * (1+f),
 *	   where  sqrt(2)/2 < 1+f < sqrt(2) .
 *
 *   2. Approximation of log(1+f).
 *	Let s = f/(2+f) ; based on log(1+f) = log(1+s) - log(1-s)
 *		 = 2s + 2/3 s**3 + 2/5 s**5 + .....,
 *	     	 = 2s + s*R
 *      We use a special Reme algorithm on [0,0.1716] to generate
 * 	a polynomial of degree 14 to approximate R The maximum error
 *	of this polynomial approximation is bounded by 2**-58.45. In
 *	other words,
 *		        2      4      6      8      10      12      14
 *	    R(z) ~ Lg1*s +Lg2*s +Lg3*s +Lg4*s +Lg5*s  +Lg6*s  +Lg7*s
 *  	(the values of Lg1 to Lg7 are listed in the program)
 *	and
 *	    |      2          14          |     -58.45
 *	    | Lg1*s +...+Lg7*s    -  R(z) | <= 2
 *	    |                             |
 *	Note that 2s = f - s*f = f - hfsq + s*hfsq, where hfsq = f*f/2.
 *	In order to guarantee error in log below 1ulp, we compute log
 *	by
 *		log(1+f) = f - s*(f - R)	(if f is not too large)
 *		log(1+f) = f - (hfsq - s*(hfsq+R)).	(better accuracy)
 *
 *	3. Finally,  log(x) = k + log(1+f).
 *			    = k+(f-(hfsq-(s*(hfsq+R))))
 *
 * Special cases:
 *	log2(x) is NaN with signal if x < 0 (including -INF) ;
 *	log2(+INF) is +INF; log(0) is -INF with signal;
 *	log2(NaN) is that NaN with no signal.
 *
 * Constants:
 * The hexadecimal values are the intended ones for the following
 * constants. The decimal values may be used, provided that the
 * compiler will convert from decimal to binary accurately enough
 * to produce the hexadecimal values shown.
 */

#include "math.h"
#include "math_private.h"

#ifdef __STDC__
static const double
#else
static double
#endif
ln2 = 0.69314718055994530942,
two54   =  1.80143985094819840000e+16,  /* 43500000 00000000 */
Lg1 = 6.666666666666735130e-01,  /* 3FE55555 55555593 */
Lg2 = 3.999999999940941908e-01,  /* 3FD99999 9997FA04 */
Lg3 = 2.857142874366239149e-01,  /* 3FD24924 94229359 */
Lg4 = 2.222219843214978396e-01,  /* 3FCC71C5 1D8E78AF */
Lg5 = 1.818357216161805012e-01,  /* 3FC74664 96CB03DE */
Lg6 = 1.531383769920937332e-01,  /* 3FC39A09 D078C69F */
Lg7 = 1.479819860511658591e-01;  /* 3FC2F112 DF3E5244 */

#ifdef __STDC__
static const double zero   =  0.0;
#else
static double zero   =  0.0;
#endif

#ifdef __STDC__
	double __ieee754_log2(double x)
#else
	double __ieee754_log2(x)
	double x;
#endif
{
	double hfsq,f,s,z,R,w,t1,t2,dk;
	int32_t k,hx,i,j;
	u_int32_t lx;

	EXTRACT_WORDS(hx,lx,x);

	k=0;
	if (hx < 0x00100000) {			/* x < 2**-1022  */
	    if (((hx&0x7fffffff)|lx)==0)
		return -two54/(x-x);		/* log(+-0)=-inf */
	    if (hx<0) return (x-x)/(x-x);	/* log(-#) = NaN */
	    k -= 54; x *= two54; /* subnormal number, scale up x */
	    GET_HIGH_WORD(hx,x);
	}
	if (hx >= 0x7ff00000) return x+x;
	k += (hx>>20)-1023;
	hx &= 0x000fffff;
	i = (hx+0x95f64)&0x100000;
	SET_HIGH_WORD(x,hx|(i^0x3ff00000));	/* normalize x or x/2 */
	k += (i>>20);
	dk = (double) k;
	f = x-1.0;
	if((0x000fffff&(2+hx))<3) {	/* |f| < 2**-20 */
	    if(f==zero) return dk;
	    R = f*f*(0.5-0.33333333333333333*f);
	    return dk-(R-f)/ln2;
	}
 	s = f/(2.0+f);
	z = s*s;
	i = hx-0x6147a;
	w = z*z;
	j = 0x6b851-hx;
	t1= w*(Lg2+w*(Lg4+w*Lg6));
	t2= z*(Lg1+w*(Lg3+w*(Lg5+w*Lg7)));
	i |= j;
	R = t2+t1;
	if(i>0) {
	    hfsq=0.5*f*f;
	    return dk-((hfsq-(s*(hfsq+R)))-f)/ln2;
	} else {
	    return dk-((s*(f-R))-f)/ln2;
	}
}



1.1                  src/patchsets/uclibc/0.9.30/math/libm/ldouble_wrappers.c

file : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/ldouble_wrappers.c?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/ldouble_wrappers.c?rev=1.1&content-type=text/plain

Index: ldouble_wrappers.c
===================================================================
/* vi: set sw=4 ts=4: */
/*
 * Wrapper functions implementing all the long double math functions
 * defined by SuSv3 by actually calling the double version of
 * each function and then casting the result back to a long double
 * to return to the user.
 *
 * Copyright (C) 2005 by Erik Andersen <andersen@××××××.org>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Library General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include "math.h"

/* Implement the following, as defined by SuSv3 */
#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);
long double fabsl(long double);
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 nearbyintl(long double);
long double nextafterl(long double, 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

#ifdef L_acoshl
long double acoshl (long double x)
{
	return (long double) acosh( (double)x );
}
#endif


#ifdef L_acosl
long double acosl (long double x)
{
	return (long double) acos( (double)x );
}
#endif


#ifdef L_asinhl
long double asinhl (long double x)
{
	return (long double) asinh( (double)x );
}
#endif


#ifdef L_asinl
long double asinl (long double x)
{
	return (long double) asin( (double)x );
}
#endif


#ifdef L_atan2l
long double atan2l (long double x, long double y)
{
	return (long double) atan2( (double)x, (double)y );
}
#endif


#ifdef L_atanhl
long double atanhl (long double x)
{
	return (long double) atanh( (double)x );
}
#endif


#ifdef L_atanl
long double atanl (long double x)
{
	return (long double) atan( (double)x );
}
#endif


#ifdef L_cbrtl
long double cbrtl (long double x)
{
	return (long double) cbrt( (double)x );
}
#endif


#ifdef L_ceill
long double ceill (long double x)
{
	return (long double) ceil( (double)x );
}
#endif


#ifdef L_copysignl
long double copysignl (long double x, long double y)
{
	return (long double) copysign( (double)x, (double)y );
}
#endif


#ifdef L_coshl
long double coshl (long double x)
{
	return (long double) cosh( (double)x );
}
#endif


#ifdef L_cosl
long double cosl (long double x)
{
	return (long double) cos( (double)x );
}
#endif


#ifdef L_erfcl
long double erfcl (long double x)
{
	return (long double) erfc( (double)x );
}
#endif


#ifdef L_erfl
long double erfl (long double x)
{
	return (long double) erf( (double)x );
}
#endif


#ifdef L_exp2l
long double exp2l (long double x)
{
	return (long double) exp2( (double)x );
}
#endif


#ifdef L_expl
long double expl (long double x)
{
	return (long double) exp( (double)x );
}
#endif


#ifdef L_expm1l
long double expm1l (long double x)
{
	return (long double) expm1( (double)x );
}
#endif


#ifdef L_fabsl
long double fabsl (long double x)
{
	return (long double) fabs( (double)x );
}
#endif


#ifdef L_fdiml
long double fdiml (long double x, long double y)
{
	return (long double) fdim( (double)x, (double)y );
}
#endif


#ifdef L_floorl
long double floorl (long double x)
{
	return (long double) floor( (double)x );
}
#endif


#ifdef L_fmal
long double fmal (long double x, long double y, long double z)
{
	return (long double) fma( (double)x, (double)y, (double)z );
}
#endif


#ifdef L_fmaxl
long double fmaxl (long double x, long double y)
{
	return (long double) fmax( (double)x, (double)y );
}
#endif


#ifdef L_fminl
long double fminl (long double x, long double y)
{
	return (long double) fmin( (double)x, (double)y );
}
#endif


#ifdef L_fmodl
long double fmodl (long double x, long double y)
{
	return (long double) fmod( (double)x, (double)y );
}
#endif


#ifdef L_frexpl
long double frexpl (long double x, int *exp)
{
	return (long double) frexp( (double)x, exp );
}
#endif


#ifdef L_hypotl
long double hypotl (long double x, long double y)
{
	return (long double) hypot( (double)x, (double)y );
}
#endif


#ifdef L_ilogbl
int ilogbl (long double x)
{
	return (long double) ilogb( (double)x );
}
#endif


#ifdef L_ldexpl
long double ldexpl (long double x, int exp)
{
	return (long double) ldexp( (double)x, exp );
}
#endif


#ifdef L_lgammal
long double lgammal (long double x)
{
	return (long double) lgamma( (double)x );
}
#endif


#ifdef L_llrintl
long long llrintl (long double x)
{
	return (long double) llrint( (double)x );
}
#endif


#ifdef L_llroundl
long long llroundl (long double x)
{
	return (long double) llround( (double)x );
}
#endif

#ifdef L_log10l
long double log10l (long double x)
{
	return (long double) log10( (double)x );
}
#endif


#ifdef L_log1pl
long double log1pl (long double x)
{
	return (long double) log1p( (double)x );
}
#endif


#ifdef L_log2l
long double log2l (long double x)
{
	return (long double) log2( (double)x );
}
#endif


#ifdef L_logbl
long double logbl (long double x)
{
	return (long double) logb( (double)x );
}
#endif


#ifdef L_logl
long double logl (long double x)
{
	return (long double) log( (double)x );
}
#endif


#ifdef L_lrintl
long lrintl (long double x)
{
	return (long double) lrint( (double)x );
}
#endif


#ifdef L_lroundl
long lroundl (long double x)
{
	return (long double) lround( (double)x );
}
#endif


#ifdef L_modfl
long double modfl (long double x, long double *iptr)
{
	double y, result;
	result = modf ( x, &y );
	*iptr = (long double)y;
	return (long double) result;

}
#endif


#ifdef L_nearbyintl
long double nearbyintl (long double x)
{
	return (long double) nearbyint( (double)x );
}
#endif


#ifdef L_nextafterl
long double nextafterl (long double x, long double y)
{
	return (long double) nextafter( (double)x, (double)y );
}
#endif


#ifdef L_nexttowardl
long double nexttowardl (long double x, long double y)
{
	return (long double) nexttoward( (double)x, (double)y );
}
#endif


#ifdef L_powl
long double powl (long double x, long double y)
{
	return (long double) pow( (double)x, (double)y );
}
#endif


#ifdef L_remainderl
long double remainderl (long double x, long double y)
{
	return (long double) remainder( (double)x, (double)y );
}
#endif


#ifdef L_remquol
long double remquol (long double x, long double y, int *quo)
{
	return (long double) remquo( (double)x, (double)y, quo );
}
#endif


#ifdef L_rintl
long double rintl (long double x)
{
	return (long double) rint( (double)x );
}
#endif


#ifdef L_roundl
long double roundl (long double x)
{
	return (long double) round( (double)x );
}
#endif


#ifdef L_scalblnl
long double scalblnl (long double x, long exp)
{
	return (long double) scalbln( (double)x, exp );
}
#endif


#ifdef L_scalbnl
long double scalbnl (long double x, int exp)
{
	return (long double) scalbn( (double)x, exp );
}
#endif


#ifdef L_sinhl
long double sinhl (long double x)
{
	return (long double) sinh( (double)x );
}
#endif


#ifdef L_sinl
long double sinl (long double x)
{
	return (long double) sin( (double)x );
}
#endif


#ifdef L_sqrtl
long double sqrtl (long double x)
{
	return (long double) sqrt( (double)x );
}
#endif


#ifdef L_tanhl
long double tanhl (long double x)
{
	return (long double) tanh( (double)x );
}
#endif


#ifdef L_tanl
long double tanl (long double x)
{
	return (long double) tan( (double)x );
}
#endif


#ifdef L_tgammal
long double tgammal (long double x)
{
	return (long double) tgamma( (double)x );
}
#endif


#ifdef L_truncl
long double truncl (long double x)
{
	return (long double) trunc( (double)x );
}
#endif




1.1                  src/patchsets/uclibc/0.9.30/math/libm/s_fdim.c

file : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/s_fdim.c?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/s_fdim.c?rev=1.1&content-type=text/plain

Index: s_fdim.c
===================================================================
/* Copyright (C) 2002 by  Red Hat, Incorporated. All rights reserved.
 *
 * Permission to use, copy, modify, and distribute this software
 * is freely granted, provided that this notice is preserved.
 */

#include "math.h"
#include "math_private.h"

libm_hidden_proto(fdim)
#ifdef __STDC__
	double fdim(double x, double y)
#else
	double fdim(x,y)
	double x;
	double y;
#endif
{
  int c = __fpclassify(x);
  if (c == FP_NAN || c == FP_INFINITE)
    return HUGE_VAL;

  return x > y ? x - y : 0.0;
}
libm_hidden_def(fdim)



1.1                  src/patchsets/uclibc/0.9.30/math/libm/s_fma.c

file : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/s_fma.c?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/s_fma.c?rev=1.1&content-type=text/plain

Index: s_fma.c
===================================================================
#include "math.h"
#include "math_private.h"

libm_hidden_proto(fma)
#ifdef __STDC__
	double fma(double x, double y, double z)
#else
	double fma(x,y)
	double x;
	double y;
        double z;
#endif
{
  /* Implementation defined. */
  return (x * y) + z;
}
libm_hidden_def(fma)



1.1                  src/patchsets/uclibc/0.9.30/math/libm/s_fmax.c

file : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/s_fmax.c?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/s_fmax.c?rev=1.1&content-type=text/plain

Index: s_fmax.c
===================================================================
/* Copyright (C) 2002 by  Red Hat, Incorporated. All rights reserved.
 *
 * Permission to use, copy, modify, and distribute this software
 * is freely granted, provided that this notice is preserved.
 */

#include "math.h"
#include "math_private.h"

libm_hidden_proto(fmax)
#ifdef __STDC__
	double fmax(double x, double y)
#else
	double fmax(x,y)
	double x;
	double y;
#endif
{
  if (__fpclassify(x) == FP_NAN)
    return x;
  if (__fpclassify(y) == FP_NAN)
    return y;
  
  return x > y ? x : y;
}
libm_hidden_def(fmax)



1.1                  src/patchsets/uclibc/0.9.30/math/libm/s_fmin.c

file : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/s_fmin.c?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/s_fmin.c?rev=1.1&content-type=text/plain

Index: s_fmin.c
===================================================================
/* Copyright (C) 2002 by  Red Hat, Incorporated. All rights reserved.
 *
 * Permission to use, copy, modify, and distribute this software
 * is freely granted, provided that this notice is preserved.
 */

#include "math.h"
#include "math_private.h"

libm_hidden_proto(fmin)
#ifdef __STDC__
	double fmin(double x, double y)
#else
	double fmin(x,y)
	double x;
	double y;
#endif
{
  if (__fpclassify(x) == FP_NAN)
    return x;
  if (__fpclassify(y) == FP_NAN)
    return y;
  
  return x < y ? x : y;
}
libm_hidden_def(fmin)



1.1                  src/patchsets/uclibc/0.9.30/math/libm/s_nearbyint.c

file : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/s_nearbyint.c?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/s_nearbyint.c?rev=1.1&content-type=text/plain

Index: s_nearbyint.c
===================================================================
/*
 * ====================================================
 * 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.
 * ====================================================
 */

#include "math.h"
#include "math_private.h"

libm_hidden_proto(nearbyint)
#ifdef __STDC__
	double nearbyint(double x)
#else
	double nearbyint(x)
	double x;
#endif
{
  return rint(x);
}
libm_hidden_def(nearbyint)



1.1                  src/patchsets/uclibc/0.9.30/math/libm/s_remquo.c

file : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/s_remquo.c?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/s_remquo.c?rev=1.1&content-type=text/plain

Index: s_remquo.c
===================================================================
/* Copyright (C) 2002 by  Red Hat, Incorporated. All rights reserved.
 *
 * Permission to use, copy, modify, and distribute this software
 * is freely granted, provided that this notice is preserved.
 */

#include "math.h"
#include "math_private.h"

libm_hidden_proto(remquo)
#ifdef __STDC__
	double remquo(double x, double y, int *quo)	/* wrapper remquo */
#else
	double remquo(x,y,quo)			/* wrapper remquo */
	double x,y;
        int *quo;
#endif
{
        int signx, signy, signres;
        int mswx;
        int mswy;
        double x_over_y;

        GET_HIGH_WORD(mswx, x);
        GET_HIGH_WORD(mswy, y);

        signx = (mswx & 0x80000000) >> 31;
        signy = (mswy & 0x80000000) >> 31;

        signres = (signx ^ signy) ? -1 : 1;

        x_over_y = fabs(x / y);

        *quo = signres * (lrint(x_over_y) & 0x7f);

        return remainder(x,y);
}
libm_hidden_def(remquo)



1.1                  src/patchsets/uclibc/0.9.30/math/libm/s_scalbln.c

file : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/s_scalbln.c?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/s_scalbln.c?rev=1.1&content-type=text/plain

Index: s_scalbln.c
===================================================================
/* @(#)s_scalbn.c 5.1 93/09/24 */
/*
 * ====================================================
 * 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.
 * ====================================================
 */

/*
 * scalbn (double x, int n)
 * scalbn(x,n) returns x* 2**n  computed by  exponent
 * manipulation rather than by actually performing an
 * exponentiation or a multiplication.
 */

#include "math.h"
#include "math_private.h"

libm_hidden_proto(scalbln)
#ifdef __STDC__
static const double
#else
static double
#endif
two54   =  1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
twom54  =  5.55111512312578270212e-17, /* 0x3C900000, 0x00000000 */
huge   = 1.0e+300,
tiny   = 1.0e-300;

#ifdef __STDC__
	double scalbln (double x, long int n)
#else
	double scalbln (x,n)
	double x; long int n;
#endif
{
	int32_t k,hx,lx;
	EXTRACT_WORDS(hx,lx,x);
        k = (hx&0x7ff00000)>>20;		/* extract exponent */
        if (k==0) {				/* 0 or subnormal x */
            if ((lx|(hx&0x7fffffff))==0) return x; /* +-0 */
	    x *= two54;
	    GET_HIGH_WORD(hx,x);
	    k = ((hx&0x7ff00000)>>20) - 54;
	    }
        if (k==0x7ff) return x+x;		/* NaN or Inf */
        k = k+n;
        if (n> 50000 || k >  0x7fe)
	  return huge*copysign(huge,x); /* overflow  */
	if (n< -50000) return tiny*copysign(tiny,x); /*underflow*/
        if (k > 0) 				/* normal result */
	    {SET_HIGH_WORD(x,(hx&0x800fffff)|(k<<20)); return x;}
        if (k <= -54)
	  return tiny*copysign(tiny,x); 	/*underflow*/
        k += 54;				/* subnormal result */
	SET_HIGH_WORD(x,(hx&0x800fffff)|(k<<20));
        return x*twom54;
}
libm_hidden_def(scalbln)



1.1                  src/patchsets/uclibc/0.9.30/math/libm/w_exp2.c

file : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/w_exp2.c?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/w_exp2.c?rev=1.1&content-type=text/plain

Index: w_exp2.c
===================================================================

/* @(#)w_exp2.c 5.1 93/09/24 */
/*
 * ====================================================
 * 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.
 * ====================================================
 */

#include "math.h"
#include "math_private.h"

libm_hidden_proto(exp2)
#ifdef __STDC__
	double exp2(double x)
#else
	double exp2(x)
	double x;
#endif
{
  return pow(2.0, x);
}
libm_hidden_def(exp2)



1.1                  src/patchsets/uclibc/0.9.30/math/libm/w_log2.c

file : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/w_log2.c?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/w_log2.c?rev=1.1&content-type=text/plain

Index: w_log2.c
===================================================================
/*
 * wrapper log2(X)
 */

#include "math.h"
#include "math_private.h"

libm_hidden_proto(log2)
double log2 (double x)	/* wrapper log2 */
{
#ifdef _IEEE_LIBM
  return __ieee754_log2 (x);
#else
  double z;
  z = __ieee754_log2 (x);
  if (_LIB_VERSION == _IEEE_ || __isnan (x)) return z;
  if (x <= 0.0)
    {
      if (x == 0.0)
	return __kernel_standard (x, x, 48); /* log2 (0) */
      else
	return __kernel_standard (x, x, 49); /* log2 (x < 0) */
    }
  else
    return z;
#endif
}
libm_hidden_def(log2)



1.1                  src/patchsets/uclibc/0.9.30/math/libm/w_nexttoward.c

file : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/w_nexttoward.c?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/w_nexttoward.c?rev=1.1&content-type=text/plain

Index: w_nexttoward.c
===================================================================
/* vi: set sw=4 ts=4: */
/*
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Library General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include "math.h"
#include "math_private.h"

libm_hidden_proto(nexttoward)
#ifdef __STDC__
double nexttoward(double x, long double y)
#else
double nexttoward(x,y)
	double x; long double y;
#endif
{
	return (double) nextafter( (double)x, (double)y );
}
libm_hidden_def(nexttoward)



1.1                  src/patchsets/uclibc/0.9.30/math/libm/w_tgamma.c

file : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/w_tgamma.c?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/uclibc/0.9.30/math/libm/w_tgamma.c?rev=1.1&content-type=text/plain

Index: w_tgamma.c
===================================================================
/* @(#)w_gamma.c 5.1 93/09/24 */
/*
 * ====================================================
 * 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.
 * ====================================================
 */

/* double gamma(double x)
 * Return  the logarithm of the Gamma function of x or the Gamma function of x,
 * depending on the library mode.
 */

#include "math.h"
#include "math_private.h"

libm_hidden_proto(tgamma)
#ifdef __STDC__
	double tgamma(double x)
#else
	double tgamma(x)
	double x;
#endif
{
        double y;
	int local_signgam;
	y = __ieee754_gamma_r(x,&local_signgam);
	if (local_signgam < 0) y = -y;
#ifdef _IEEE_LIBM
	return y;
#else
	if(_LIB_VERSION == _IEEE_) return y;

	if(!finite(y)&&finite(x)) {
	  if(floor(x)==x&&x<=0.0)
	    return __kernel_standard(x,x,41); /* tgamma pole */
	  else
	    return __kernel_standard(x,x,40); /* tgamma overflow */
	}
	return y;
#endif
}
libm_hidden_def(tgamma)