Mail Archives: cygwin/2002/12/21/14:33:19
------=_NextPart_000_0015_01C2A8DA.D878AF80
Content-Type: text/plain;
charset="iso-8859-1"
Content-Transfer-Encoding: 7bit
----- Original Message -----
From: "Mikhail Teterin" <mi AT corbulon DOT video-collage DOT com>
To: "Timothy C Prince" <tprince AT myrealbox DOT com>
Cc: <cygwin AT cygwin DOT com>
Sent: Saturday, December 21, 2002 6:47 AM
Subject: Re: poor performance -- is Cygwin to blame?..
> > In my experience with MPI programs, comparing cygwin and linux,
> > message passing takes longer under cygwin, but the time may be made up
> > elsewhere, if the compilation is truly similar.
> >
> > You mention that considerable time is spent in log(), pow(), exp()
> > but leave us guessing how you implemented them.
>
> I did not implement them. They are from whatever -lm means on Cygwin. I
> use them to compute my own formula repeatedly for hundreds of different
> vectors.
>
> > Then you imply that you think cygwin, rather than your math functions,
> > is the speed determining factor, without giving us a means to judge.
>
> They are not mine. There must be a misunderstanding...
>
> > The glibc versions of these functions are much faster than the newlib
> > versions, particularly if you permit the use of <mathinline.h>.
> > Neither approach the potential of pentium4, but the simplest way to
> > speed them up on cygwin is to employ something like <mathinline.h>,
> > and to provide your own pow() (or to use a compiler and library which
> > targets pentium4).
>
> Can this be done with just CFLAGS? I really don't want to pollute my
> code with ``#ifdef CYGWIN''... Thank you,
>
You could simply add
#include <mathinline.h>
just ahead of the final #endif in whichever <math.h> file is active, and supply a mathinline.h (example attached) in the include
search path. You could add guards so that the <mathinline.h> is invoked in accordance with command line flags. See the glibc
example for which in-line functions are made to depend on -ffast-math. I have corrected some extreme value cases in my version, so
that it may not be as risky as the full glibc -ffast-math version.
------=_NextPart_000_0015_01C2A8DA.D878AF80
Content-Type: application/octet-stream;
name="mathinline.h"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: attachment;
filename="mathinline.h"
/* Inline math functions for i387.=0A=
Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc.=0A=
This file is part of the GNU C Library.=0A=
Contributed by John C. Bowman <bowman AT math DOT ualberta DOT ca>, 1995.=0A=
=0A=
The GNU C Library is free software; you can redistribute it and/or=0A=
modify it under the terms of the GNU Library General Public License as=0A=
published by the Free Software Foundation; either version 2 of the=0A=
License, or (at your option) any later version.=0A=
=0A=
The GNU C Library is distributed in the hope that it will be useful,=0A=
but WITHOUT ANY WARRANTY; without even the implied warranty of=0A=
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU=0A=
Library General Public License for more details.=0A=
=0A=
You should have received a copy of the GNU Library General Public=0A=
License along with the GNU C Library; see the file COPYING.LIB. If =
not,=0A=
write to the Free Software Foundation, Inc., 59 Temple Place - Suite =
330,=0A=
Boston, MA 02111-1307, USA. */=0A=
=0A=
#ifndef __INC_MATH_INLINE=0A=
#define __INC_MATH_INLINE=0A=
#ifndef __CONCAT=0A=
#define __CONCAT(a,b) a##b=0A=
#endif=0A=
#ifndef __USE_MISC=0A=
#define __USE_MISC=0A=
#endif=0A=
#ifndef __OPTIMIZE__=0A=
#define __OPTIMIZE__=0A=
#endif=0A=
=0A=
#ifdef __cplusplus=0A=
# define __MATH_INLINE __inline=0A=
#else=0A=
# define __MATH_INLINE extern __inline=0A=
#endif=0A=
=0A=
=0A=
#if defined __USE_ISOC9X && defined __GNUC__ && __GNUC__ >=3D 2=0A=
/* ISO C 9X defines some macros to perform unordered comparisons. The=0A=
ix87 FPU supports this with special opcodes and we should use them.=0A=
These must not be inline functions since we have to be able to handle=0A=
all floating-point types. */=0A=
# ifdef __i686__=0A=
/* For the PentiumPro and more recent processors we can provide=0A=
better code. */=0A=
# define isgreater(x, y) \=0A=
({ char __result; \=0A=
__asm__ ("fucomip %%st(1), %%st; seta %%al" \=0A=
: "=3Da" (__result) : "u" (y), "t" (x) : "cc", "st"); \=0A=
__result; })=0A=
# define isgreaterequal(x, y) \=0A=
({ char __result; \=0A=
__asm__ ("fucomip %%st(1), %%st; setae %%al" \=0A=
: "=3Da" (__result) : "u" (y), "t" (x) : "cc", "st"); \=0A=
__result; })=0A=
=0A=
# define isless(x, y) \=0A=
({ char __result; \=0A=
__asm__ ("fucomip %%st(1), %%st; seta %%al" \=0A=
: "=3Da" (__result) : "u" (x), "t" (y) : "cc", "st"); \=0A=
__result; })=0A=
=0A=
# define islessequal(x, y) \=0A=
({ char __result; \=0A=
__asm__ ("fucomip %%st(1), %%st; setae %%al" \=0A=
: "=3Da" (__result) : "u" (x), "t" (y) : "cc", "st"); \=0A=
__result; })=0A=
=0A=
# define islessgreater(x, y) \=0A=
({ char __result; \=0A=
__asm__ ("fucomip %%st(1), %%st; setne %%al" \=0A=
: "=3Da" (__result) : "u" (y), "t" (x) : "cc", "st"); \=0A=
__result; })=0A=
=0A=
# define isunordered(x, y) \=0A=
({ char __result; \=0A=
__asm__ ("fucomip %%st(1), %%st; setp %%al" \=0A=
: "=3Da" (__result) : "u" (y), "t" (x) : "cc", "st"); \=0A=
__result; })=0A=
# else=0A=
/* This is the dumb, portable code for i386 and above. */=0A=
# define isgreater(x, y) \=0A=
({ char __result; \=0A=
__asm__ ("fucompp; fnstsw; testb $0x45, %%ah; setz %%al" \=0A=
: "=3Da" (__result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \=0A=
__result; })=0A=
=0A=
# define isgreaterequal(x, y) \=0A=
({ char __result; \=0A=
__asm__ ("fucompp; fnstsw; testb $0x05, %%ah; setz %%al" \=0A=
: "=3Da" (__result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \=0A=
__result; })=0A=
=0A=
# define isless(x, y) \=0A=
({ char __result; \=0A=
__asm__ ("fucompp; fnstsw; testb $0x45, %%ah; setz %%al" \=0A=
: "=3Da" (__result) : "u" (x), "t" (y) : "cc", "st", "st(1)"); \=0A=
__result; })=0A=
=0A=
# define islessequal(x, y) \=0A=
({ char __result; \=0A=
__asm__ ("fucompp; fnstsw; testb $0x05, %%ah; setz %%al" \=0A=
: "=3Da" (__result) : "u" (x), "t" (y) : "cc", "st", "st(1)"); \=0A=
__result; })=0A=
=0A=
# define islessgreater(x, y) \=0A=
({ char __result; \=0A=
__asm__ ("fucompp; fnstsw; testb $0x44, %%ah; setz %%al" \=0A=
: "=3Da" (__result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \=0A=
__result; })=0A=
=0A=
# define isunordered(x, y) \=0A=
({ char __result; \=0A=
__asm__ ("fucompp; fnstsw; sahf; setp %%al" \=0A=
: "=3Da" (__result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \=0A=
__result; })=0A=
# endif /* __i686__ */=0A=
=0A=
/* Test for negative number. Used in the signbit() macro. */=0A=
__MATH_INLINE int=0A=
__signbitf (float __x)=0A=
{=0A=
union { float __f; int __i; } __u =3D { __f: __x }; return __u.__i < 0;=0A=
}=0A=
__MATH_INLINE int=0A=
__signbit (double __x)=0A=
{=0A=
union { double __d; int __i[2]; } __u =3D { __d: __x }; return =
__u.__i[1] < 0;=0A=
}=0A=
__MATH_INLINE int=0A=
__signbitl (long double __x)=0A=
{=0A=
union { long double __l; int __i[3]; } __u =3D { __l: __x };=0A=
return (__u.__i[2] & 0x8000) !=3D 0;=0A=
}=0A=
#endif=0A=
=0A=
=0A=
/* The gcc, version 2.7 or below, has problems with all this inlining=0A=
code. So disable it for this version of the compiler. */=0A=
#if defined __GNUC__ && (__GNUC__ > 2 || (__GNUC__ =3D=3D 2 && =
__GNUC_MINOR__ > 7))=0A=
=0A=
#if ((!defined __NO_MATH_INLINES || defined =
__LIBC_INTERNAL_MATH_INLINES) \=0A=
&& defined __OPTIMIZE__)=0A=
=0A=
/* A macro to define float, double, and long double versions of various=0A=
math functions for the ix87 FPU. FUNC is the function name (which =
will=0A=
be suffixed with f and l for the float and long double version,=0A=
respectively). OP is the name of the FPU operation. */=0A=
=0A=
#if defined __USE_MISC || defined __USE_ISOC9X=0A=
# define __inline_mathop(func, op) \=0A=
__inline_mathop_ (double, func, op) \=0A=
__inline_mathop_ (float, __CONCAT(func,f), op) \=0A=
__inline_mathop_ (long double, __CONCAT(func,l), op)=0A=
#else=0A=
# define __inline_mathop(func, op) \=0A=
__inline_mathop_ (double, func, op)=0A=
#endif=0A=
=0A=
#define __inline_mathop_(float_type, func, op) \=0A=
__inline_mathop_decl_ (float_type, func, op, "0" (__x))=0A=
=0A=
=0A=
#if defined __USE_MISC || defined __USE_ISOC9X=0A=
# define __inline_mathop_decl(func, op, params...) \=0A=
__inline_mathop_decl_ (double, func, op, params) \=0A=
__inline_mathop_decl_ (float, __CONCAT(func,f), op, params) \=0A=
__inline_mathop_decl_ (long double, __CONCAT(func,l), op, params)=0A=
#else=0A=
# define __inline_mathop_decl(func, op, params...) \=0A=
__inline_mathop_decl_ (double, func, op, params)=0A=
#endif=0A=
=0A=
#define __inline_mathop_decl_(float_type, func, op, params...) \=0A=
__MATH_INLINE float_type func (float_type); \=0A=
__MATH_INLINE float_type func (float_type __x) \=0A=
{ \=0A=
float_type __result; \=0A=
__asm (op : "=3Dt" (__result) : params); \=0A=
return __result; \=0A=
}=0A=
=0A=
=0A=
#if defined __USE_MISC || defined __USE_ISOC9X=0A=
# define __inline_mathcode(func, arg, code) \=0A=
__inline_mathcode_ (double, func, arg, code) \=0A=
__inline_mathcode_ (float, __CONCAT(func,f), arg, code) \=0A=
__inline_mathcode_ (long double, __CONCAT(func,l), arg, code)=0A=
# define __inline_mathcode2(func, arg1, arg2, code) \=0A=
__inline_mathcode2_ (double, func, arg1, arg2, code) \=0A=
__inline_mathcode2_ (float, __CONCAT(func,f), arg1, arg2, code) \=0A=
__inline_mathcode2_ (long double, __CONCAT(func,l), arg1, arg2, code)=0A=
# define __inline_mathcode3(func, arg1, arg2, arg3, code) \=0A=
__inline_mathcode3_ (double, func, arg1, arg2, arg3, code) \=0A=
__inline_mathcode3_ (float, __CONCAT(func,f), arg1, arg2, arg3, code) =
\=0A=
__inline_mathcode3_ (long double, __CONCAT(func,l), arg1, arg2, arg3, =
code)=0A=
#else=0A=
# define __inline_mathcode(func, arg, code) \=0A=
__inline_mathcode_ (double, func, (arg), code)=0A=
# define __inline_mathcode2(func, arg1, arg2, code) \=0A=
__inline_mathcode2_ (double, func, arg1, arg2, code)=0A=
# define __inline_mathcode3(func, arg1, arg2, arg3, code) \=0A=
__inline_mathcode3_ (double, func, arg1, arg2, arg3, code)=0A=
#endif=0A=
=0A=
#define __inline_mathcode_(float_type, func, arg, code) \=0A=
__MATH_INLINE float_type func (float_type); \=0A=
__MATH_INLINE float_type func (float_type arg) \=0A=
{ \=0A=
code; \=0A=
}=0A=
=0A=
#define __inline_mathcode2_(float_type, func, arg1, arg2, code) \=0A=
__MATH_INLINE float_type func (float_type, float_type); \=0A=
__MATH_INLINE float_type func (float_type arg1, float_type arg2) =
\=0A=
{ \=0A=
code; \=0A=
}=0A=
=0A=
#define __inline_mathcode3_(float_type, func, arg1, arg2, arg3, code) \=0A=
__MATH_INLINE float_type func (float_type, float_type, float_type); =
\=0A=
__MATH_INLINE float_type func (float_type arg1, float_type arg2, =
\=0A=
float_type arg3) \=0A=
{ \=0A=
code; \=0A=
}=0A=
#endif=0A=
=0A=
=0A=
#if !defined __NO_MATH_INLINES && defined __OPTIMIZE__=0A=
/* Miscellaneous functions */=0A=
=0A=
__inline_mathcode (__sgn, __x, \=0A=
return __x =3D=3D 0.0 ? 0.0 : (__x > 0.0 ? 1.0 : -1.0))=0A=
=0A=
__inline_mathcode (__pow2, __x, \=0A=
long double __value; \=0A=
long double __exponent; \=0A=
__extension__ long long int __p =3D (long long int) __x; \=0A=
if (__x =3D=3D (long double) __p) \=0A=
{ \=0A=
__asm \=0A=
("fscale" \=0A=
: "=3Dt" (__value) : "0" (1.0), "u" (__x)); \=0A=
return __value; \=0A=
} \=0A=
__asm \=0A=
("fld %%st(0)\n\t" \=0A=
"frndint # int(x)\n\t" \=0A=
"fxch\n\t" \=0A=
"fsub %%st(1) # fract(x)\n\t" \=0A=
"f2xm1 # 2^(fract(x)) - 1\n\t" \=0A=
: "=3Dt" (__value), "=3Du" (__exponent) : "0" (__x)); \=0A=
__value +=3D 1.0; \=0A=
__asm \=0A=
("fscale" \=0A=
: "=3Dt" (__value) : "0" (__value), "u" (__exponent)); \=0A=
return __value)=0A=
=0A=
#define __sincos_code \=0A=
long double __cosr; \=0A=
long double __sinr; \=0A=
__asm \=0A=
("fsincos\n\t" \=0A=
: "=3Dt" (__cosr), "=3Du" (__sinr) : "0" (__x)); \=0A=
*__sinx =3D __sinr; \=0A=
*__cosx =3D __cosr=0A=
=0A=
__MATH_INLINE void __sincos (double __x, double *__sinx, double *__cosx);=0A=
__MATH_INLINE void=0A=
__sincos (double __x, double *__sinx, double *__cosx)=0A=
{=0A=
__sincos_code;=0A=
}=0A=
=0A=
__MATH_INLINE void __sincosf (float __x, float *__sinx, float *__cosx);=0A=
__MATH_INLINE void=0A=
__sincosf (float __x, float *__sinx, float *__cosx)=0A=
{=0A=
__sincos_code;=0A=
}=0A=
=0A=
__MATH_INLINE void __sincosl (long double __x, long double *__sinx,=0A=
long double *__cosx);=0A=
__MATH_INLINE void=0A=
__sincosl (long double __x, long double *__sinx, long double *__cosx)=0A=
{=0A=
__sincos_code;=0A=
}=0A=
=0A=
=0A=
/* Optimized inline implementation, sometimes with reduced precision=0A=
and/or argument range. */=0A=
=0A=
__inline_mathop(rint, "frndint")=0A=
=0A=
#define __expm1_code \=0A=
long double __value; \=0A=
long double __exponent; \=0A=
long double __temp; \=0A=
__asm ("fldl2e" : "=3Dt" (__temp) ); \=0A=
__x -=3D .693147178739309310913*(__exponent =3D rintl(__x * __temp)); \=0A=
__x =3D (__x-1.82063599850414622404E-09*__exponent)*__temp; \=0A=
__asm ("f2xm1" : "=3Dt" (__value) : "0" (__x)); \=0A=
__asm ("fscale" : "=3Dt" (__value) : "0" (__value), "u" (__exponent)); =
\=0A=
__asm ("fscale" : "=3Dt" (__temp) : "0" (1.0), "u" (__exponent)); \=0A=
return (__temp - 1) + __value=0A=
__inline_mathcode_ (long double, __expm1l, __x, __expm1_code)=0A=
=0A=
/* generate (exp(x)-1)/2 for use in sinh()=0A=
* result ought to be finite up to |x| =3D 11357.2 but it seems to be =
unstable=0A=
* beyond the limit applied below, producing NaN in division later */=0A=
#define __expm1h_code \=0A=
long double __value; \=0A=
long double __exponent; \=0A=
long double __temp; \=0A=
if(__x > 11356.8) __x =3D 11356.8; \=0A=
__asm ("fldl2e" : "=3Dt" (__temp) ); \=0A=
__x -=3D .693147178739309310913*(__exponent =3D rintl(__x * __temp)); \=0A=
__x =3D (__x-1.82063599850414622404E-09*__exponent)*__temp; \=0A=
__asm ("f2xm1" : "=3Dt" (__value) : "0" (__x)); \=0A=
__asm ("fscale" : "=3Dt" (__value) : "0" (__value), "u" =
(__exponent-1));\=0A=
__asm ("fscale" : "=3Dt" (__temp) : "0" (1.0), "u" (__exponent-1)); \=0A=
return (__temp - .5) + __value=0A=
__inline_mathcode_ (long double, __expm1h, __x, __expm1h_code)=0A=
=0A=
=0A=
/* extra precision range reduction saves 11 bits in elefunt expl() */=0A=
#define __exp_code \=0A=
long double __value; \=0A=
long double __exponent; \=0A=
long double __temp; \=0A=
__asm ("fldl2e" : "=3Dt" (__temp) ); \=0A=
__x -=3D .693147178739309310913*(__exponent =3D rintl(__x * __temp)); \=0A=
__x =3D (__x-1.82063599850414622404E-09*__exponent)*__temp; \=0A=
__asm ("f2xm1" : "=3Dt" (__value) : "0" (__x)); \=0A=
__asm ("fscale" : "=3Dt" (__value) : "0" (__value+1), "u" =
(__exponent)); \=0A=
return __value=0A=
__inline_mathcode_ (long double, __expl, __x, __exp_code)=0A=
__inline_mathcode (exp, __x, if(__x > 20768)__x =3D 20768;return =
__expl(__x))=0A=
=0A=
#define __exp_h_code \=0A=
long double __value; \=0A=
long double __exponent; \=0A=
long double __temp; \=0A=
if(__x > 20768) __x =3D 20768; \=0A=
__asm ("fldl2e" : "=3Dt" (__temp) ); \=0A=
__x -=3D .693147178739309310913*(__exponent =3D rintl(__x * __temp)); \=0A=
__x =3D (__x-1.82063599850414622404E-09*__exponent)*__temp; \=0A=
__asm ("f2xm1" : "=3Dt" (__value) : "0" (__x)); \=0A=
__asm ("fscale" : "=3Dt" (__value) : "0" (__value+1), "u" =
(__exponent-1)); \=0A=
return __value=0A=
__inline_mathcode_ (long double, __exph, __x, __exp_h_code)=0A=
=0A=
=0A=
__inline_mathcode (tan, __x, \=0A=
long double __value; \=0A=
long double __value2; /* unused */ \=0A=
__asm \=0A=
("fptan" \=0A=
: "=3Dt" (__value2), "=3Du" (__value) : "0" (__x)); \=0A=
return __value)=0A=
=0A=
=0A=
#define __atan2_code \=0A=
long double __value; \=0A=
__asm \=0A=
("fpatan\n\t" \=0A=
: "=3Dt" (__value) : "0" (__x), "u" (__y) : "st(1)"); \=0A=
return __value=0A=
__inline_mathcode2 (atan2, __y, __x, __atan2_code)=0A=
__inline_mathcode2_ (long double, __atan2l, __y, __x, __atan2_code)=0A=
__inline_mathcode (atan, __y, return __atan2l(__y,1.0))=0A=
=0A=
=0A=
__inline_mathcode2 (fmod, __x, __y, \=0A=
long double __value; \=0A=
__asm \=0A=
("1: fprem\n\t" \=0A=
"fnstsw %%ax\n\t" \=0A=
"sahf\n\t" \=0A=
"jp 1b" \=0A=
: "=3Dt" (__value) : "0" (__x), "u" (__y) : "ax", "cc"); \=0A=
return __value)=0A=
=0A=
=0A=
#if 0=0A=
/* while this version is faster and more accurate than the one in =
glibc-2.1.2,=0A=
* there is no speed gain over separate compilation, and there is a loss =
of 9=0A=
* significant bits. */=0A=
__inline_mathcode2 (pow, __x, __y, \=0A=
long double __value; \=0A=
long double __exponent; \=0A=
__extension__ long long int __p =3D (long long int) __y; \=0A=
long double __r; \=0A=
if (__x =3D=3D 0.0 && __y > 0.0) \=0A=
return __x; \=0A=
if(__y =3D=3D __p) \=0A=
__r =3D 1; \=0A=
else{ \=0A=
__asm \=0A=
("fyl2x" : "=3Dt" (__value) : "0" (__x), "u" (__y - __p) : =
"st(1)"); \=0A=
__value -=3D (__exponent =3D rintl(__value)); \=0A=
__asm ( "f2xm1 # 2^(fract(y * log2(x))) - 1\n\t" \=0A=
: "=3Dt" (__value) : "0" (__value)); \=0A=
__asm ("fscale" \=0A=
: "=3Dt" (__r) : "0" (__value + 1), "u" (__exponent)); \=0A=
} \=0A=
if (__p < 0) \=0A=
{ \=0A=
__p =3D -__p; \=0A=
__x =3D 1.0 / __x; \=0A=
} \=0A=
if (__p & 1) \=0A=
__r *=3D __x; \=0A=
for ( ; __p > 1; __r *=3D __x) \=0A=
do \=0A=
__x *=3D __x; \=0A=
while(!((__p >>=3D 1) & 1)); \=0A=
return __r)=0A=
#endif=0A=
=0A=
=0A=
=0A=
#if defined __GNUC__ && (__GNUC__ > 2 || __GNUC__ =3D=3D 2 && =
__GNUC_MINOR__ >=3D 8)=0A=
__inline_mathcode_ (double, fabs, __x, return __builtin_fabs (__x))=0A=
__inline_mathcode_ (float, fabsf, __x, return __builtin_fabsf (__x))=0A=
__inline_mathcode_ (long double, fabsl, __x, return __builtin_fabsl =
(__x))=0A=
__inline_mathcode_ (long double, __fabsl, __x, return __builtin_fabsl =
(__x))=0A=
__inline_mathcode_ (long double, __sqrtl, __x, return __builtin_sqrtl =
(__x))=0A=
#else=0A=
__inline_mathop (fabs, "fabs")=0A=
__inline_mathop_ ( double, __fabsl, "fabs")=0A=
__inline_mathop_ (long double, __sqrtl, "fsqrt")=0A=
#endif=0A=
=0A=
/* The argument range of this inline version is reduced. */=0A=
__inline_mathop (sin, "fsin")=0A=
/* The argument range of this inline version is reduced. */=0A=
__inline_mathop (cos, "fcos")=0A=
=0A=
/* this and all other uses of fyl2x have been corrected to include =
clobber */=0A=
#define __log_code \=0A=
long double __value; \=0A=
__asm ("fldln2": "=3Dt" (__value)); \=0A=
__asm ("fyl2x" : "=3Dt" (__value) : "0" (__x), "u" (__value) : =
"st(1)" ); \=0A=
return __value=0A=
=0A=
__inline_mathcode (log, __x, __log_code)=0A=
=0A=
#define __log10_code \=0A=
long double __value; \=0A=
__asm ("fldlg2": "=3Dt" (__value)); \=0A=
__asm ("fyl2x" : "=3Dt" (__value) : "0" (__x), "u" (__value) : =
"st(1)" ); \=0A=
return __value=0A=
=0A=
__inline_mathcode (log10, __x, __log10_code)=0A=
=0A=
/* sqrt(1-x*x) is good only on the non-IEEE fused multiply-accumulate =
arithmetic=0A=
* this saves 9 bits in elefunt asinl() but still misses 20% of =
achieveable=0A=
* correctly rounded results without a net gain in speed over a library=0A=
* function following the suggestions of Plauger. */=0A=
#if 0=0A=
__inline_mathcode (asin, __x, return __atan2l (__x, __sqrtl =
((1-__x)*(1+__x))))=0A=
__inline_mathcode (acos, __x, return __atan2l (__sqrtl =
((1-__x)*(1+__x)), __x))=0A=
#endif=0A=
__inline_mathcode_ (long double, __sgn1l, __x, return __x >=3D 0.0 ? 1.0 =
: -1.0)=0A=
=0A=
/* i286 compatibility is not retained. */=0A=
__inline_mathcode (sinh, __x, \=0A=
long double __exm1 =3D __expm1h (__x); \=0A=
return __exm1*.5 / (__exm1 + .5) + __exm1;)=0A=
=0A=
__inline_mathcode (cosh, __x, \=0A=
long double __ex =3D __exph (__fabsl(__x)); \=0A=
return __ex + .25 / __ex);=0A=
=0A=
/* this corrects the sign returned when x =3D=3D 0 and improves accuracy =
and speed.=0A=
* Limits in expl() above solve problem of NaN returned for large |__x|.=0A=
* Use Chebyshev economized polynomial for small |__x| to improve =
accuracy=0A=
* and speed, at the expense of code size. */=0A=
__inline_mathcode (tanh, __x, \=0A=
if(__fabsl(__x) <=3D .34657){ \=0A=
long double __x2 =3D __x * __x; \=0A=
long double __x4 =3D __x2*__x2; \=0A=
return __x + __x2*__x*( \=0A=
-0.3333333333333333333028L \=0A=
+__x2*(0.133333333333333321200L \=0A=
+__x2*-0.5396825396825207695E-01L \=0A=
+__x4*(0.218694885360028124E-01L \=0A=
+__x2*-0.88632355226515778E-02 \=0A=
+__x4*(0.3592127817609080E-02 \=0A=
+__x2*-0.14558300258105E-02) \=0A=
+__x4*__x4*(0.5899693119329E-03 \=0A=
+__x2*-0.238614526828E-03 \=0A=
+__x4*(0.9399418484E-04 \=0A=
+__x2*-0.294863013E-04)))));} \=0A=
return 1 - 2 / (expl(__x + __x) + 1))=0A=
=0A=
=0A=
__inline_mathcode (floor, __x, \=0A=
long double __value; \=0A=
unsigned short int __cw; \=0A=
unsigned short int __cwtmp; \=0A=
__asm ("fnstcw %0" : "=3Dm" (__cw)); \=0A=
__cwtmp =3D (__cw & 0xf3ff) | 0x0400; /* rounding down */ \=0A=
__asm ("fldcw %0" : : "m" (__cwtmp)); \=0A=
__asm ("frndint" : "=3Dt" (__value) : "0" (__x)); \=0A=
__asm ("fldcw %0" : : "m" (__cw)); \=0A=
return __value)=0A=
=0A=
__inline_mathcode (ceil, __x, \=0A=
long double __value; \=0A=
unsigned short int __cw; \=0A=
unsigned short int __cwtmp; \=0A=
__asm ("fnstcw %0" : "=3Dm" (__cw)); \=0A=
__cwtmp =3D (__cw & 0xf3ff) | 0x0800; /* rounding up */ \=0A=
__asm ("fldcw %0" : : "m" (__cwtmp)); \=0A=
__asm ("frndint" : "=3Dt" (__value) : "0" (__x)); \=0A=
__asm ("fldcw %0" : : "m" (__cw)); \=0A=
return __value)=0A=
=0A=
#define __ldexp_code \=0A=
long double __value; \=0A=
__asm \=0A=
("fscale" \=0A=
: "=3Dt" (__value) : "0" (__x), "u" ((long double) __y)); \=0A=
return __value=0A=
=0A=
__MATH_INLINE double ldexp (double __x, int __y);=0A=
__MATH_INLINE double=0A=
ldexp (double __x, int __y)=0A=
{=0A=
__ldexp_code;=0A=
}=0A=
=0A=
=0A=
/* Optimized versions for some non-standardized functions. */=0A=
#if defined __USE_ISOC9X || defined __USE_MISC=0A=
=0A=
__inline_mathcode (expm1, __x, __expm1_code)=0A=
=0A=
/* We cannot rely on M_SQRT being defined. So we do it for ourself=0A=
here. */=0A=
# define __M_SQRT2 1.41421356237309504880L /* sqrt(2) */=0A=
=0A=
__inline_mathcode (log1p, __x, \=0A=
long double __value; \=0A=
if (__fabsl (__x) >=3D 1.0 - 0.5 * __M_SQRT2) \=0A=
return logl (1.0 + __x); \=0A=
__asm ("fldln2":"=3Dt" (__value)); \=0A=
__asm ("fyl2xp1" : "=3Dt" (__value) : "0" (__x),"u" (__value) : =
"st(1)"); \=0A=
return __value)=0A=
=0A=
=0A=
/* The argument range of the inline version of asinhl is slightly =
reduced. */=0A=
__inline_mathcode (asinh, __x, \=0A=
long double __y =3D __fabsl (__x); \=0A=
__y =3D log1pl (__x * __x / (__sqrtl (__x * __x + 1.0) + 1.0) + __y); =
\=0A=
return __x >=3D 0 ? __y : -__y)=0A=
=0A=
__inline_mathcode (acosh, __x, \=0A=
return logl (__x + __sqrtl (__x - 1.0) * __sqrtl (__x + 1.0)))=0A=
=0A=
__inline_mathcode (atanh, __x, \=0A=
return 0.5 * log1pl (2 * ( __x / (1.0 + __fabsl (__x)))))=0A=
=0A=
/* The argument range of the inline version of hypotl is slightly =
reduced. */=0A=
__inline_mathcode2 (hypot, __x, __y, return __sqrtl (__x * __x + __y * =
__y))=0A=
=0A=
__inline_mathcode(logb, __x, \=0A=
long double __value; \=0A=
long double __junk; \=0A=
__asm \=0A=
("fxtract\n\t" \=0A=
: "=3Dt" (__junk), "=3Du" (__value) : "0" (__x)); \=0A=
return __value)=0A=
=0A=
#endif=0A=
=0A=
#ifdef __USE_ISOC9X=0A=
__inline_mathcode (log2, __x, \=0A=
long double __value; \=0A=
__asm__ ("fyl2x" : "=3Dt" (__value) : "0" (__x), "u" (1.0) : =
"st(1)"); \=0A=
return __value)=0A=
=0A=
__MATH_INLINE float ldexpf (float __x, int __y);=0A=
__MATH_INLINE float=0A=
ldexpf (float __x, int __y)=0A=
{=0A=
__ldexp_code;=0A=
}=0A=
=0A=
__MATH_INLINE long double ldexpl (long double __x, int __y);=0A=
__MATH_INLINE long double=0A=
ldexpl (long double __x, int __y)=0A=
{=0A=
__ldexp_code;=0A=
}=0A=
=0A=
__inline_mathcode3 (fma, __x, __y, __z, return (__x * __y) + __z)=0A=
=0A=
#define __lrint_code \=0A=
long int __lrintres; \=0A=
__asm__ \=0A=
("fistpl %0" \=0A=
: "=3Dm" (__lrintres) : "t" (__x) : "st"); \=0A=
return __lrintres=0A=
__MATH_INLINE long int=0A=
lrintf (float __x)=0A=
{=0A=
__lrint_code;=0A=
}=0A=
__MATH_INLINE long int=0A=
lrint (double __x)=0A=
{=0A=
__lrint_code;=0A=
}=0A=
__MATH_INLINE long int=0A=
lrintl (long double __x)=0A=
{=0A=
__lrint_code;=0A=
}=0A=
#undef __lrint_code=0A=
=0A=
#define __llrint_code \=0A=
long long int __llrintres; \=0A=
__asm__ \=0A=
("fistpll %0" \=0A=
: "=3Dm" (__llrintres) : "t" (__x) : "st"); \=0A=
return __llrintres=0A=
__MATH_INLINE long long int=0A=
llrintf (float __x)=0A=
{=0A=
__llrint_code;=0A=
}=0A=
__MATH_INLINE long long int=0A=
llrint (double __x)=0A=
{=0A=
__llrint_code;=0A=
}=0A=
__MATH_INLINE long long int=0A=
llrintl (long double __x)=0A=
{=0A=
__llrint_code;=0A=
}=0A=
#undef __llrint_code=0A=
=0A=
#endif=0A=
=0A=
=0A=
#ifdef __USE_MISC=0A=
=0A=
__inline_mathcode2 (drem, __x, __y, \=0A=
double __value; \=0A=
int __clobbered; \=0A=
__asm \=0A=
("1: fprem1\n\t" \=0A=
"fstsw %%ax\n\t" \=0A=
"sahf\n\t" \=0A=
"jp 1b" \=0A=
: "=3Dt" (__value), "=3D&a" (__clobbered) : "0" (__x), "u" (__y) : =
"cc"); \=0A=
return __value)=0A=
=0A=
=0A=
/* This function is used in the `isfinite' macro. */=0A=
__MATH_INLINE int __finite (double __x) __attribute__ ((__const__));=0A=
__MATH_INLINE int=0A=
__finite (double __x)=0A=
{=0A=
return (__extension__=0A=
(((((union { double __d; int __i[2]; }) {__d: __x}).__i[1]=0A=
| 0x800fffff) + 1) >> 31));=0A=
}=0A=
=0A=
/* Miscellaneous functions */=0A=
=0A=
__inline_mathcode (__coshm1, __x, \=0A=
long double __exm1 =3D __expm1l (__fabsl (__x)); \=0A=
return 0.5 * (__exm1 / (__exm1 + 1.0)) * __exm1)=0A=
=0A=
__inline_mathcode (__acosh1p, __x, \=0A=
return log1pl (__x + __sqrtl (__x) * __sqrtl (__x + 2.0)))=0A=
=0A=
#endif /* __USE_MISC */=0A=
=0A=
/* Undefine some of the large macros which are not used anymore. */=0A=
#undef __expm1_code=0A=
#undef __exp_code=0A=
#undef __atan2_code=0A=
#undef __sincos_code=0A=
=0A=
#endif /* __NO_MATH_INLINES */=0A=
=0A=
=0A=
/* This code is used internally in the GNU libc. */=0A=
#ifdef __LIBC_INTERNAL_MATH_INLINES=0A=
__inline_mathcode2 (__ieee754_atan2, __y, __x,=0A=
long double __value;=0A=
__asm ("fpatan\n\t"=0A=
: "=3Dt" (__value)=0A=
: "0" (__x), "u" (__y) : "st(1)");=0A=
return __value;)=0A=
#endif=0A=
=0A=
#endif /* __GNUC__ */=0A=
#endif =0A=
------=_NextPart_000_0015_01C2A8DA.D878AF80
Content-Type: text/plain; charset=us-ascii
--
Unsubscribe info: http://cygwin.com/ml/#unsubscribe-simple
Bug reporting: http://cygwin.com/bugs.html
Documentation: http://cygwin.com/docs.html
FAQ: http://cygwin.com/faq/
------=_NextPart_000_0015_01C2A8DA.D878AF80--
---------------------------------------------
Introducing NetZero Long Distance
1st month Free!
Sign up today at: www.netzerolongdistance.com
- Raw text -