2006-01-27 Dwayne Grant McConnell <decimal@us.ibm.com>, Jakub Jelinek <jakub@redha...
authorroland <roland>
Sat, 28 Jan 2006 00:07:25 +0000 (00:07 +0000)
committerroland <roland>
Sat, 28 Jan 2006 00:07:25 +0000 (00:07 +0000)
* sysdeps/powerpc/fpu/bits/mathdef.h (__NO_LONG_DOUBLE_MATH): Remove.
* sysdeps/powerpc/Implies: Add ieee754/ldbl-128ibm.
* sysdeps/powerpc/powerpc32/Implies: Remove powerpc/soft-fp.
* sysdeps/ieee754/ldbl-128ibm/Makefile: New file.
* sysdeps/ieee754/ldbl-128ibm/e_acoshl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_acosl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_asinl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_atan2l.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_atanhl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_coshl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_expl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_fmodl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_gammal_r.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_hypotl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_j0l.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_j1l.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_jnl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_lgammal_r.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_log10l.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_log2l.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_logl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_powl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_rem_pio2l.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_remainderl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_sinhl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/e_sqrtl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/ieee754.h: New file.
* sysdeps/ieee754/ldbl-128ibm/k_cosl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/k_sincosl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/k_sinl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/k_tanl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/ldbl2mpn.c: New file.
* sysdeps/ieee754/ldbl-128ibm/math_ldbl.h: New file.
* sysdeps/ieee754/ldbl-128ibm/mpn2ldbl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/printf_fphex.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_asinhl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_atanl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_cbrtl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_cosl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_erfl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_expm1l.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_fabsl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_finitel.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_fpclassifyl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_frexpl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_ilogbl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_isinfl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_isnanl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_log1pl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_logbl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_modfl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_nextafterl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_nexttoward.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_nexttowardf.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_remquol.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_rintl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_scalblnl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_scalbnl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_signbitl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_sincosl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_sinl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_tanhl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_tanl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_truncl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/strtold_l.c: New file.
* sysdeps/ieee754/ldbl-128ibm/t_sincosl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/w_expl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_copysignl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_floorl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_llrintl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_llroundl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_roundl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_ceill.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_nearbyintl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_lrintl.c: New file.
* sysdeps/ieee754/ldbl-128ibm/s_lroundl.c: New file.

76 files changed:
sysdeps/ieee754/ldbl-128ibm/Makefile [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_acoshl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_acosl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_asinl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_atan2l.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_atanhl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_coshl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_expl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_fmodl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_gammal_r.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_hypotl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_j0l.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_j1l.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_jnl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_lgammal_r.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_log10l.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_log2l.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_logl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_powl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_rem_pio2l.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_remainderl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_sinhl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/e_sqrtl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/ieee754.h [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/k_cosl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/k_sincosl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/k_sinl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/k_tanl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/ldbl2mpn.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/math_ldbl.h [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/mpn2ldbl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/printf_fphex.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_asinhl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_atanl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_cbrtl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_ceill.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_copysignl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_cosl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_erfl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_expm1l.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_fabsl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_finitel.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_floorl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_fpclassifyl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_frexpl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_ilogbl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_isinfl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_isnanl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_llrintl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_llroundl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_log1pl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_logbl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_lrintl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_lroundl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_modfl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_nearbyintl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_nextafterl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_nexttoward.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_nexttowardf.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_remquol.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_rintl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_roundl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_scalblnl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_scalbnl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_signbitl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_sincosl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_sinl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_tanhl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_tanl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/s_truncl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/strtold_l.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/t_sincosl.c [new file with mode: 0644]
sysdeps/ieee754/ldbl-128ibm/w_expl.c [new file with mode: 0644]
sysdeps/powerpc/Implies
sysdeps/powerpc/fpu/bits/mathdef.h
sysdeps/powerpc/powerpc32/Implies

diff --git a/sysdeps/ieee754/ldbl-128ibm/Makefile b/sysdeps/ieee754/ldbl-128ibm/Makefile
new file mode 100644 (file)
index 0000000..8e1e2e6
--- /dev/null
@@ -0,0 +1,5 @@
+# The`long double' type is a distinct type we support if
+# -mlong-double-128 option is used (or when it becomes a default
+# when -mlong-double-64 is not used).
+long-double-fcts = yes
+sysdep-CFLAGS += -mlong-double-128
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_acoshl.c b/sysdeps/ieee754/ldbl-128ibm/e_acoshl.c
new file mode 100644 (file)
index 0000000..00576c7
--- /dev/null
@@ -0,0 +1,69 @@
+/* @(#)e_acosh.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.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: e_acosh.c,v 1.9 1995/05/12 04:57:18 jtc Exp $";
+#endif
+
+/* __ieee754_acosh(x)
+ * Method :
+ *     Based on
+ *             acosh(x) = log [ x + sqrt(x*x-1) ]
+ *     we have
+ *             acosh(x) := log(x)+ln2, if x is large; else
+ *             acosh(x) := log(2x-1/(sqrt(x*x-1)+x)) if x>2; else
+ *             acosh(x) := log1p(t+sqrt(2.0*t+t*t)); where t=x-1.
+ *
+ * Special cases:
+ *     acosh(x) is NaN with signal if x<1.
+ *     acosh(NaN) is NaN without signal.
+ */
+
+#include "math.h"
+#include "math_private.h"
+
+#ifdef __STDC__
+static const long double
+#else
+static long double
+#endif
+one    = 1.0L,
+ln2    = 6.93147180559945286227e-01L;  /* 0x3FE62E42, 0xFEFA39EF */
+
+#ifdef __STDC__
+       long double __ieee754_acoshl(long double x)
+#else
+       long double __ieee754_acoshl(x)
+       long double x;
+#endif
+{
+       long double t;
+       int64_t hx;
+       u_int64_t lx;
+       GET_LDOUBLE_WORDS64(hx,lx,x);
+       if(hx<0x3ff0000000000000LL) {           /* x < 1 */
+           return (x-x)/(x-x);
+       } else if(hx >=0x41b0000000000000LL) {  /* x > 2**28 */
+           if(hx >=0x7ff0000000000000LL) {     /* x is inf of NaN */
+               return x+x;
+           } else
+               return __ieee754_logl(x)+ln2;   /* acosh(huge)=log(2x) */
+       } else if (((hx-0x3ff0000000000000LL)|(lx&0x7fffffffffffffffLL))==0) {
+           return 0.0;                 /* acosh(1) = 0 */
+       } else if (hx > 0x4000000000000000LL) { /* 2**28 > x > 2 */
+           t=x*x;
+           return __ieee754_logl(2.0*x-one/(x+__ieee754_sqrtl(t-one)));
+       } else {                        /* 1<x<2 */
+           t = x-one;
+           return __log1p(t+__sqrtl(2.0*t+t*t));
+       }
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_acosl.c b/sysdeps/ieee754/ldbl-128ibm/e_acosl.c
new file mode 100644 (file)
index 0000000..8823fd6
--- /dev/null
@@ -0,0 +1,328 @@
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+/*
+   Long double expansions are
+   Copyright (C) 2001 Stephen L. Moshier <moshier@na-net.ornl.gov>
+   and are incorporated herein by permission of the author.  The author
+   reserves the right to distribute this material elsewhere under different
+   copying permissions.  These modifications are distributed here under
+   the following terms:
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA */
+
+/* __ieee754_acosl(x)
+ * Method :
+ *      acos(x)  = pi/2 - asin(x)
+ *      acos(-x) = pi/2 + asin(x)
+ * For |x| <= 0.375
+ *      acos(x) = pi/2 - asin(x)
+ * Between .375 and .5 the approximation is
+ *      acos(0.4375 + x) = acos(0.4375) + x P(x) / Q(x)
+ * Between .5 and .625 the approximation is
+ *      acos(0.5625 + x) = acos(0.5625) + x rS(x) / sS(x)
+ * For x > 0.625,
+ *      acos(x) = 2 asin(sqrt((1-x)/2))
+ *      computed with an extended precision square root in the leading term.
+ * For x < -0.625
+ *      acos(x) = pi - 2 asin(sqrt((1-|x|)/2))
+ *
+ * Special cases:
+ *      if x is NaN, return x itself;
+ *      if |x|>1, return NaN with invalid signal.
+ *
+ * Functions needed: __ieee754_sqrtl.
+ */
+
+#include "math.h"
+#include "math_private.h"
+
+#ifdef __STDC__
+static const long double
+#else
+static long double
+#endif
+  one = 1.0L,
+  pio2_hi = 1.5707963267948966192313216916397514420986L,
+  pio2_lo = 4.3359050650618905123985220130216759843812E-35L,
+
+  /* acos(0.5625 + x) = acos(0.5625) + x rS(x) / sS(x)
+     -0.0625 <= x <= 0.0625
+     peak relative error 3.3e-35  */
+
+  rS0 =  5.619049346208901520945464704848780243887E0L,
+  rS1 = -4.460504162777731472539175700169871920352E1L,
+  rS2 =  1.317669505315409261479577040530751477488E2L,
+  rS3 = -1.626532582423661989632442410808596009227E2L,
+  rS4 =  3.144806644195158614904369445440583873264E1L,
+  rS5 =  9.806674443470740708765165604769099559553E1L,
+  rS6 = -5.708468492052010816555762842394927806920E1L,
+  rS7 = -1.396540499232262112248553357962639431922E1L,
+  rS8 =  1.126243289311910363001762058295832610344E1L,
+  rS9 =  4.956179821329901954211277873774472383512E-1L,
+  rS10 = -3.313227657082367169241333738391762525780E-1L,
+
+  sS0 = -4.645814742084009935700221277307007679325E0L,
+  sS1 =  3.879074822457694323970438316317961918430E1L,
+  sS2 = -1.221986588013474694623973554726201001066E2L,
+  sS3 =  1.658821150347718105012079876756201905822E2L,
+  sS4 = -4.804379630977558197953176474426239748977E1L,
+  sS5 = -1.004296417397316948114344573811562952793E2L,
+  sS6 =  7.530281592861320234941101403870010111138E1L,
+  sS7 =  1.270735595411673647119592092304357226607E1L,
+  sS8 = -1.815144839646376500705105967064792930282E1L,
+  sS9 = -7.821597334910963922204235247786840828217E-2L,
+  /* 1.000000000000000000000000000000000000000E0 */
+
+  acosr5625 = 9.7338991014954640492751132535550279812151E-1L,
+  pimacosr5625 = 2.1682027434402468335351320579240000860757E0L,
+
+  /* acos(0.4375 + x) = acos(0.4375) + x rS(x) / sS(x)
+     -0.0625 <= x <= 0.0625
+     peak relative error 2.1e-35  */
+
+  P0 =  2.177690192235413635229046633751390484892E0L,
+  P1 = -2.848698225706605746657192566166142909573E1L,
+  P2 =  1.040076477655245590871244795403659880304E2L,
+  P3 = -1.400087608918906358323551402881238180553E2L,
+  P4 =  2.221047917671449176051896400503615543757E1L,
+  P5 =  9.643714856395587663736110523917499638702E1L,
+  P6 = -5.158406639829833829027457284942389079196E1L,
+  P7 = -1.578651828337585944715290382181219741813E1L,
+  P8 =  1.093632715903802870546857764647931045906E1L,
+  P9 =  5.448925479898460003048760932274085300103E-1L,
+  P10 = -3.315886001095605268470690485170092986337E-1L,
+  Q0 = -1.958219113487162405143608843774587557016E0L,
+  Q1 =  2.614577866876185080678907676023269360520E1L,
+  Q2 = -9.990858606464150981009763389881793660938E1L,
+  Q3 =  1.443958741356995763628660823395334281596E2L,
+  Q4 = -3.206441012484232867657763518369723873129E1L,
+  Q5 = -1.048560885341833443564920145642588991492E2L,
+  Q6 =  6.745883931909770880159915641984874746358E1L,
+  Q7 =  1.806809656342804436118449982647641392951E1L,
+  Q8 = -1.770150690652438294290020775359580915464E1L,
+  Q9 = -5.659156469628629327045433069052560211164E-1L,
+  /* 1.000000000000000000000000000000000000000E0 */
+
+  acosr4375 = 1.1179797320499710475919903296900511518755E0L,
+  pimacosr4375 = 2.0236129215398221908706530535894517323217E0L,
+
+  /* asin(x) = x + x^3 pS(x^2) / qS(x^2)
+     0 <= x <= 0.5
+     peak relative error 1.9e-35  */
+  pS0 = -8.358099012470680544198472400254596543711E2L,
+  pS1 =  3.674973957689619490312782828051860366493E3L,
+  pS2 = -6.730729094812979665807581609853656623219E3L,
+  pS3 =  6.643843795209060298375552684423454077633E3L,
+  pS4 = -3.817341990928606692235481812252049415993E3L,
+  pS5 =  1.284635388402653715636722822195716476156E3L,
+  pS6 = -2.410736125231549204856567737329112037867E2L,
+  pS7 =  2.219191969382402856557594215833622156220E1L,
+  pS8 = -7.249056260830627156600112195061001036533E-1L,
+  pS9 =  1.055923570937755300061509030361395604448E-3L,
+
+  qS0 = -5.014859407482408326519083440151745519205E3L,
+  qS1 =  2.430653047950480068881028451580393430537E4L,
+  qS2 = -4.997904737193653607449250593976069726962E4L,
+  qS3 =  5.675712336110456923807959930107347511086E4L,
+  qS4 = -3.881523118339661268482937768522572588022E4L,
+  qS5 =  1.634202194895541569749717032234510811216E4L,
+  qS6 = -4.151452662440709301601820849901296953752E3L,
+  qS7 =  5.956050864057192019085175976175695342168E2L,
+  qS8 = -4.175375777334867025769346564600396877176E1L;
+  /* 1.000000000000000000000000000000000000000E0 */
+
+#ifdef __STDC__
+long double
+__ieee754_acosl (long double x)
+#else
+long double
+__ieee754_acosl (x)
+     long double x;
+#endif
+{
+  long double z, r, w, p, q, s, t, f2;
+  int32_t ix, sign;
+  ieee854_long_double_shape_type u;
+
+  u.value = x;
+  sign = u.parts32.w0;
+  ix = sign & 0x7fffffff;
+  u.parts32.w0 = ix;           /* |x| */
+  if (ix >= 0x3ff00000)                /* |x| >= 1 */
+    {
+      if (ix == 0x3ff00000
+         && (u.parts32.w1 | (u.parts32.w2&0x7fffffff) | u.parts32.w3) == 0)
+       {                       /* |x| == 1 */
+         if ((sign & 0x80000000) == 0)
+           return 0.0;         /* acos(1) = 0  */
+         else
+           return (2.0 * pio2_hi) + (2.0 * pio2_lo);   /* acos(-1)= pi */
+       }
+      return (x - x) / (x - x);        /* acos(|x| > 1) is NaN */
+    }
+  else if (ix < 0x3fe00000)    /* |x| < 0.5 */
+    {
+      if (ix < 0x3c600000)     /* |x| < 2**-57 */
+       return pio2_hi + pio2_lo;
+      if (ix < 0x3fde0000)     /* |x| < .4375 */
+       {
+         /* Arcsine of x.  */
+         z = x * x;
+         p = (((((((((pS9 * z
+                      + pS8) * z
+                     + pS7) * z
+                    + pS6) * z
+                   + pS5) * z
+                  + pS4) * z
+                 + pS3) * z
+                + pS2) * z
+               + pS1) * z
+              + pS0) * z;
+         q = (((((((( z
+                      + qS8) * z
+                    + qS7) * z
+                   + qS6) * z
+                  + qS5) * z
+                 + qS4) * z
+                + qS3) * z
+               + qS2) * z
+              + qS1) * z
+           + qS0;
+         r = x + x * p / q;
+         z = pio2_hi - (r - pio2_lo);
+         return z;
+       }
+      /* .4375 <= |x| < .5 */
+      t = u.value - 0.4375L;
+      p = ((((((((((P10 * t
+                   + P9) * t
+                  + P8) * t
+                 + P7) * t
+                + P6) * t
+               + P5) * t
+              + P4) * t
+             + P3) * t
+            + P2) * t
+           + P1) * t
+          + P0) * t;
+
+      q = (((((((((t
+                  + Q9) * t
+                 + Q8) * t
+                + Q7) * t
+               + Q6) * t
+              + Q5) * t
+             + Q4) * t
+            + Q3) * t
+           + Q2) * t
+          + Q1) * t
+       + Q0;
+      r = p / q;
+      if (sign & 0x80000000)
+       r = pimacosr4375 - r;
+      else
+       r = acosr4375 + r;
+      return r;
+    }
+  else if (ix < 0x3fe40000)    /* |x| < 0.625 */
+    {
+      t = u.value - 0.5625L;
+      p = ((((((((((rS10 * t
+                   + rS9) * t
+                  + rS8) * t
+                 + rS7) * t
+                + rS6) * t
+               + rS5) * t
+              + rS4) * t
+             + rS3) * t
+            + rS2) * t
+           + rS1) * t
+          + rS0) * t;
+
+      q = (((((((((t
+                  + sS9) * t
+                 + sS8) * t
+                + sS7) * t
+               + sS6) * t
+              + sS5) * t
+             + sS4) * t
+            + sS3) * t
+           + sS2) * t
+          + sS1) * t
+       + sS0;
+      if (sign & 0x80000000)
+       r = pimacosr5625 - p / q;
+      else
+       r = acosr5625 + p / q;
+      return r;
+    }
+  else
+    {                          /* |x| >= .625 */
+      z = (one - u.value) * 0.5;
+      s = __ieee754_sqrtl (z);
+      /* Compute an extended precision square root from
+        the Newton iteration  s -> 0.5 * (s + z / s).
+         The change w from s to the improved value is
+           w = 0.5 * (s + z / s) - s  = (s^2 + z)/2s - s = (z - s^2)/2s.
+          Express s = f1 + f2 where f1 * f1 is exactly representable.
+         w = (z - s^2)/2s = (z - f1^2 - 2 f1 f2 - f2^2)/2s .
+          s + w has extended precision.  */
+      u.value = s;
+      u.parts32.w2 = 0;
+      u.parts32.w3 = 0;
+      f2 = s - u.value;
+      w = z - u.value * u.value;
+      w = w - 2.0 * u.value * f2;
+      w = w - f2 * f2;
+      w = w / (2.0 * s);
+      /* Arcsine of s.  */
+      p = (((((((((pS9 * z
+                  + pS8) * z
+                 + pS7) * z
+                + pS6) * z
+               + pS5) * z
+              + pS4) * z
+             + pS3) * z
+            + pS2) * z
+           + pS1) * z
+          + pS0) * z;
+      q = (((((((( z
+                  + qS8) * z
+                + qS7) * z
+               + qS6) * z
+              + qS5) * z
+             + qS4) * z
+            + qS3) * z
+           + qS2) * z
+          + qS1) * z
+       + qS0;
+      r = s + (w + s * p / q);
+
+      if (sign & 0x80000000)
+       w = pio2_hi + (pio2_lo - r);
+      else
+       w = r;
+      return 2.0 * w;
+    }
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_asinl.c b/sysdeps/ieee754/ldbl-128ibm/e_asinl.c
new file mode 100644 (file)
index 0000000..3696694
--- /dev/null
@@ -0,0 +1,265 @@
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+/*
+  Long double expansions are
+  Copyright (C) 2001 Stephen L. Moshier <moshier@na-net.ornl.gov>
+  and are incorporated herein by permission of the author.  The author 
+  reserves the right to distribute this material elsewhere under different 
+  copying permissions.  These modifications are distributed here under the 
+  following terms:
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA */
+
+/* __ieee754_asin(x)
+ * Method :
+ *     Since  asin(x) = x + x^3/6 + x^5*3/40 + x^7*15/336 + ...
+ *     we approximate asin(x) on [0,0.5] by
+ *             asin(x) = x + x*x^2*R(x^2)
+ *      Between .5 and .625 the approximation is
+ *              asin(0.5625 + x) = asin(0.5625) + x rS(x) / sS(x)
+ *     For x in [0.625,1]
+ *             asin(x) = pi/2-2*asin(sqrt((1-x)/2))
+ *     Let y = (1-x), z = y/2, s := sqrt(z), and pio2_hi+pio2_lo=pi/2;
+ *     then for x>0.98
+ *             asin(x) = pi/2 - 2*(s+s*z*R(z))
+ *                     = pio2_hi - (2*(s+s*z*R(z)) - pio2_lo)
+ *     For x<=0.98, let pio4_hi = pio2_hi/2, then
+ *             f = hi part of s;
+ *             c = sqrt(z) - f = (z-f*f)/(s+f)         ...f+c=sqrt(z)
+ *     and
+ *             asin(x) = pi/2 - 2*(s+s*z*R(z))
+ *                     = pio4_hi+(pio4-2s)-(2s*z*R(z)-pio2_lo)
+ *                     = pio4_hi+(pio4-2f)-(2s*z*R(z)-(pio2_lo+2c))
+ *
+ * Special cases:
+ *     if x is NaN, return x itself;
+ *     if |x|>1, return NaN with invalid signal.
+ *
+ */
+
+
+#include "math.h"
+#include "math_private.h"
+long double sqrtl (long double);
+
+#ifdef __STDC__
+static const long double
+#else
+static long double
+#endif
+  one = 1.0L,
+  huge = 1.0e+300L,
+  pio2_hi = 1.5707963267948966192313216916397514420986L,
+  pio2_lo = 4.3359050650618905123985220130216759843812E-35L,
+  pio4_hi = 7.8539816339744830961566084581987569936977E-1L,
+
+       /* coefficient for R(x^2) */
+
+  /* asin(x) = x + x^3 pS(x^2) / qS(x^2)
+     0 <= x <= 0.5
+     peak relative error 1.9e-35  */
+  pS0 = -8.358099012470680544198472400254596543711E2L,
+  pS1 =  3.674973957689619490312782828051860366493E3L,
+  pS2 = -6.730729094812979665807581609853656623219E3L,
+  pS3 =  6.643843795209060298375552684423454077633E3L,
+  pS4 = -3.817341990928606692235481812252049415993E3L,
+  pS5 =  1.284635388402653715636722822195716476156E3L,
+  pS6 = -2.410736125231549204856567737329112037867E2L,
+  pS7 =  2.219191969382402856557594215833622156220E1L,
+  pS8 = -7.249056260830627156600112195061001036533E-1L,
+  pS9 =  1.055923570937755300061509030361395604448E-3L,
+
+  qS0 = -5.014859407482408326519083440151745519205E3L,
+  qS1 =  2.430653047950480068881028451580393430537E4L,
+  qS2 = -4.997904737193653607449250593976069726962E4L,
+  qS3 =  5.675712336110456923807959930107347511086E4L,
+  qS4 = -3.881523118339661268482937768522572588022E4L,
+  qS5 =  1.634202194895541569749717032234510811216E4L,
+  qS6 = -4.151452662440709301601820849901296953752E3L,
+  qS7 =  5.956050864057192019085175976175695342168E2L,
+  qS8 = -4.175375777334867025769346564600396877176E1L,
+  /* 1.000000000000000000000000000000000000000E0 */
+
+  /* asin(0.5625 + x) = asin(0.5625) + x rS(x) / sS(x)
+     -0.0625 <= x <= 0.0625
+     peak relative error 3.3e-35  */
+  rS0 = -5.619049346208901520945464704848780243887E0L,
+  rS1 =  4.460504162777731472539175700169871920352E1L,
+  rS2 = -1.317669505315409261479577040530751477488E2L,
+  rS3 =  1.626532582423661989632442410808596009227E2L,
+  rS4 = -3.144806644195158614904369445440583873264E1L,
+  rS5 = -9.806674443470740708765165604769099559553E1L,
+  rS6 =  5.708468492052010816555762842394927806920E1L,
+  rS7 =  1.396540499232262112248553357962639431922E1L,
+  rS8 = -1.126243289311910363001762058295832610344E1L,
+  rS9 = -4.956179821329901954211277873774472383512E-1L,
+  rS10 =  3.313227657082367169241333738391762525780E-1L,
+
+  sS0 = -4.645814742084009935700221277307007679325E0L,
+  sS1 =  3.879074822457694323970438316317961918430E1L,
+  sS2 = -1.221986588013474694623973554726201001066E2L,
+  sS3 =  1.658821150347718105012079876756201905822E2L,
+  sS4 = -4.804379630977558197953176474426239748977E1L,
+  sS5 = -1.004296417397316948114344573811562952793E2L,
+  sS6 =  7.530281592861320234941101403870010111138E1L,
+  sS7 =  1.270735595411673647119592092304357226607E1L,
+  sS8 = -1.815144839646376500705105967064792930282E1L,
+  sS9 = -7.821597334910963922204235247786840828217E-2L,
+  /*  1.000000000000000000000000000000000000000E0 */
+
+ asinr5625 =  5.9740641664535021430381036628424864397707E-1L;
+
+
+
+#ifdef __STDC__
+long double
+__ieee754_asinl (long double x)
+#else
+double
+__ieee754_asinl (x)
+     long double x;
+#endif
+{
+  long double t, w, p, q, c, r, s;
+  int32_t ix, sign, flag;
+  ieee854_long_double_shape_type u;
+
+  flag = 0;
+  u.value = x;
+  sign = u.parts32.w0;
+  ix = sign & 0x7fffffff;
+  u.parts32.w0 = ix;    /* |x| */
+  if (ix >= 0x3ff00000)        /* |x|>= 1 */
+    {
+      if (ix == 0x3ff00000
+         && (u.parts32.w1 | (u.parts32.w2 & 0x7fffffff) | u.parts32.w3) == 0)
+       /* asin(1)=+-pi/2 with inexact */
+       return x * pio2_hi + x * pio2_lo;
+      return (x - x) / (x - x);        /* asin(|x|>1) is NaN */
+    }
+  else if (ix < 0x3fe00000) /* |x| < 0.5 */
+    {
+      if (ix < 0x3c600000) /* |x| < 2**-57 */
+       {
+         if (huge + x > one)
+           return x;           /* return x with inexact if x!=0 */
+       }
+      else
+       {
+         t = x * x;
+         /* Mark to use pS, qS later on.  */
+         flag = 1;
+       }
+    }
+  else if (ix < 0x3fe40000) /* 0.625 */
+    {
+      t = u.value - 0.5625;
+      p = ((((((((((rS10 * t
+                   + rS9) * t
+                  + rS8) * t
+                 + rS7) * t
+                + rS6) * t
+               + rS5) * t
+              + rS4) * t
+             + rS3) * t
+            + rS2) * t
+           + rS1) * t
+          + rS0) * t;
+
+      q = ((((((((( t
+                   + sS9) * t
+                 + sS8) * t
+                + sS7) * t
+               + sS6) * t
+              + sS5) * t
+             + sS4) * t
+            + sS3) * t
+           + sS2) * t
+          + sS1) * t
+       + sS0;
+      t = asinr5625 + p / q;
+      if ((sign & 0x80000000) == 0)
+       return t;
+      else
+       return -t;
+    }
+  else
+    {
+      /* 1 > |x| >= 0.625 */
+      w = one - u.value;
+      t = w * 0.5;
+    }
+
+  p = (((((((((pS9 * t
+              + pS8) * t
+             + pS7) * t
+            + pS6) * t
+           + pS5) * t
+          + pS4) * t
+         + pS3) * t
+        + pS2) * t
+       + pS1) * t
+       + pS0) * t;
+
+  q = (((((((( t
+             + qS8) * t
+            + qS7) * t
+           + qS6) * t
+          + qS5) * t
+         + qS4) * t
+        + qS3) * t
+       + qS2) * t
+       + qS1) * t
+    + qS0;
+
+  if (flag) /* 2^-57 < |x| < 0.5 */
+    {
+      w = p / q;
+      return x + x * w;
+    }
+
+  s = __ieee754_sqrtl (t);
+  if (ix >= 0x3fef3333) /* |x| > 0.975 */
+    {
+      w = p / q;
+      t = pio2_hi - (2.0 * (s + s * w) - pio2_lo);
+    }
+  else
+    {
+      u.value = s;
+      u.parts32.w3 = 0;
+      u.parts32.w2 = 0;
+      w = u.value;
+      c = (t - w * w) / (s + w);
+      r = p / q;
+      p = 2.0 * s * r - (pio2_lo - 2.0 * c);
+      q = pio4_hi - 2.0 * w;
+      t = pio4_hi - (p - q);
+    }
+
+  if ((sign & 0x80000000) == 0)
+    return t;
+  else
+    return -t;
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_atan2l.c b/sysdeps/ieee754/ldbl-128ibm/e_atan2l.c
new file mode 100644 (file)
index 0000000..a4bb53d
--- /dev/null
@@ -0,0 +1,124 @@
+/* e_atan2l.c -- long double version of e_atan2.c.
+ * Conversion to long double by Jakub Jelinek, jj@ultra.linux.cz.
+ */
+
+/*
+ * ====================================================
+ * 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_atan2l(y,x)
+ * Method :
+ *     1. Reduce y to positive by atan2l(y,x)=-atan2l(-y,x).
+ *     2. Reduce x to positive by (if x and y are unexceptional):
+ *             ARG (x+iy) = arctan(y/x)           ... if x > 0,
+ *             ARG (x+iy) = pi - arctan[y/(-x)]   ... if x < 0,
+ *
+ * Special cases:
+ *
+ *     ATAN2((anything), NaN ) is NaN;
+ *     ATAN2(NAN , (anything) ) is NaN;
+ *     ATAN2(+-0, +(anything but NaN)) is +-0  ;
+ *     ATAN2(+-0, -(anything but NaN)) is +-pi ;
+ *     ATAN2(+-(anything but 0 and NaN), 0) is +-pi/2;
+ *     ATAN2(+-(anything but INF and NaN), +INF) is +-0 ;
+ *     ATAN2(+-(anything but INF and NaN), -INF) is +-pi;
+ *     ATAN2(+-INF,+INF ) is +-pi/4 ;
+ *     ATAN2(+-INF,-INF ) is +-3pi/4;
+ *     ATAN2(+-INF, (anything but,0,NaN, and INF)) is +-pi/2;
+ *
+ * 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 long double
+#else
+static long double
+#endif
+tiny  = 1.0e-300L,
+zero  = 0.0,
+pi_o_4  = 7.85398163397448309615660845819875699e-01L, /* 3ffe921fb54442d18469898cc51701b8 */
+pi_o_2  = 1.57079632679489661923132169163975140e+00L, /* 3fff921fb54442d18469898cc51701b8 */
+pi      = 3.14159265358979323846264338327950280e+00L, /* 4000921fb54442d18469898cc51701b8 */
+pi_lo   = 8.67181013012378102479704402604335225e-35L; /* 3f8dcd129024e088a67cc74020bbea64 */
+
+#ifdef __STDC__
+       long double __ieee754_atan2l(long double y, long double x)
+#else
+       long double __ieee754_atan2l(y,x)
+       long double  y,x;
+#endif
+{
+       long double z;
+       int64_t k,m,hx,hy,ix,iy;
+       u_int64_t lx,ly;
+
+       GET_LDOUBLE_WORDS64(hx,lx,x);
+       ix = hx&0x7fffffffffffffffLL;
+       GET_LDOUBLE_WORDS64(hy,ly,y);
+       iy = hy&0x7fffffffffffffffLL;
+       if(((ix)>0x7ff0000000000000LL)||
+          ((iy)>0x7ff0000000000000LL)) /* x or y is NaN */
+          return x+y;
+       if(((hx-0x3ff0000000000000LL))==0) return __atanl(y);   /* x=1.0L */
+       m = ((hy>>63)&1)|((hx>>62)&2);  /* 2*sign(x)+sign(y) */
+
+    /* when y = 0 */
+       if((iy|(ly&0x7fffffffffffffffLL))==0) {
+           switch(m) {
+               case 0:
+               case 1: return y;       /* atan(+-0,+anything)=+-0 */
+               case 2: return  pi+tiny;/* atan(+0,-anything) = pi */
+               case 3: return -pi-tiny;/* atan(-0,-anything) =-pi */
+           }
+       }
+    /* when x = 0 */
+       if((ix|(lx&0x7fffffffffffffff))==0) return (hy<0)?  -pi_o_2-tiny: pi_o_2+tiny;
+
+    /* when x is INF */
+       if(ix==0x7ff0000000000000LL) {
+           if(iy==0x7ff0000000000000LL) {
+               switch(m) {
+                   case 0: return  pi_o_4+tiny;/* atan(+INF,+INF) */
+                   case 1: return -pi_o_4-tiny;/* atan(-INF,+INF) */
+                   case 2: return  3.0L*pi_o_4+tiny;/*atan(+INF,-INF)*/
+                   case 3: return -3.0L*pi_o_4-tiny;/*atan(-INF,-INF)*/
+               }
+           } else {
+               switch(m) {
+                   case 0: return  zero  ;     /* atan(+...,+INF) */
+                   case 1: return -zero  ;     /* atan(-...,+INF) */
+                   case 2: return  pi+tiny  ;  /* atan(+...,-INF) */
+                   case 3: return -pi-tiny  ;  /* atan(-...,-INF) */
+               }
+           }
+       }
+    /* when y is INF */
+       if(iy==0x7ff0000000000000LL) return (hy<0)? -pi_o_2-tiny: pi_o_2+tiny;
+
+    /* compute y/x */
+       k = (iy-ix)>>52;
+       if(k > 120) z=pi_o_2+0.5L*pi_lo;        /* |y/x| >  2**120 */
+       else if(hx<0&&k<-120) z=0.0L;           /* |y|/x < -2**120 */
+       else z=__atanl(fabsl(y/x));             /* safe to do y/x */
+       switch (m) {
+           case 0: return       z  ;   /* atan(+,+) */
+           case 1: return      -z  ;   /* atan(-,+) */
+           case 2: return  pi-(z-pi_lo);/* atan(+,-) */
+           default: /* case 3 */
+                   return  (z-pi_lo)-pi;/* atan(-,-) */
+       }
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_atanhl.c b/sysdeps/ieee754/ldbl-128ibm/e_atanhl.c
new file mode 100644 (file)
index 0000000..a801bd6
--- /dev/null
@@ -0,0 +1,79 @@
+/* @(#)e_atanh.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.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: e_atanh.c,v 1.8 1995/05/10 20:44:55 jtc Exp $";
+#endif
+
+/* __ieee754_atanh(x)
+ * Method :
+ *    1.Reduced x to positive by atanh(-x) = -atanh(x)
+ *    2.For x>=0.5
+ *                  1              2x                          x
+ *     atanh(x) = --- * log(1 + -------) = 0.5 * log1p(2 * --------)
+ *                  2             1 - x                      1 - x
+ *
+ *     For x<0.5
+ *     atanh(x) = 0.5*log1p(2x+2x*x/(1-x))
+ *
+ * Special cases:
+ *     atanh(x) is NaN if |x| > 1 with signal;
+ *     atanh(NaN) is that NaN with no signal;
+ *     atanh(+-1) is +-INF with signal.
+ *
+ */
+
+#include "math.h"
+#include "math_private.h"
+
+#ifdef __STDC__
+static const long double one = 1.0L, huge = 1e300L;
+#else
+static long double one = 1.0L, huge = 1e300L;
+#endif
+
+#ifdef __STDC__
+static const long double zero = 0.0L;
+#else
+static long double zero = 0.0L;
+#endif
+
+#ifdef __STDC__
+       long double __ieee754_atanhl(long double x)
+#else
+       long double __ieee754_atanhl(x)
+       long double x;
+#endif
+{
+       long double t;
+       int64_t hx,ix;
+       u_int64_t lx;
+       GET_LDOUBLE_WORDS64(hx,lx,x);
+       ix = hx&0x7fffffffffffffffLL;
+       if (ix >= 0x3ff0000000000000LL) { /* |x|>=1 */
+           if (ix > 0x3ff0000000000000LL)
+               return (x-x)/(x-x);
+           t = fabsl (x);
+           if (t > one)
+               return (x-x)/(x-x);
+           if (t == one)
+               return x/zero;
+       }
+       if(ix<0x3e20000000000000LL&&(huge+x)>zero) return x;    /* x<2**-29 */
+       x = fabsl (x);
+       if(ix<0x3fe0000000000000LL) {           /* x < 0.5 */
+           t = x+x;
+           t = 0.5*__log1pl(t+t*x/(one-x));
+       } else
+           t = 0.5*__log1pl((x+x)/(one-x));
+       if(hx>=0) return t; else return -t;
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_coshl.c b/sysdeps/ieee754/ldbl-128ibm/e_coshl.c
new file mode 100644 (file)
index 0000000..73cb478
--- /dev/null
@@ -0,0 +1,90 @@
+/* @(#)e_cosh.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.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: e_cosh.c,v 1.7 1995/05/10 20:44:58 jtc Exp $";
+#endif
+
+/* __ieee754_cosh(x)
+ * Method :
+ * mathematically cosh(x) if defined to be (exp(x)+exp(-x))/2
+ *     1. Replace x by |x| (cosh(x) = cosh(-x)).
+ *     2.
+ *                                                     [ exp(x) - 1 ]^2
+ *         0        <= x <= ln2/2  :  cosh(x) := 1 + -------------------
+ *                                                        2*exp(x)
+ *
+ *                                               exp(x) +  1/exp(x)
+ *         ln2/2    <= x <= 22     :  cosh(x) := -------------------
+ *                                                       2
+ *         22       <= x <= lnovft :  cosh(x) := exp(x)/2
+ *         lnovft   <= x <= ln2ovft:  cosh(x) := exp(x/2)/2 * exp(x/2)
+ *         ln2ovft  <  x           :  cosh(x) := huge*huge (overflow)
+ *
+ * Special cases:
+ *     cosh(x) is |x| if x is +INF, -INF, or NaN.
+ *     only cosh(0)=1 is exact for finite x.
+ */
+
+#include "math.h"
+#include "math_private.h"
+
+#ifdef __STDC__
+static const long double one = 1.0L, half=0.5L, huge = 1.0e300L;
+#else
+static long double one = 1.0L, half=0.5L, huge = 1.0e300L;
+#endif
+
+#ifdef __STDC__
+       long double __ieee754_coshl(long double x)
+#else
+       long double __ieee754_coshl(x)
+       long double x;
+#endif
+{
+       long double t,w;
+       int64_t ix;
+
+    /* High word of |x|. */
+       GET_LDOUBLE_MSW64(ix,x);
+       ix &= 0x7fffffffffffffffLL;
+
+    /* x is INF or NaN */
+       if(ix>=0x7ff0000000000000LL) return x*x;
+
+    /* |x| in [0,0.5*ln2], return 1+expm1(|x|)^2/(2*exp(|x|)) */
+       if(ix<0x3fd62e42fefa39efLL) {
+           t = __expm1l(fabsl(x));
+           w = one+t;
+           if (ix<0x3c80000000000000LL) return w;      /* cosh(tiny) = 1 */
+           return one+(t*t)/(w+w);
+       }
+
+    /* |x| in [0.5*ln2,22], return (exp(|x|)+1/exp(|x|)/2; */
+       if (ix < 0x4036000000000000LL) {
+               t = __ieee754_expl(fabsl(x));
+               return half*t+half/t;
+       }
+
+    /* |x| in [22, log(maxdouble)] return half*exp(|x|) */
+       if (ix < 0x40862e42fefa39efLL)  return half*__ieee754_expl(fabsl(x));
+
+    /* |x| in [log(maxdouble), overflowthresold] */
+        if (ix < 0x408633ce8fb9f87dLL) {
+           w = __ieee754_expl(half*fabsl(x));
+           t = half*w;
+           return t*w;
+       }
+
+    /* |x| > overflowthresold, cosh(x) overflow */
+       return huge*huge;
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_expl.c b/sysdeps/ieee754/ldbl-128ibm/e_expl.c
new file mode 100644 (file)
index 0000000..3c4088f
--- /dev/null
@@ -0,0 +1,257 @@
+/* Quad-precision floating point e^x.
+   Copyright (C) 1999,2004,2006 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Jakub Jelinek <jj@ultra.linux.cz>
+   Partly based on double-precision code
+   by Geoffrey Keating <geoffk@ozemail.com.au>
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+/* The basic design here is from
+   Abraham Ziv, "Fast Evaluation of Elementary Mathematical Functions with
+   Correctly Rounded Last Bit", ACM Trans. Math. Soft., 17 (3), September 1991,
+   pp. 410-423.
+
+   We work with number pairs where the first number is the high part and
+   the second one is the low part. Arithmetic with the high part numbers must
+   be exact, without any roundoff errors.
+
+   The input value, X, is written as
+   X = n * ln(2)_0 + arg1[t1]_0 + arg2[t2]_0 + x
+       - n * ln(2)_1 + arg1[t1]_1 + arg2[t2]_1 + xl
+
+   where:
+   - n is an integer, 16384 >= n >= -16495;
+   - ln(2)_0 is the first 93 bits of ln(2), and |ln(2)_0-ln(2)-ln(2)_1| < 2^-205
+   - t1 is an integer, 89 >= t1 >= -89
+   - t2 is an integer, 65 >= t2 >= -65
+   - |arg1[t1]-t1/256.0| < 2^-53
+   - |arg2[t2]-t2/32768.0| < 2^-53
+   - x + xl is whatever is left, |x + xl| < 2^-16 + 2^-53
+
+   Then e^x is approximated as
+
+   e^x = 2^n_1 ( 2^n_0 e^(arg1[t1]_0 + arg1[t1]_1) e^(arg2[t2]_0 + arg2[t2]_1)
+              + 2^n_0 e^(arg1[t1]_0 + arg1[t1]_1) e^(arg2[t2]_0 + arg2[t2]_1)
+                * p (x + xl + n * ln(2)_1))
+   where:
+   - p(x) is a polynomial approximating e(x)-1
+   - e^(arg1[t1]_0 + arg1[t1]_1) is obtained from a table
+   - e^(arg2[t2]_0 + arg2[t2]_1) likewise
+   - n_1 + n_0 = n, so that |n_0| < -LDBL_MIN_EXP-1.
+
+   If it happens that n_1 == 0 (this is the usual case), that multiplication
+   is omitted.
+   */
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <float.h>
+#include <ieee754.h>
+#include <math.h>
+#include <fenv.h>
+#include <inttypes.h>
+#include <math_private.h>
+#include <sysdeps/ieee754/ldbl-128/t_expl.h>
+
+static const long double C[] = {
+/* Smallest integer x for which e^x overflows.  */
+#define himark C[0]
+ 709.08956571282405153382846025171462914L,
+
+/* Largest integer x for which e^x underflows.  */
+#define lomark C[1]
+-709.08956571282405153382846025171462914L,
+
+/* 3x2^96 */
+#define THREEp96 C[2]
+ 59421121885698253195157962752.0L,
+
+/* 3x2^103 */
+#define THREEp103 C[3]
+ 30423614405477505635920876929024.0L,
+
+/* 3x2^111 */
+#define THREEp111 C[4]
+ 7788445287802241442795744493830144.0L,
+
+/* 1/ln(2) */
+#define M_1_LN2 C[5]
+ 1.44269504088896340735992468100189204L,
+
+/* first 93 bits of ln(2) */
+#define M_LN2_0 C[6]
+ 0.693147180559945309417232121457981864L,
+
+/* ln2_0 - ln(2) */
+#define M_LN2_1 C[7]
+-1.94704509238074995158795957333327386E-31L,
+
+/* very small number */
+#define TINY C[8]
+ 1.0e-308L,
+
+/* 2^16383 */
+#define TWO1023 C[9]
+ 8.988465674311579538646525953945123668E+307L,
+
+/* 256 */
+#define TWO8 C[10]
+ 256.0L,
+
+/* 32768 */
+#define TWO15 C[11]
+ 32768.0L,
+
+/* Chebyshev polynom coeficients for (exp(x)-1)/x */
+#define P1 C[12]
+#define P2 C[13]
+#define P3 C[14]
+#define P4 C[15]
+#define P5 C[16]
+#define P6 C[17]
+ 0.5L,
+ 1.66666666666666666666666666666666683E-01L,
+ 4.16666666666666666666654902320001674E-02L,
+ 8.33333333333333333333314659767198461E-03L,
+ 1.38888888889899438565058018857254025E-03L,
+ 1.98412698413981650382436541785404286E-04L,
+};
+
+long double
+__ieee754_expl (long double x)
+{
+  /* Check for usual case.  */
+  if (isless (x, himark) && isgreater (x, lomark))
+    {
+      int tval1, tval2, unsafe, n_i, exponent2;
+      long double x22, n, result, xl;
+      union ibm_extended_long_double ex2_u, scale_u;
+      fenv_t oldenv;
+
+      feholdexcept (&oldenv);
+#ifdef FE_TONEAREST
+      fesetround (FE_TONEAREST);
+#endif
+
+      n = roundl(x*M_1_LN2);
+      x = x-n*M_LN2_0;
+      xl = n*M_LN2_1;
+
+      tval1 = roundl(x*TWO8);
+      x -= __expl_table[T_EXPL_ARG1+2*tval1];
+      xl -= __expl_table[T_EXPL_ARG1+2*tval1+1];
+
+      tval2 = roundl(x*TWO15);
+      x -= __expl_table[T_EXPL_ARG2+2*tval2];
+      xl -= __expl_table[T_EXPL_ARG2+2*tval2+1];
+
+      x = x + xl;
+
+      /* Compute ex2 = 2^n_0 e^(argtable[tval1]) e^(argtable[tval2]).  */
+      ex2_u.d = __expl_table[T_EXPL_RES1 + tval1]
+               * __expl_table[T_EXPL_RES2 + tval2];
+      n_i = (int)n;
+      /* 'unsafe' is 1 iff n_1 != 0.  */
+      unsafe = fabsl(n_i) >= -LDBL_MIN_EXP - 1;
+      ex2_u.ieee.exponent += n_i >> unsafe;
+      /* Fortunately, there are no subnormal lowpart doubles in
+        __expl_table, only normal values and zeros.
+        But after scaling it can be subnormal.  */
+      exponent2 = ex2_u.ieee.exponent2 + (n_i >> unsafe);
+      if (ex2_u.ieee.exponent2 == 0)
+       /* assert ((ex2_u.ieee.mantissa2|ex2_u.ieee.mantissa3) == 0) */;
+      else if (exponent2 > 0)
+       ex2_u.ieee.exponent2 = exponent2;
+      else if (exponent2 <= -54)
+       {
+         ex2_u.ieee.exponent2 = 0;
+         ex2_u.ieee.mantissa2 = 0;
+         ex2_u.ieee.mantissa3 = 0;
+       }
+      else
+       {
+         static const double
+           two54 = 1.80143985094819840000e+16, /* 4350000000000000 */
+           twom54 = 5.55111512312578270212e-17; /* 3C90000000000000 */
+         ex2_u.dd[1] *= two54;
+         ex2_u.ieee.exponent2 += n_i >> unsafe;
+         ex2_u.dd[1] *= twom54;
+       }
+
+      /* Compute scale = 2^n_1.  */
+      scale_u.d = 1.0L;
+      scale_u.ieee.exponent += n_i - (n_i >> unsafe);
+
+      /* Approximate e^x2 - 1, using a seventh-degree polynomial,
+        with maximum error in [-2^-16-2^-53,2^-16+2^-53]
+        less than 4.8e-39.  */
+      x22 = x + x*x*(P1+x*(P2+x*(P3+x*(P4+x*(P5+x*P6)))));
+
+      /* Return result.  */
+      fesetenv (&oldenv);
+
+      result = x22 * ex2_u.d + ex2_u.d;
+
+      /* Now we can test whether the result is ultimate or if we are unsure.
+        In the later case we should probably call a mpn based routine to give
+        the ultimate result.
+        Empirically, this routine is already ultimate in about 99.9986% of
+        cases, the test below for the round to nearest case will be false
+        in ~ 99.9963% of cases.
+        Without proc2 routine maximum error which has been seen is
+        0.5000262 ulp.
+
+         union ieee854_long_double ex3_u;
+
+         #ifdef FE_TONEAREST
+           fesetround (FE_TONEAREST);
+         #endif
+         ex3_u.d = (result - ex2_u.d) - x22 * ex2_u.d;
+         ex2_u.d = result;
+         ex3_u.ieee.exponent += LDBL_MANT_DIG + 15 + IEEE854_LONG_DOUBLE_BIAS
+                                - ex2_u.ieee.exponent;
+         n_i = abs (ex3_u.d);
+         n_i = (n_i + 1) / 2;
+         fesetenv (&oldenv);
+         #ifdef FE_TONEAREST
+         if (fegetround () == FE_TONEAREST)
+           n_i -= 0x4000;
+         #endif
+         if (!n_i) {
+           return __ieee754_expl_proc2 (origx);
+         }
+       */
+      if (!unsafe)
+       return result;
+      else
+       return result * scale_u.d;
+    }
+  /* Exceptional cases:  */
+  else if (isless (x, himark))
+    {
+      if (__isinfl (x))
+       /* e^-inf == 0, with no error.  */
+       return 0;
+      else
+       /* Underflow */
+       return TINY * TINY;
+    }
+  else
+    /* Return x, if x is a NaN or Inf; or overflow, otherwise.  */
+    return TWO1023*x;
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_fmodl.c b/sysdeps/ieee754/ldbl-128ibm/e_fmodl.c
new file mode 100644 (file)
index 0000000..9666873
--- /dev/null
@@ -0,0 +1,145 @@
+/* e_fmodl.c -- long double version of e_fmod.c.
+ * Conversion to IEEE quad long double by Jakub Jelinek, jj@ultra.linux.cz.
+ */
+/*
+ * ====================================================
+ * 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_fmodl(x,y)
+ * Return x mod y in exact arithmetic
+ * Method: shift and subtract
+ */
+
+#include "math.h"
+#include "math_private.h"
+#include <ieee754.h>
+
+#ifdef __STDC__
+static const long double one = 1.0, Zero[] = {0.0, -0.0,};
+#else
+static long double one = 1.0, Zero[] = {0.0, -0.0,};
+#endif
+
+#ifdef __STDC__
+       long double __ieee754_fmodl(long double x, long double y)
+#else
+       long double __ieee754_fmodl(x,y)
+       long double x,y;
+#endif
+{
+       int64_t n,hx,hy,hz,ix,iy,sx,i;
+       u_int64_t lx,ly,lz;
+       int temp;
+
+       GET_LDOUBLE_WORDS64(hx,lx,x);
+       GET_LDOUBLE_WORDS64(hy,ly,y);
+       sx = hx&0x8000000000000000ULL;          /* sign of x */
+       hx ^=sx;                                /* |x| */
+       hy &= 0x7fffffffffffffffLL;             /* |y| */
+
+    /* purge off exception values */
+       if((hy|(ly&0x7fffffffffffffff))==0||(hx>=0x7ff0000000000000LL)|| /* y=0,or x not finite */
+         (hy>0x7ff0000000000000LL))    /* or y is NaN */
+           return (x*y)/(x*y);
+       if(hx<=hy) {
+           if((hx<hy)||(lx<ly)) return x;      /* |x|<|y| return x */
+           if(lx==ly)
+               return Zero[(u_int64_t)sx>>63]; /* |x|=|y| return x*0*/
+       }
+
+    /* determine ix = ilogb(x) */
+       if(hx<0x0010000000000000LL) {   /* subnormal x */
+           if(hx==0) {
+               for (ix = -1043, i=lx; i>0; i<<=1) ix -=1;
+           } else {
+               for (ix = -1022, i=hx<<19; i>0; i<<=1) ix -=1;
+           }
+       } else ix = (hx>>52)-0x3ff;
+
+    /* determine iy = ilogb(y) */
+       if(hy<0x0010000000000000LL) {   /* subnormal y */
+           if(hy==0) {
+               for (iy = -1043, i=ly; i>0; i<<=1) iy -=1;
+           } else {
+               for (iy = -1022, i=hy<<19; i>0; i<<=1) iy -=1;
+           }
+       } else iy = (hy>>52)-0x3ff;
+
+    /* Make the IBM extended format 105 bit mantissa look like the ieee854 112
+       bit mantissa so the following operatations will give the correct
+       result.  */
+        EXTRACT_IBM_EXTENDED_MANTISSA(hx, lx, temp, x);
+        EXTRACT_IBM_EXTENDED_MANTISSA(hy, ly, temp, y);
+
+    /* set up {hx,lx}, {hy,ly} and align y to x */
+       if(ix >= -1022)
+           hx = 0x0001000000000000LL|(0x0000ffffffffffffLL&hx);
+       else {          /* subnormal x, shift x to normal */
+           n = -1022-ix;
+           if(n<=63) {
+               hx = (hx<<n)|(lx>>(64-n));
+               lx <<= n;
+           } else {
+               hx = lx<<(n-64);
+               lx = 0;
+           }
+       }
+       if(iy >= -1022)
+           hy = 0x0001000000000000LL|(0x0000ffffffffffffLL&hy);
+       else {          /* subnormal y, shift y to normal */
+           n = -1022-iy;
+           if(n<=63) {
+               hy = (hy<<n)|(ly>>(64-n));
+               ly <<= n;
+           } else {
+               hy = ly<<(n-64);
+               ly = 0;
+           }
+       }
+
+    /* fix point fmod */
+       n = ix - iy;
+       while(n--) {
+           hz=hx-hy;lz=lx-ly; if(lx<ly) hz -= 1;
+           if(hz<0){hx = hx+hx+(lx>>63); lx = lx+lx;}
+           else {
+               if((hz|(lz&0x7fffffffffffffff))==0)             /* return sign(x)*0 */
+                   return Zero[(u_int64_t)sx>>63];
+               hx = hz+hz+(lz>>63); lx = lz+lz;
+           }
+       }
+       hz=hx-hy;lz=lx-ly; if(lx<ly) hz -= 1;
+       if(hz>=0) {hx=hz;lx=lz;}
+
+    /* convert back to floating value and restore the sign */
+       if((hx|(lx&0x7fffffffffffffff))==0)                     /* return sign(x)*0 */
+           return Zero[(u_int64_t)sx>>63];
+       while(hx<0x0001000000000000LL) {        /* normalize x */
+           hx = hx+hx+(lx>>63); lx = lx+lx;
+           iy -= 1;
+       }
+       if(iy>= -1022) {        /* normalize output */
+           INSERT_IBM_EXTENDED_MANTISSA(x, (sx>>63), iy, hx, lx);
+       } else {                /* subnormal output */
+           n = -1022 - iy;
+           if(n<=48) {
+               lx = (lx>>n)|((u_int64_t)hx<<(64-n));
+               hx >>= n;
+           } else if (n<=63) {
+               lx = (hx<<(64-n))|(lx>>n); hx = sx;
+           } else {
+               lx = hx>>(n-64); hx = sx;
+           }
+           INSERT_IBM_EXTENDED_MANTISSA(x, (sx>>63), iy, hx, lx);
+           x *= one;           /* create necessary signal */
+       }
+       return x;               /* exact output */
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_gammal_r.c b/sysdeps/ieee754/ldbl-128ibm/e_gammal_r.c
new file mode 100644 (file)
index 0000000..03bcb21
--- /dev/null
@@ -0,0 +1,58 @@
+/* Implementation of gamma function according to ISO C.
+   Copyright (C) 1997,1999,2002,2004,2006 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997 and
+                 Jakub Jelinek <jj@ultra.linux.cz, 1999.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; 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>
+
+
+long double
+__ieee754_gammal_r (long double x, int *signgamp)
+{
+  /* We don't have a real gamma implementation now.  We'll use lgamma
+     and the exp function.  But due to the required boundary
+     conditions we must check some values separately.  */
+  int64_t hx;
+  u_int64_t lx;
+
+  GET_LDOUBLE_WORDS64 (hx, lx, x);
+
+  if (((hx | lx) & 0x7fffffffffffffffLL) == 0)
+    {
+      /* Return value for x == 0 is Inf with divide by zero exception.  */
+      *signgamp = 0;
+      return 1.0 / x;
+    }
+  if (hx < 0 && (u_int64_t) hx < 0xfff0000000000000ULL && __rintl (x) == x)
+    {
+      /* Return value for integer x < 0 is NaN with invalid exception.  */
+      *signgamp = 0;
+      return (x - x) / (x - x);
+    }
+  if (hx == 0xfff0000000000000ULL)
+    {
+      /* x == -Inf.  According to ISO this is NaN.  */
+      *signgamp = 0;
+      return x - x;
+    }
+
+  /* XXX FIXME.  */
+  return __ieee754_expl (__ieee754_lgammal_r (x, signgamp));
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_hypotl.c b/sysdeps/ieee754/ldbl-128ibm/e_hypotl.c
new file mode 100644 (file)
index 0000000..4330f28
--- /dev/null
@@ -0,0 +1,131 @@
+/* @(#)e_hypotl.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.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: e_hypotl.c,v 1.9 1995/05/12 04:57:27 jtc Exp $";
+#endif
+
+/* __ieee754_hypotl(x,y)
+ *
+ * Method :
+ *     If (assume round-to-nearest) z=x*x+y*y
+ *     has error less than sqrtl(2)/2 ulp, than
+ *     sqrtl(z) has error less than 1 ulp (exercise).
+ *
+ *     So, compute sqrtl(x*x+y*y) with some care as
+ *     follows to get the error below 1 ulp:
+ *
+ *     Assume x>y>0;
+ *     (if possible, set rounding to round-to-nearest)
+ *     1. if x > 2y  use
+ *             x1*x1+(y*y+(x2*(x+x1))) for x*x+y*y
+ *     where x1 = x with lower 53 bits cleared, x2 = x-x1; else
+ *     2. if x <= 2y use
+ *             t1*y1+((x-y)*(x-y)+(t1*y2+t2*y))
+ *     where t1 = 2x with lower 53 bits cleared, t2 = 2x-t1,
+ *     y1= y with lower 53 bits chopped, y2 = y-y1.
+ *
+ *     NOTE: scaling may be necessary if some argument is too
+ *           large or too tiny
+ *
+ * Special cases:
+ *     hypotl(x,y) is INF if x or y is +INF or -INF; else
+ *     hypotl(x,y) is NAN if x or y is NAN.
+ *
+ * Accuracy:
+ *     hypotl(x,y) returns sqrtl(x^2+y^2) with error less
+ *     than 1 ulps (units in the last place)
+ */
+
+#include "math.h"
+#include "math_private.h"
+
+static const long double two600 = 0x1.0p+600L;
+static const long double two1022 = 0x1.0p+1022L;
+
+#ifdef __STDC__
+       long double __ieee754_hypotl(long double x, long double y)
+#else
+       long double __ieee754_hypotl(x,y)
+       long double x, y;
+#endif
+{
+       long double a,b,t1,t2,y1,y2,w,kld;
+       int64_t j,k,ha,hb;
+
+       GET_LDOUBLE_MSW64(ha,x);
+       ha &= 0x7fffffffffffffffLL;
+       GET_LDOUBLE_MSW64(hb,y);
+       hb &= 0x7fffffffffffffffLL;
+       if(hb > ha) {a=y;b=x;j=ha; ha=hb;hb=j;} else {a=x;b=y;}
+       a = fabsl(a);   /* a <- |a| */
+       b = fabsl(b);   /* b <- |b| */
+       if((ha-hb)>0x3c0000000000000LL) {return a+b;} /* x/y > 2**60 */
+       k=0;
+       kld = 1.0L;
+       if(ha > 0x5f30000000000000LL) { /* a>2**500 */
+          if(ha >= 0x7ff0000000000000LL) {     /* Inf or NaN */
+              u_int64_t low;
+              w = a+b;                 /* for sNaN */
+              GET_LDOUBLE_LSW64(low,a);
+              if(((ha&0xfffffffffffffLL)|(low&0x7fffffffffffffffLL))==0)
+                w = a;
+              GET_LDOUBLE_LSW64(low,b);
+              if(((hb^0x7ff0000000000000LL)|(low&0x7fffffffffffffffLL))==0)
+                w = b;
+              return w;
+          }
+          /* scale a and b by 2**-600 */
+          ha -= 0x2580000000000000LL; hb -= 0x2580000000000000LL; k += 600;
+          a /= two600;
+          b /= two600;
+          k += 600;
+          kld = two600;
+       }
+       if(hb < 0x20b0000000000000LL) { /* b < 2**-500 */
+           if(hb <= 0x000fffffffffffffLL) {    /* subnormal b or 0 */
+               u_int64_t low;
+               GET_LDOUBLE_LSW64(low,b);
+               if((hb|(low&0x7fffffffffffffffLL))==0) return a;
+               t1=two1022;     /* t1=2^1022 */
+               b *= t1;
+               a *= t1;
+               k -= 1022;
+               kld = kld / two1022;
+           } else {            /* scale a and b by 2^600 */
+               ha += 0x2580000000000000LL;     /* a *= 2^600 */
+               hb += 0x2580000000000000LL;     /* b *= 2^600 */
+               k -= 600;
+               a *= two600;
+               b *= two600;
+               kld = kld / two600;
+           }
+       }
+    /* medium size a and b */
+       w = a-b;
+       if (w>b) {
+           SET_LDOUBLE_WORDS64(t1,ha,0);
+           t2 = a-t1;
+           w  = __ieee754_sqrtl(t1*t1-(b*(-b)-t2*(a+t1)));
+       } else {
+           a  = a+a;
+           SET_LDOUBLE_WORDS64(y1,hb,0);
+           y2 = b - y1;
+           SET_LDOUBLE_WORDS64(t1,ha+0x0010000000000000LL,0);
+           t2 = a - t1;
+           w  = __ieee754_sqrtl(t1*y1-(w*(-w)-(t1*y2+t2*b)));
+       }
+       if(k!=0)
+           return w*kld;
+       else
+           return w;
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_j0l.c b/sysdeps/ieee754/ldbl-128ibm/e_j0l.c
new file mode 100644 (file)
index 0000000..39a238a
--- /dev/null
@@ -0,0 +1,3 @@
+/* Looks like we can use ieee854 e_j0l.c as is for IBM extended format. */
+#include <sysdeps/ieee754/ldbl-128/e_j0l.c>
+
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_j1l.c b/sysdeps/ieee754/ldbl-128ibm/e_j1l.c
new file mode 100644 (file)
index 0000000..c86e24f
--- /dev/null
@@ -0,0 +1,2 @@
+/* Looks like we can use ieee854 e_j1l.c as is for IBM extended format. */
+#include <sysdeps/ieee754/ldbl-128/e_j1l.c>
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_jnl.c b/sysdeps/ieee754/ldbl-128ibm/e_jnl.c
new file mode 100644 (file)
index 0000000..0eea745
--- /dev/null
@@ -0,0 +1,402 @@
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+/* Modifications for 128-bit long double are
+   Copyright (C) 2001 Stephen L. Moshier <moshier@na-net.ornl.gov>
+   and are incorporated herein by permission of the author.  The author
+   reserves the right to distribute this material elsewhere under different
+   copying permissions.  These modifications are distributed here under
+   the following terms:
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA */
+
+/*
+ * __ieee754_jn(n, x), __ieee754_yn(n, x)
+ * floating point Bessel's function of the 1st and 2nd kind
+ * of order n
+ *
+ * Special cases:
+ *     y0(0)=y1(0)=yn(n,0) = -inf with division by zero signal;
+ *     y0(-ve)=y1(-ve)=yn(n,-ve) are NaN with invalid signal.
+ * Note 2. About jn(n,x), yn(n,x)
+ *     For n=0, j0(x) is called,
+ *     for n=1, j1(x) is called,
+ *     for n<x, forward recursion us used starting
+ *     from values of j0(x) and j1(x).
+ *     for n>x, a continued fraction approximation to
+ *     j(n,x)/j(n-1,x) is evaluated and then backward
+ *     recursion is used starting from a supposed value
+ *     for j(n,x). The resulting value of j(0,x) is
+ *     compared with the actual value to correct the
+ *     supposed value of j(n,x).
+ *
+ *     yn(n,x) is similar in all respects, except
+ *     that forward recursion is used for all
+ *     values of n>1.
+ *
+ */
+
+#include "math.h"
+#include "math_private.h"
+
+#ifdef __STDC__
+static const long double
+#else
+static long double
+#endif
+  invsqrtpi = 5.6418958354775628694807945156077258584405E-1L,
+  two = 2.0e0L,
+  one = 1.0e0L,
+  zero = 0.0L;
+
+
+#ifdef __STDC__
+long double
+__ieee754_jnl (int n, long double x)
+#else
+long double
+__ieee754_jnl (n, x)
+     int n;
+     long double x;
+#endif
+{
+  u_int32_t se;
+  int32_t i, ix, sgn;
+  long double a, b, temp, di;
+  long double z, w;
+  ieee854_long_double_shape_type u;
+
+
+  /* J(-n,x) = (-1)^n * J(n, x), J(n, -x) = (-1)^n * J(n, x)
+   * Thus, J(-n,x) = J(n,-x)
+   */
+
+  u.value = x;
+  se = u.parts32.w0;
+  ix = se & 0x7fffffff;
+
+  /* if J(n,NaN) is NaN */
+  if (ix >= 0x7ff00000)
+    {
+      if ((u.parts32.w0 & 0xfffff) | u.parts32.w1
+         | (u.parts32.w2 & 0x7fffffff) | u.parts32.w3)
+       return x + x;
+    }
+
+  if (n < 0)
+    {
+      n = -n;
+      x = -x;
+      se ^= 0x80000000;
+    }
+  if (n == 0)
+    return (__ieee754_j0l (x));
+  if (n == 1)
+    return (__ieee754_j1l (x));
+  sgn = (n & 1) & (se >> 31);  /* even n -- 0, odd n -- sign(x) */
+  x = fabsl (x);
+
+  if (x == 0.0L || ix >= 0x7ff00000)   /* if x is 0 or inf */
+    b = zero;
+  else if ((long double) n <= x)
+    {
+      /* Safe to use J(n+1,x)=2n/x *J(n,x)-J(n-1,x) */
+      if (ix >= 0x52d00000)
+       {                       /* x > 2**302 */
+
+         /* ??? Could use an expansion for large x here.  */
+
+         /* (x >> n**2)
+          *      Jn(x) = cos(x-(2n+1)*pi/4)*sqrt(2/x*pi)
+          *      Yn(x) = sin(x-(2n+1)*pi/4)*sqrt(2/x*pi)
+          *      Let s=sin(x), c=cos(x),
+          *          xn=x-(2n+1)*pi/4, sqt2 = sqrt(2),then
+          *
+          *             n    sin(xn)*sqt2    cos(xn)*sqt2
+          *          ----------------------------------
+          *             0     s-c             c+s
+          *             1    -s-c            -c+s
+          *             2    -s+c            -c-s
+          *             3     s+c             c-s
+          */
+         long double s;
+         long double c;
+         __sincosl (x, &s, &c);
+         switch (n & 3)
+           {
+           case 0:
+             temp = c + s;
+             break;
+           case 1:
+             temp = -c + s;
+             break;
+           case 2:
+             temp = -c - s;
+             break;
+           case 3:
+             temp = c - s;
+             break;
+           }
+         b = invsqrtpi * temp / __ieee754_sqrtl (x);
+       }
+      else
+       {
+         a = __ieee754_j0l (x);
+         b = __ieee754_j1l (x);
+         for (i = 1; i < n; i++)
+           {
+             temp = b;
+             b = b * ((long double) (i + i) / x) - a;  /* avoid underflow */
+             a = temp;
+           }
+       }
+    }
+  else
+    {
+      if (ix < 0x3e100000)
+       {                       /* x < 2**-29 */
+         /* x is tiny, return the first Taylor expansion of J(n,x)
+          * J(n,x) = 1/n!*(x/2)^n  - ...
+          */
+         if (n >= 33)          /* underflow, result < 10^-300 */
+           b = zero;
+         else
+           {
+             temp = x * 0.5;
+             b = temp;
+             for (a = one, i = 2; i <= n; i++)
+               {
+                 a *= (long double) i; /* a = n! */
+                 b *= temp;    /* b = (x/2)^n */
+               }
+             b = b / a;
+           }
+       }
+      else
+       {
+         /* use backward recurrence */
+         /*                      x      x^2      x^2
+          *  J(n,x)/J(n-1,x) =  ----   ------   ------   .....
+          *                      2n  - 2(n+1) - 2(n+2)
+          *
+          *                      1      1        1
+          *  (for large x)   =  ----  ------   ------   .....
+          *                      2n   2(n+1)   2(n+2)
+          *                      -- - ------ - ------ -
+          *                       x     x         x
+          *
+          * Let w = 2n/x and h=2/x, then the above quotient
+          * is equal to the continued fraction:
+          *                  1
+          *      = -----------------------
+          *                     1
+          *         w - -----------------
+          *                        1
+          *              w+h - ---------
+          *                     w+2h - ...
+          *
+          * To determine how many terms needed, let
+          * Q(0) = w, Q(1) = w(w+h) - 1,
+          * Q(k) = (w+k*h)*Q(k-1) - Q(k-2),
+          * When Q(k) > 1e4      good for single
+          * When Q(k) > 1e9      good for double
+          * When Q(k) > 1e17     good for quadruple
+          */
+         /* determine k */
+         long double t, v;
+         long double q0, q1, h, tmp;
+         int32_t k, m;
+         w = (n + n) / (long double) x;
+         h = 2.0L / (long double) x;
+         q0 = w;
+         z = w + h;
+         q1 = w * z - 1.0L;
+         k = 1;
+         while (q1 < 1.0e17L)
+           {
+             k += 1;
+             z += h;
+             tmp = z * q1 - q0;
+             q0 = q1;
+             q1 = tmp;
+           }
+         m = n + n;
+         for (t = zero, i = 2 * (n + k); i >= m; i -= 2)
+           t = one / (i / x - t);
+         a = t;
+         b = one;
+         /*  estimate log((2/x)^n*n!) = n*log(2/x)+n*ln(n)
+          *  Hence, if n*(log(2n/x)) > ...
+          *  single 8.8722839355e+01
+          *  double 7.09782712893383973096e+02
+          *  long double 1.1356523406294143949491931077970765006170e+04
+          *  then recurrent value may overflow and the result is
+          *  likely underflow to zero
+          */
+         tmp = n;
+         v = two / x;
+         tmp = tmp * __ieee754_logl (fabsl (v * tmp));
+
+         if (tmp < 1.1356523406294143949491931077970765006170e+04L)
+           {
+             for (i = n - 1, di = (long double) (i + i); i > 0; i--)
+               {
+                 temp = b;
+                 b *= di;
+                 b = b / x - a;
+                 a = temp;
+                 di -= two;
+               }
+           }
+         else
+           {
+             for (i = n - 1, di = (long double) (i + i); i > 0; i--)
+               {
+                 temp = b;
+                 b *= di;
+                 b = b / x - a;
+                 a = temp;
+                 di -= two;
+                 /* scale b to avoid spurious overflow */
+                 if (b > 1e100L)
+                   {
+                     a /= b;
+                     t /= b;
+                     b = one;
+                   }
+               }
+           }
+         b = (t * __ieee754_j0l (x) / b);
+       }
+    }
+  if (sgn == 1)
+    return -b;
+  else
+    return b;
+}
+
+#ifdef __STDC__
+long double
+__ieee754_ynl (int n, long double x)
+#else
+long double
+__ieee754_ynl (n, x)
+     int n;
+     long double x;
+#endif
+{
+  u_int32_t se;
+  int32_t i, ix;
+  int32_t sign;
+  long double a, b, temp;
+  ieee854_long_double_shape_type u;
+
+  u.value = x;
+  se = u.parts32.w0;
+  ix = se & 0x7fffffff;
+
+  /* if Y(n,NaN) is NaN */
+  if (ix >= 0x7ff00000)
+    {
+      if ((u.parts32.w0 & 0xfffff) | u.parts32.w1
+         | (u.parts32.w2 & 0x7fffffff) | u.parts32.w3)
+       return x + x;
+    }
+  if (x <= 0.0L)
+    {
+      if (x == 0.0L)
+       return -HUGE_VALL + x;
+      if (se & 0x80000000)
+       return zero / (zero * x);
+    }
+  sign = 1;
+  if (n < 0)
+    {
+      n = -n;
+      sign = 1 - ((n & 1) << 1);
+    }
+  if (n == 0)
+    return (__ieee754_y0l (x));
+  if (n == 1)
+    return (sign * __ieee754_y1l (x));
+  if (ix >= 0x7ff00000)
+    return zero;
+  if (ix >= 0x52D00000)
+    {                          /* x > 2**302 */
+
+      /* ??? See comment above on the possible futility of this.  */
+
+      /* (x >> n**2)
+       *      Jn(x) = cos(x-(2n+1)*pi/4)*sqrt(2/x*pi)
+       *      Yn(x) = sin(x-(2n+1)*pi/4)*sqrt(2/x*pi)
+       *      Let s=sin(x), c=cos(x),
+       *          xn=x-(2n+1)*pi/4, sqt2 = sqrt(2),then
+       *
+       *             n    sin(xn)*sqt2    cos(xn)*sqt2
+       *          ----------------------------------
+       *             0     s-c             c+s
+       *             1    -s-c            -c+s
+       *             2    -s+c            -c-s
+       *             3     s+c             c-s
+       */
+      long double s;
+      long double c;
+      __sincosl (x, &s, &c);
+      switch (n & 3)
+       {
+       case 0:
+         temp = s - c;
+         break;
+       case 1:
+         temp = -s - c;
+         break;
+       case 2:
+         temp = -s + c;
+         break;
+       case 3:
+         temp = s + c;
+         break;
+       }
+      b = invsqrtpi * temp / __ieee754_sqrtl (x);
+    }
+  else
+    {
+      a = __ieee754_y0l (x);
+      b = __ieee754_y1l (x);
+      /* quit if b is -inf */
+      u.value = b;
+      se = u.parts32.w0 & 0xfff00000;
+      for (i = 1; i < n && se != 0xfff00000; i++)
+       {
+         temp = b;
+         b = ((long double) (i + i) / x) * b - a;
+         u.value = b;
+         se = u.parts32.w0 & 0xfff00000;
+         a = temp;
+       }
+    }
+  if (sign > 0)
+    return b;
+  else
+    return -b;
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_lgammal_r.c b/sysdeps/ieee754/ldbl-128ibm/e_lgammal_r.c
new file mode 100644 (file)
index 0000000..9bcaaf7
--- /dev/null
@@ -0,0 +1,3 @@
+/* Looks like we can use ieee854 e_lgammal_r.c as is for IBM extended format. */
+#include <sysdeps/ieee754/ldbl-128/e_lgammal_r.c>
+
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_log10l.c b/sysdeps/ieee754/ldbl-128ibm/e_log10l.c
new file mode 100644 (file)
index 0000000..27e2c71
--- /dev/null
@@ -0,0 +1,258 @@
+/*                                                     log10l.c
+ *
+ *     Common logarithm, 128-bit long double precision
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * long double x, y, log10l();
+ *
+ * y = log10l( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns the base 10 logarithm of x.
+ *
+ * The argument is separated into its exponent and fractional
+ * parts.  If the exponent is between -1 and +1, the logarithm
+ * of the fraction is approximated by
+ *
+ *     log(1+x) = x - 0.5 x^2 + x^3 P(x)/Q(x).
+ *
+ * Otherwise, setting  z = 2(x-1)/x+1),
+ *
+ *     log(x) = z + z^3 P(z)/Q(z).
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      0.5, 2.0     30000      2.3e-34     4.9e-35
+ *    IEEE     exp(+-10000)  30000      1.0e-34     4.1e-35
+ *
+ * In the tests over the interval exp(+-10000), the logarithms
+ * of the random arguments were uniformly distributed over
+ * [-10000, +10000].
+ *
+ */
+
+/*
+   Cephes Math Library Release 2.2:  January, 1991
+   Copyright 1984, 1991 by Stephen L. Moshier
+   Adapted for glibc November, 2001
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; 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"
+
+/* Coefficients for ln(1+x) = x - x**2/2 + x**3 P(x)/Q(x)
+ * 1/sqrt(2) <= x < sqrt(2)
+ * Theoretical peak relative error = 5.3e-37,
+ * relative peak error spread = 2.3e-14
+ */
+static const long double P[13] =
+{
+  1.313572404063446165910279910527789794488E4L,
+  7.771154681358524243729929227226708890930E4L,
+  2.014652742082537582487669938141683759923E5L,
+  3.007007295140399532324943111654767187848E5L,
+  2.854829159639697837788887080758954924001E5L,
+  1.797628303815655343403735250238293741397E5L,
+  7.594356839258970405033155585486712125861E4L,
+  2.128857716871515081352991964243375186031E4L,
+  3.824952356185897735160588078446136783779E3L,
+  4.114517881637811823002128927449878962058E2L,
+  2.321125933898420063925789532045674660756E1L,
+  4.998469661968096229986658302195402690910E-1L,
+  1.538612243596254322971797716843006400388E-6L
+};
+static const long double Q[12] =
+{
+  3.940717212190338497730839731583397586124E4L,
+  2.626900195321832660448791748036714883242E5L,
+  7.777690340007566932935753241556479363645E5L,
+  1.347518538384329112529391120390701166528E6L,
+  1.514882452993549494932585972882995548426E6L,
+  1.158019977462989115839826904108208787040E6L,
+  6.132189329546557743179177159925690841200E5L,
+  2.248234257620569139969141618556349415120E5L,
+  5.605842085972455027590989944010492125825E4L,
+  9.147150349299596453976674231612674085381E3L,
+  9.104928120962988414618126155557301584078E2L,
+  4.839208193348159620282142911143429644326E1L
+/* 1.000000000000000000000000000000000000000E0L, */
+};
+
+/* Coefficients for log(x) = z + z^3 P(z^2)/Q(z^2),
+ * where z = 2(x-1)/(x+1)
+ * 1/sqrt(2) <= x < sqrt(2)
+ * Theoretical peak relative error = 1.1e-35,
+ * relative peak error spread 1.1e-9
+ */
+static const long double R[6] =
+{
+  1.418134209872192732479751274970992665513E5L,
+ -8.977257995689735303686582344659576526998E4L,
+  2.048819892795278657810231591630928516206E4L,
+ -2.024301798136027039250415126250455056397E3L,
+  8.057002716646055371965756206836056074715E1L,
+ -8.828896441624934385266096344596648080902E-1L
+};
+static const long double S[6] =
+{
+  1.701761051846631278975701529965589676574E6L,
+ -1.332535117259762928288745111081235577029E6L,
+  4.001557694070773974936904547424676279307E5L,
+ -5.748542087379434595104154610899551484314E4L,
+  3.998526750980007367835804959888064681098E3L,
+ -1.186359407982897997337150403816839480438E2L
+/* 1.000000000000000000000000000000000000000E0L, */
+};
+
+static const long double
+/* log10(2) */
+L102A = 0.3125L,
+L102B = -1.14700043360188047862611052755069732318101185E-2L,
+/* log10(e) */
+L10EA = 0.5L,
+L10EB = -6.570551809674817234887108108339491770560299E-2L,
+/* sqrt(2)/2 */
+SQRTH = 7.071067811865475244008443621048490392848359E-1L;
+
+
+
+/* Evaluate P[n] x^n  +  P[n-1] x^(n-1)  +  ...  +  P[0] */
+
+static long double
+neval (long double x, const long double *p, int n)
+{
+  long double y;
+
+  p += n;
+  y = *p--;
+  do
+    {
+      y = y * x + *p--;
+    }
+  while (--n > 0);
+  return y;
+}
+
+
+/* Evaluate x^n+1  +  P[n] x^(n)  +  P[n-1] x^(n-1)  +  ...  +  P[0] */
+
+static long double
+deval (long double x, const long double *p, int n)
+{
+  long double y;
+
+  p += n;
+  y = x + *p--;
+  do
+    {
+      y = y * x + *p--;
+    }
+  while (--n > 0);
+  return y;
+}
+
+
+
+long double
+__ieee754_log10l (x)
+     long double x;
+{
+  long double z;
+  long double y;
+  int e;
+  int64_t hx, lx;
+
+/* Test for domain */
+  GET_LDOUBLE_WORDS64 (hx, lx, x);
+  if (((hx & 0x7fffffffffffffffLL) | (lx & 0x7fffffffffffffffLL)) == 0)
+    return (-1.0L / (x - x));
+  if (hx < 0)
+    return (x - x) / (x - x);
+  if (hx >= 0x7ff0000000000000LL)
+    return (x + x);
+
+/* separate mantissa from exponent */
+
+/* Note, frexp is used so that denormal numbers
+ * will be handled properly.
+ */
+  x = __frexpl (x, &e);
+
+
+/* logarithm using log(x) = z + z**3 P(z)/Q(z),
+ * where z = 2(x-1)/x+1)
+ */
+  if ((e > 2) || (e < -2))
+    {
+      if (x < SQRTH)
+       {                       /* 2( 2x-1 )/( 2x+1 ) */
+         e -= 1;
+         z = x - 0.5L;
+         y = 0.5L * z + 0.5L;
+       }
+      else
+       {                       /*  2 (x-1)/(x+1)   */
+         z = x - 0.5L;
+         z -= 0.5L;
+         y = 0.5L * x + 0.5L;
+       }
+      x = z / y;
+      z = x * x;
+      y = x * (z * neval (z, R, 5) / deval (z, S, 5));
+      goto done;
+    }
+
+
+/* logarithm using log(1+x) = x - .5x**2 + x**3 P(x)/Q(x) */
+
+  if (x < SQRTH)
+    {
+      e -= 1;
+      x = 2.0 * x - 1.0L;      /*  2x - 1  */
+    }
+  else
+    {
+      x = x - 1.0L;
+    }
+  z = x * x;
+  y = x * (z * neval (x, P, 12) / deval (x, Q, 11));
+  y = y - 0.5 * z;
+
+done:
+
+  /* Multiply log of fraction by log10(e)
+   * and base 2 exponent by log10(2).
+   */
+  z = y * L10EB;
+  z += x * L10EB;
+  z += e * L102B;
+  z += y * L10EA;
+  z += x * L10EA;
+  z += e * L102A;
+  return (z);
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_log2l.c b/sysdeps/ieee754/ldbl-128ibm/e_log2l.c
new file mode 100644 (file)
index 0000000..fe8a8e1
--- /dev/null
@@ -0,0 +1,250 @@
+/*                                                      log2l.c
+ *      Base 2 logarithm, 128-bit long double precision
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * long double x, y, log2l();
+ *
+ * y = log2l( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns the base 2 logarithm of x.
+ *
+ * The argument is separated into its exponent and fractional
+ * parts.  If the exponent is between -1 and +1, the (natural)
+ * logarithm of the fraction is approximated by
+ *
+ *     log(1+x) = x - 0.5 x^2 + x^3 P(x)/Q(x).
+ *
+ * Otherwise, setting  z = 2(x-1)/x+1),
+ *
+ *     log(x) = z + z^3 P(z)/Q(z).
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      0.5, 2.0     100,000    2.6e-34     4.9e-35
+ *    IEEE     exp(+-10000)  100,000    9.6e-35     4.0e-35
+ *
+ * In the tests over the interval exp(+-10000), the logarithms
+ * of the random arguments were uniformly distributed over
+ * [-10000, +10000].
+ *
+ */
+
+/*
+   Cephes Math Library Release 2.2:  January, 1991
+   Copyright 1984, 1991 by Stephen L. Moshier
+   Adapted for glibc November, 2001
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; 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"
+
+/* Coefficients for ln(1+x) = x - x**2/2 + x**3 P(x)/Q(x)
+ * 1/sqrt(2) <= x < sqrt(2)
+ * Theoretical peak relative error = 5.3e-37,
+ * relative peak error spread = 2.3e-14
+ */
+static const long double P[13] =
+{
+  1.313572404063446165910279910527789794488E4L,
+  7.771154681358524243729929227226708890930E4L,
+  2.014652742082537582487669938141683759923E5L,
+  3.007007295140399532324943111654767187848E5L,
+  2.854829159639697837788887080758954924001E5L,
+  1.797628303815655343403735250238293741397E5L,
+  7.594356839258970405033155585486712125861E4L,
+  2.128857716871515081352991964243375186031E4L,
+  3.824952356185897735160588078446136783779E3L,
+  4.114517881637811823002128927449878962058E2L,
+  2.321125933898420063925789532045674660756E1L,
+  4.998469661968096229986658302195402690910E-1L,
+  1.538612243596254322971797716843006400388E-6L
+};
+static const long double Q[12] =
+{
+  3.940717212190338497730839731583397586124E4L,
+  2.626900195321832660448791748036714883242E5L,
+  7.777690340007566932935753241556479363645E5L,
+  1.347518538384329112529391120390701166528E6L,
+  1.514882452993549494932585972882995548426E6L,
+  1.158019977462989115839826904108208787040E6L,
+  6.132189329546557743179177159925690841200E5L,
+  2.248234257620569139969141618556349415120E5L,
+  5.605842085972455027590989944010492125825E4L,
+  9.147150349299596453976674231612674085381E3L,
+  9.104928120962988414618126155557301584078E2L,
+  4.839208193348159620282142911143429644326E1L
+/* 1.000000000000000000000000000000000000000E0L, */
+};
+
+/* Coefficients for log(x) = z + z^3 P(z^2)/Q(z^2),
+ * where z = 2(x-1)/(x+1)
+ * 1/sqrt(2) <= x < sqrt(2)
+ * Theoretical peak relative error = 1.1e-35,
+ * relative peak error spread 1.1e-9
+ */
+static const long double R[6] =
+{
+  1.418134209872192732479751274970992665513E5L,
+ -8.977257995689735303686582344659576526998E4L,
+  2.048819892795278657810231591630928516206E4L,
+ -2.024301798136027039250415126250455056397E3L,
+  8.057002716646055371965756206836056074715E1L,
+ -8.828896441624934385266096344596648080902E-1L
+};
+static const long double S[6] =
+{
+  1.701761051846631278975701529965589676574E6L,
+ -1.332535117259762928288745111081235577029E6L,
+  4.001557694070773974936904547424676279307E5L,
+ -5.748542087379434595104154610899551484314E4L,
+  3.998526750980007367835804959888064681098E3L,
+ -1.186359407982897997337150403816839480438E2L
+/* 1.000000000000000000000000000000000000000E0L, */
+};
+
+static const long double
+/* log2(e) - 1 */
+LOG2EA = 4.4269504088896340735992468100189213742664595E-1L,
+/* sqrt(2)/2 */
+SQRTH = 7.071067811865475244008443621048490392848359E-1L;
+
+
+/* Evaluate P[n] x^n  +  P[n-1] x^(n-1)  +  ...  +  P[0] */
+
+static long double
+neval (long double x, const long double *p, int n)
+{
+  long double y;
+
+  p += n;
+  y = *p--;
+  do
+    {
+      y = y * x + *p--;
+    }
+  while (--n > 0);
+  return y;
+}
+
+
+/* Evaluate x^n+1  +  P[n] x^(n)  +  P[n-1] x^(n-1)  +  ...  +  P[0] */
+
+static long double
+deval (long double x, const long double *p, int n)
+{
+  long double y;
+
+  p += n;
+  y = x + *p--;
+  do
+    {
+      y = y * x + *p--;
+    }
+  while (--n > 0);
+  return y;
+}
+
+
+
+long double
+__ieee754_log2l (x)
+     long double x;
+{
+  long double z;
+  long double y;
+  int e;
+  int64_t hx, lx;
+
+/* Test for domain */
+  GET_LDOUBLE_WORDS64 (hx, lx, x);
+  if (((hx & 0x7fffffffffffffffLL) | (lx & 0x7fffffffffffffffLL)) == 0)
+    return (-1.0L / (x - x));
+  if (hx < 0)
+    return (x - x) / (x - x);
+  if (hx >= 0x7ff0000000000000LL)
+    return (x + x);
+
+/* separate mantissa from exponent */
+
+/* Note, frexp is used so that denormal numbers
+ * will be handled properly.
+ */
+  x = __frexpl (x, &e);
+
+
+/* logarithm using log(x) = z + z**3 P(z)/Q(z),
+ * where z = 2(x-1)/x+1)
+ */
+  if ((e > 2) || (e < -2))
+    {
+      if (x < SQRTH)
+       {                       /* 2( 2x-1 )/( 2x+1 ) */
+         e -= 1;
+         z = x - 0.5L;
+         y = 0.5L * z + 0.5L;
+       }
+      else
+       {                       /*  2 (x-1)/(x+1)   */
+         z = x - 0.5L;
+         z -= 0.5L;
+         y = 0.5L * x + 0.5L;
+       }
+      x = z / y;
+      z = x * x;
+      y = x * (z * neval (z, R, 5) / deval (z, S, 5));
+      goto done;
+    }
+
+
+/* logarithm using log(1+x) = x - .5x**2 + x**3 P(x)/Q(x) */
+
+  if (x < SQRTH)
+    {
+      e -= 1;
+      x = 2.0 * x - 1.0L;      /*  2x - 1  */
+    }
+  else
+    {
+      x = x - 1.0L;
+    }
+  z = x * x;
+  y = x * (z * neval (x, P, 12) / deval (x, Q, 11));
+  y = y - 0.5 * z;
+
+done:
+
+/* Multiply log of fraction by log2(e)
+ * and base 2 exponent by 1
+ */
+  z = y * LOG2EA;
+  z += x * LOG2EA;
+  z += y;
+  z += x;
+  z += e;
+  return (z);
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_logl.c b/sysdeps/ieee754/ldbl-128ibm/e_logl.c
new file mode 100644 (file)
index 0000000..aa5fc37
--- /dev/null
@@ -0,0 +1,281 @@
+/*                                                     logll.c
+ *
+ * Natural logarithm for 128-bit long double precision.
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * long double x, y, logl();
+ *
+ * y = logl( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns the base e (2.718...) logarithm of x.
+ *
+ * The argument is separated into its exponent and fractional
+ * parts.  Use of a lookup table increases the speed of the routine.
+ * The program uses logarithms tabulated at intervals of 1/128 to
+ * cover the domain from approximately 0.7 to 1.4.
+ *
+ * On the interval [-1/128, +1/128] the logarithm of 1+x is approximated by
+ *     log(1+x) = x - 0.5 x^2 + x^3 P(x) .
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE   0.875, 1.125   100000      1.2e-34    4.1e-35
+ *    IEEE   0.125, 8       100000      1.2e-34    4.1e-35
+ *
+ *
+ * WARNING:
+ *
+ * This program uses integer operations on bit fields of floating-point
+ * numbers.  It does not work with data structures other than the
+ * structure assumed.
+ *
+ */
+
+/* Copyright 2001 by Stephen L. Moshier <moshier@na-net.ornl.gov>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA */
+
+#include "math_private.h"
+
+/* log(1+x) = x - .5 x^2 + x^3 l(x)
+   -.0078125 <= x <= +.0078125
+   peak relative error 1.2e-37 */
+static const long double
+l3 =   3.333333333333333333333333333333336096926E-1L,
+l4 =  -2.499999999999999999999999999486853077002E-1L,
+l5 =   1.999999999999999999999999998515277861905E-1L,
+l6 =  -1.666666666666666666666798448356171665678E-1L,
+l7 =   1.428571428571428571428808945895490721564E-1L,
+l8 =  -1.249999999999999987884655626377588149000E-1L,
+l9 =   1.111111111111111093947834982832456459186E-1L,
+l10 = -1.000000000000532974938900317952530453248E-1L,
+l11 =  9.090909090915566247008015301349979892689E-2L,
+l12 = -8.333333211818065121250921925397567745734E-2L,
+l13 =  7.692307559897661630807048686258659316091E-2L,
+l14 = -7.144242754190814657241902218399056829264E-2L,
+l15 =  6.668057591071739754844678883223432347481E-2L;
+
+/* Lookup table of ln(t) - (t-1)
+    t = 0.5 + (k+26)/128)
+    k = 0, ..., 91   */
+static const long double logtbl[92] = {
+-5.5345593589352099112142921677820359632418E-2L,
+-5.2108257402767124761784665198737642086148E-2L,
+-4.8991686870576856279407775480686721935120E-2L,
+-4.5993270766361228596215288742353061431071E-2L,
+-4.3110481649613269682442058976885699556950E-2L,
+-4.0340872319076331310838085093194799765520E-2L,
+-3.7682072451780927439219005993827431503510E-2L,
+-3.5131785416234343803903228503274262719586E-2L,
+-3.2687785249045246292687241862699949178831E-2L,
+-3.0347913785027239068190798397055267411813E-2L,
+-2.8110077931525797884641940838507561326298E-2L,
+-2.5972247078357715036426583294246819637618E-2L,
+-2.3932450635346084858612873953407168217307E-2L,
+-2.1988775689981395152022535153795155900240E-2L,
+-2.0139364778244501615441044267387667496733E-2L,
+-1.8382413762093794819267536615342902718324E-2L,
+-1.6716169807550022358923589720001638093023E-2L,
+-1.5138929457710992616226033183958974965355E-2L,
+-1.3649036795397472900424896523305726435029E-2L,
+-1.2244881690473465543308397998034325468152E-2L,
+-1.0924898127200937840689817557742469105693E-2L,
+-9.6875626072830301572839422532631079809328E-3L,
+-8.5313926245226231463436209313499745894157E-3L,
+-7.4549452072765973384933565912143044991706E-3L,
+-6.4568155251217050991200599386801665681310E-3L,
+-5.5356355563671005131126851708522185605193E-3L,
+-4.6900728132525199028885749289712348829878E-3L,
+-3.9188291218610470766469347968659624282519E-3L,
+-3.2206394539524058873423550293617843896540E-3L,
+-2.5942708080877805657374888909297113032132E-3L,
+-2.0385211375711716729239156839929281289086E-3L,
+-1.5522183228760777967376942769773768850872E-3L,
+-1.1342191863606077520036253234446621373191E-3L,
+-7.8340854719967065861624024730268350459991E-4L,
+-4.9869831458030115699628274852562992756174E-4L,
+-2.7902661731604211834685052867305795169688E-4L,
+-1.2335696813916860754951146082826952093496E-4L,
+-3.0677461025892873184042490943581654591817E-5L,
+#define ZERO logtbl[38]
+ 0.0000000000000000000000000000000000000000E0L,
+-3.0359557945051052537099938863236321874198E-5L,
+-1.2081346403474584914595395755316412213151E-4L,
+-2.7044071846562177120083903771008342059094E-4L,
+-4.7834133324631162897179240322783590830326E-4L,
+-7.4363569786340080624467487620270965403695E-4L,
+-1.0654639687057968333207323853366578860679E-3L,
+-1.4429854811877171341298062134712230604279E-3L,
+-1.8753781835651574193938679595797367137975E-3L,
+-2.3618380914922506054347222273705859653658E-3L,
+-2.9015787624124743013946600163375853631299E-3L,
+-3.4938307889254087318399313316921940859043E-3L,
+-4.1378413103128673800485306215154712148146E-3L,
+-4.8328735414488877044289435125365629849599E-3L,
+-5.5782063183564351739381962360253116934243E-3L,
+-6.3731336597098858051938306767880719015261E-3L,
+-7.2169643436165454612058905294782949315193E-3L,
+-8.1090214990427641365934846191367315083867E-3L,
+-9.0486422112807274112838713105168375482480E-3L,
+-1.0035177140880864314674126398350812606841E-2L,
+-1.1067990155502102718064936259435676477423E-2L,
+-1.2146457974158024928196575103115488672416E-2L,
+-1.3269969823361415906628825374158424754308E-2L,
+-1.4437927104692837124388550722759686270765E-2L,
+-1.5649743073340777659901053944852735064621E-2L,
+-1.6904842527181702880599758489058031645317E-2L,
+-1.8202661505988007336096407340750378994209E-2L,
+-1.9542647000370545390701192438691126552961E-2L,
+-2.0924256670080119637427928803038530924742E-2L,
+-2.2346958571309108496179613803760727786257E-2L,
+-2.3810230892650362330447187267648486279460E-2L,
+-2.5313561699385640380910474255652501521033E-2L,
+-2.6856448685790244233704909690165496625399E-2L,
+-2.8438398935154170008519274953860128449036E-2L,
+-3.0058928687233090922411781058956589863039E-2L,
+-3.1717563112854831855692484086486099896614E-2L,
+-3.3413836095418743219397234253475252001090E-2L,
+-3.5147290019036555862676702093393332533702E-2L,
+-3.6917475563073933027920505457688955423688E-2L,
+-3.8723951502862058660874073462456610731178E-2L,
+-4.0566284516358241168330505467000838017425E-2L,
+-4.2444048996543693813649967076598766917965E-2L,
+-4.4356826869355401653098777649745233339196E-2L,
+-4.6304207416957323121106944474331029996141E-2L,
+-4.8285787106164123613318093945035804818364E-2L,
+-5.0301169421838218987124461766244507342648E-2L,
+-5.2349964705088137924875459464622098310997E-2L,
+-5.4431789996103111613753440311680967840214E-2L,
+-5.6546268881465384189752786409400404404794E-2L,
+-5.8693031345788023909329239565012647817664E-2L,
+-6.0871713627532018185577188079210189048340E-2L,
+-6.3081958078862169742820420185833800925568E-2L,
+-6.5323413029406789694910800219643791556918E-2L,
+-6.7595732653791419081537811574227049288168E-2L
+};
+
+/* ln(2) = ln2a + ln2b with extended precision. */
+static const long double
+  ln2a = 6.93145751953125e-1L,
+  ln2b = 1.4286068203094172321214581765680755001344E-6L;
+
+long double
+__ieee754_logl(long double x)
+{
+  long double z, y, w;
+  ieee854_long_double_shape_type u, t;
+  unsigned int m;
+  int k, e;
+
+  u.value = x;
+  m = u.parts32.w0;
+
+  /* Check for IEEE special cases.  */
+  k = m & 0x7fffffff;
+  /* log(0) = -infinity. */
+  if ((k | u.parts32.w1 | (u.parts32.w2 & 0x7fffffff) | u.parts32.w3) == 0)
+    {
+      return -0.5L / ZERO;
+    }
+  /* log ( x < 0 ) = NaN */
+  if (m & 0x80000000)
+    {
+      return (x - x) / ZERO;
+    }
+  /* log (infinity or NaN) */
+  if (k >= 0x7ff00000)
+    {
+      return x + x;
+    }
+
+  /* On this interval the table is not used due to cancellation error.  */
+  if ((x <= 1.0078125L) && (x >= 0.9921875L))
+    {
+      z = x - 1.0L;
+      k = 64;
+      t.value  = 1.0L;
+      e = 0;
+    }
+  else
+    {
+      /* Extract exponent and reduce domain to 0.703125 <= u < 1.40625  */
+      unsigned int w0;
+      e = (int) (m >> 20) - (int) 0x3fe;
+      m &= 0xfffff;
+      w0 = m | 0x3fe00000;
+      m |= 0x100000;
+      /* Find lookup table index k from high order bits of the significand. */
+      if (m < 0x168000)
+       {
+         k = (m - 0xff000) >> 13;
+         /* t is the argument 0.5 + (k+26)/128
+            of the nearest item to u in the lookup table.  */
+         t.parts32.w0 = 0x3ff00000 + (k << 13);
+         t.parts32.w1 = 0;
+         t.parts32.w2 = 0;
+         t.parts32.w3 = 0;
+         w0 += 0x100000;
+         e -= 1;
+         k += 64;
+       }
+      else
+       {
+         k = (m - 0xfe000) >> 14;
+         t.parts32.w0 = 0x3fe00000 + (k << 14);
+         t.parts32.w1 = 0;
+         t.parts32.w2 = 0;
+         t.parts32.w3 = 0;
+       }
+      u.value = __scalbnl (u.value, ((int) ((w0 - u.parts32.w0) * 2)) >> 21);
+      /* log(u) = log( t u/t ) = log(t) + log(u/t)
+        log(t) is tabulated in the lookup table.
+        Express log(u/t) = log(1+z),  where z = u/t - 1 = (u-t)/t.
+         cf. Cody & Waite. */
+      z = (u.value - t.value) / t.value;
+    }
+  /* Series expansion of log(1+z).  */
+  w = z * z;
+  y = ((((((((((((l15 * z
+                 + l14) * z
+                + l13) * z
+               + l12) * z
+              + l11) * z
+             + l10) * z
+            + l9) * z
+           + l8) * z
+          + l7) * z
+         + l6) * z
+        + l5) * z
+       + l4) * z
+       + l3) * z * w;
+  y -= 0.5 * w;
+  y += e * ln2b;  /* Base 2 exponent offset times ln(2).  */
+  y += z;
+  y += logtbl[k-26]; /* log(t) - (t-1) */
+  y += (t.value - 1.0L);
+  y += e * ln2a;
+  return y;
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_powl.c b/sysdeps/ieee754/ldbl-128ibm/e_powl.c
new file mode 100644 (file)
index 0000000..feeaa8c
--- /dev/null
@@ -0,0 +1,441 @@
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+/* Expansions and modifications for 128-bit long double are
+   Copyright (C) 2001 Stephen L. Moshier <moshier@na-net.ornl.gov>
+   and are incorporated herein by permission of the author.  The author
+   reserves the right to distribute this material elsewhere under different
+   copying permissions.  These modifications are distributed here under
+   the following terms:
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA */
+
+/* __ieee754_powl(x,y) return x**y
+ *
+ *                   n
+ * Method:  Let x =  2   * (1+f)
+ *     1. Compute and return log2(x) in two pieces:
+ *             log2(x) = w1 + w2,
+ *        where w1 has 113-53 = 60 bit trailing zeros.
+ *     2. Perform y*log2(x) = n+y' by simulating muti-precision
+ *        arithmetic, where |y'|<=0.5.
+ *     3. Return x**y = 2**n*exp(y'*log2)
+ *
+ * Special cases:
+ *     1.  (anything) ** 0  is 1
+ *     2.  (anything) ** 1  is itself
+ *     3.  (anything) ** NAN is NAN
+ *     4.  NAN ** (anything except 0) is NAN
+ *     5.  +-(|x| > 1) **  +INF is +INF
+ *     6.  +-(|x| > 1) **  -INF is +0
+ *     7.  +-(|x| < 1) **  +INF is +0
+ *     8.  +-(|x| < 1) **  -INF is +INF
+ *     9.  +-1         ** +-INF is NAN
+ *     10. +0 ** (+anything except 0, NAN)               is +0
+ *     11. -0 ** (+anything except 0, NAN, odd integer)  is +0
+ *     12. +0 ** (-anything except 0, NAN)               is +INF
+ *     13. -0 ** (-anything except 0, NAN, odd integer)  is +INF
+ *     14. -0 ** (odd integer) = -( +0 ** (odd integer) )
+ *     15. +INF ** (+anything except 0,NAN) is +INF
+ *     16. +INF ** (-anything except 0,NAN) is +0
+ *     17. -INF ** (anything)  = -0 ** (-anything)
+ *     18. (-anything) ** (integer) is (-1)**(integer)*(+anything**integer)
+ *     19. (-anything except 0 and inf) ** (non-integer) is NAN
+ *
+ */
+
+#include "math.h"
+#include "math_private.h"
+
+static const long double bp[] = {
+  1.0L,
+  1.5L,
+};
+
+/* log_2(1.5) */
+static const long double dp_h[] = {
+  0.0,
+  5.8496250072115607565592654282227158546448E-1L
+};
+
+/* Low part of log_2(1.5) */
+static const long double dp_l[] = {
+  0.0,
+  1.0579781240112554492329533686862998106046E-16L
+};
+
+static const long double zero = 0.0L,
+  one = 1.0L,
+  two = 2.0L,
+  two113 = 1.0384593717069655257060992658440192E34L,
+  huge = 1.0e3000L,
+  tiny = 1.0e-3000L;
+
+/* 3/2 log x = 3 z + z^3 + z^3 (z^2 R(z^2))
+   z = (x-1)/(x+1)
+   1 <= x <= 1.25
+   Peak relative error 2.3e-37 */
+static const long double LN[] =
+{
+ -3.0779177200290054398792536829702930623200E1L,
+  6.5135778082209159921251824580292116201640E1L,
+ -4.6312921812152436921591152809994014413540E1L,
+  1.2510208195629420304615674658258363295208E1L,
+ -9.9266909031921425609179910128531667336670E-1L
+};
+static const long double LD[] =
+{
+ -5.129862866715009066465422805058933131960E1L,
+  1.452015077564081884387441590064272782044E2L,
+ -1.524043275549860505277434040464085593165E2L,
+  7.236063513651544224319663428634139768808E1L,
+ -1.494198912340228235853027849917095580053E1L
+  /* 1.0E0 */
+};
+
+/* exp(x) = 1 + x - x / (1 - 2 / (x - x^2 R(x^2)))
+   0 <= x <= 0.5
+   Peak relative error 5.7e-38  */
+static const long double PN[] =
+{
+  5.081801691915377692446852383385968225675E8L,
+  9.360895299872484512023336636427675327355E6L,
+  4.213701282274196030811629773097579432957E4L,
+  5.201006511142748908655720086041570288182E1L,
+  9.088368420359444263703202925095675982530E-3L,
+};
+static const long double PD[] =
+{
+  3.049081015149226615468111430031590411682E9L,
+  1.069833887183886839966085436512368982758E8L,
+  8.259257717868875207333991924545445705394E5L,
+  1.872583833284143212651746812884298360922E3L,
+  /* 1.0E0 */
+};
+
+static const long double
+  /* ln 2 */
+  lg2 = 6.9314718055994530941723212145817656807550E-1L,
+  lg2_h = 6.9314718055994528622676398299518041312695E-1L,
+  lg2_l = 2.3190468138462996154948554638754786504121E-17L,
+  ovt = 8.0085662595372944372e-0017L,
+  /* 2/(3*log(2)) */
+  cp = 9.6179669392597560490661645400126142495110E-1L,
+  cp_h = 9.6179669392597555432899980587535537779331E-1L,
+  cp_l = 5.0577616648125906047157785230014751039424E-17L;
+
+#ifdef __STDC__
+long double
+__ieee754_powl (long double x, long double y)
+#else
+long double
+__ieee754_powl (x, y)
+     long double x, y;
+#endif
+{
+  long double z, ax, z_h, z_l, p_h, p_l;
+  long double y1, t1, t2, r, s, t, u, v, w;
+  long double s2, s_h, s_l, t_h, t_l;
+  int32_t i, j, k, yisint, n;
+  u_int32_t ix, iy;
+  int32_t hx, hy;
+  ieee854_long_double_shape_type o, p, q;
+
+  p.value = x;
+  hx = p.parts32.w0;
+  ix = hx & 0x7fffffff;
+
+  q.value = y;
+  hy = q.parts32.w0;
+  iy = hy & 0x7fffffff;
+
+
+  /* y==zero: x**0 = 1 */
+  if ((iy | q.parts32.w1 | (q.parts32.w2 & 0x7fffffff) | q.parts32.w3) == 0)
+    return one;
+
+  /* 1.0**y = 1; -1.0**+-Inf = 1 */
+  if (x == one)
+    return one;
+  if (x == -1.0L && iy == 0x7ff00000
+      && (q.parts32.w1 | (q.parts32.w2 & 0x7fffffff) | q.parts32.w3) == 0)
+    return one;
+
+  /* +-NaN return x+y */
+  if ((ix > 0x7ff00000)
+      || ((ix == 0x7ff00000)
+         && ((p.parts32.w1 | (p.parts32.w2 & 0x7fffffff) | p.parts32.w3) != 0))
+      || (iy > 0x7ff00000)
+      || ((iy == 0x7ff00000)
+         && ((q.parts32.w1 | (q.parts32.w2 & 0x7fffffff) | q.parts32.w3) != 0)))
+    return x + y;
+
+  /* determine if y is an odd int when x < 0
+   * yisint = 0       ... y is not an integer
+   * yisint = 1       ... y is an odd int
+   * yisint = 2       ... y is an even int
+   */
+  yisint = 0;
+  if (hx < 0)
+    {
+      if ((q.parts32.w2 & 0x7fffffff) >= 0x43400000)   /* Low part >= 2^53 */
+       yisint = 2;             /* even integer y */
+      else if (iy >= 0x3ff00000)       /* 1.0 */
+       {
+         if (__floorl (y) == y)
+           {
+             z = 0.5 * y;
+             if (__floorl (z) == z)
+               yisint = 2;
+             else
+               yisint = 1;
+           }
+       }
+    }
+
+  /* special value of y */
+  if ((q.parts32.w1 | (q.parts32.w2 & 0x7fffffff) | q.parts32.w3) == 0)
+    {
+      if (iy == 0x7ff00000 && q.parts32.w1 == 0)       /* y is +-inf */
+       {
+         if (((ix - 0x3ff00000) | p.parts32.w1
+              | (p.parts32.w2 & 0x7fffffff) | p.parts32.w3) == 0)
+           return y - y;       /* inf**+-1 is NaN */
+         else if (ix > 0x3ff00000 || fabsl (x) > 1.0L)
+           /* (|x|>1)**+-inf = inf,0 */
+           return (hy >= 0) ? y : zero;
+         else
+           /* (|x|<1)**-,+inf = inf,0 */
+           return (hy < 0) ? -y : zero;
+       }
+      if (iy == 0x3ff00000)
+       {                       /* y is  +-1 */
+         if (hy < 0)
+           return one / x;
+         else
+           return x;
+       }
+      if (hy == 0x40000000)
+       return x * x;           /* y is  2 */
+      if (hy == 0x3fe00000)
+       {                       /* y is  0.5 */
+         if (hx >= 0)          /* x >= +0 */
+           return __ieee754_sqrtl (x);
+       }
+    }
+
+  ax = fabsl (x);
+  /* special value of x */
+  if ((p.parts32.w1 | (p.parts32.w2 & 0x7fffffff) | p.parts32.w3) == 0)
+    {
+      if (ix == 0x7ff00000 || ix == 0 || ix == 0x3ff00000)
+       {
+         z = ax;               /*x is +-0,+-inf,+-1 */
+         if (hy < 0)
+           z = one / z;        /* z = (1/|x|) */
+         if (hx < 0)
+           {
+             if (((ix - 0x3ff00000) | yisint) == 0)
+               {
+                 z = (z - z) / (z - z);        /* (-1)**non-int is NaN */
+               }
+             else if (yisint == 1)
+               z = -z;         /* (x<0)**odd = -(|x|**odd) */
+           }
+         return z;
+       }
+    }
+
+  /* (x<0)**(non-int) is NaN */
+  if (((((u_int32_t) hx >> 31) - 1) | yisint) == 0)
+    return (x - x) / (x - x);
+
+  /* |y| is huge.
+     2^-16495 = 1/2 of smallest representable value.
+     If (1 - 1/131072)^y underflows, y > 1.4986e9 */
+  if (iy > 0x41d654b0)
+    {
+      /* if (1 - 2^-113)^y underflows, y > 1.1873e38 */
+      if (iy > 0x47d654b0)
+       {
+         if (ix <= 0x3fefffff)
+           return (hy < 0) ? huge * huge : tiny * tiny;
+         if (ix >= 0x3ff00000)
+           return (hy > 0) ? huge * huge : tiny * tiny;
+       }
+      /* over/underflow if x is not close to one */
+      if (ix < 0x3fefffff)
+       return (hy < 0) ? huge * huge : tiny * tiny;
+      if (ix > 0x3ff00000)
+       return (hy > 0) ? huge * huge : tiny * tiny;
+    }
+
+  n = 0;
+  /* take care subnormal number */
+  if (ix < 0x00100000)
+    {
+      ax *= two113;
+      n -= 113;
+      o.value = ax;
+      ix = o.parts32.w0;
+    }
+  n += ((ix) >> 20) - 0x3ff;
+  j = ix & 0x000fffff;
+  /* determine interval */
+  ix = j | 0x3ff00000;         /* normalize ix */
+  if (j <= 0x39880)
+    k = 0;                     /* |x|<sqrt(3/2) */
+  else if (j < 0xbb670)
+    k = 1;                     /* |x|<sqrt(3)   */
+  else
+    {
+      k = 0;
+      n += 1;
+      ix -= 0x00100000;
+    }
+
+  o.value = ax;
+  o.value = __scalbnl (o.value, ((int) ((ix - o.parts32.w0) * 2)) >> 21);
+  ax = o.value;
+
+  /* compute s = s_h+s_l = (x-1)/(x+1) or (x-1.5)/(x+1.5) */
+  u = ax - bp[k];              /* bp[0]=1.0, bp[1]=1.5 */
+  v = one / (ax + bp[k]);
+  s = u * v;
+  s_h = s;
+
+  o.value = s_h;
+  o.parts32.w3 = 0;
+  o.parts32.w2 &= 0xffff8000;
+  s_h = o.value;
+  /* t_h=ax+bp[k] High */
+  t_h = ax + bp[k];
+  o.value = t_h;
+  o.parts32.w3 = 0;
+  o.parts32.w2 &= 0xffff8000;
+  t_h = o.value;
+  t_l = ax - (t_h - bp[k]);
+  s_l = v * ((u - s_h * t_h) - s_h * t_l);
+  /* compute log(ax) */
+  s2 = s * s;
+  u = LN[0] + s2 * (LN[1] + s2 * (LN[2] + s2 * (LN[3] + s2 * LN[4])));
+  v = LD[0] + s2 * (LD[1] + s2 * (LD[2] + s2 * (LD[3] + s2 * (LD[4] + s2))));
+  r = s2 * s2 * u / v;
+  r += s_l * (s_h + s);
+  s2 = s_h * s_h;
+  t_h = 3.0 + s2 + r;
+  o.value = t_h;
+  o.parts32.w3 = 0;
+  o.parts32.w2 &= 0xffff8000;
+  t_h = o.value;
+  t_l = r - ((t_h - 3.0) - s2);
+  /* u+v = s*(1+...) */
+  u = s_h * t_h;
+  v = s_l * t_h + t_l * s;
+  /* 2/(3log2)*(s+...) */
+  p_h = u + v;
+  o.value = p_h;
+  o.parts32.w3 = 0;
+  o.parts32.w2 &= 0xffff8000;
+  p_h = o.value;
+  p_l = v - (p_h - u);
+  z_h = cp_h * p_h;            /* cp_h+cp_l = 2/(3*log2) */
+  z_l = cp_l * p_h + p_l * cp + dp_l[k];
+  /* log2(ax) = (s+..)*2/(3*log2) = n + dp_h + z_h + z_l */
+  t = (long double) n;
+  t1 = (((z_h + z_l) + dp_h[k]) + t);
+  o.value = t1;
+  o.parts32.w3 = 0;
+  o.parts32.w2 &= 0xffff8000;
+  t1 = o.value;
+  t2 = z_l - (((t1 - t) - dp_h[k]) - z_h);
+
+  /* s (sign of result -ve**odd) = -1 else = 1 */
+  s = one;
+  if (((((u_int32_t) hx >> 31) - 1) | (yisint - 1)) == 0)
+    s = -one;                  /* (-ve)**(odd int) */
+
+  /* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */
+  y1 = y;
+  o.value = y1;
+  o.parts32.w3 = 0;
+  o.parts32.w2 &= 0xffff8000;
+  y1 = o.value;
+  p_l = (y - y1) * t1 + y * t2;
+  p_h = y1 * t1;
+  z = p_l + p_h;
+  o.value = z;
+  j = o.parts32.w0;
+  if (j >= 0x40d00000) /* z >= 16384 */
+    {
+      /* if z > 16384 */
+      if (((j - 0x40d00000) | o.parts32.w1
+        | (o.parts32.w2 & 0x7fffffff) | o.parts32.w3) != 0)
+       return s * huge * huge; /* overflow */
+      else
+       {
+         if (p_l + ovt > z - p_h)
+           return s * huge * huge;     /* overflow */
+       }
+    }
+  else if ((j & 0x7fffffff) >= 0x40d01b90)     /* z <= -16495 */
+    {
+      /* z < -16495 */
+      if (((j - 0xc0d01bc0) | o.parts32.w1
+         | (o.parts32.w2 & 0x7fffffff) | o.parts32.w3) != 0)
+       return s * tiny * tiny; /* underflow */
+      else
+       {
+         if (p_l <= z - p_h)
+           return s * tiny * tiny;     /* underflow */
+       }
+    }
+  /* compute 2**(p_h+p_l) */
+  i = j & 0x7fffffff;
+  k = (i >> 20) - 0x3ff;
+  n = 0;
+  if (i > 0x3fe00000)
+    {                          /* if |z| > 0.5, set n = [z+0.5] */
+      n = __floorl (z + 0.5L);
+      t = n;
+      p_h -= t;
+    }
+  t = p_l + p_h;
+  o.value = t;
+  o.parts32.w3 = 0;
+  o.parts32.w2 &= 0xffff8000;
+  t = o.value;
+  u = t * lg2_h;
+  v = (p_l - (t - p_h)) * lg2 + t * lg2_l;
+  z = u + v;
+  w = v - (z - u);
+  /*  exp(z) */
+  t = z * z;
+  u = PN[0] + t * (PN[1] + t * (PN[2] + t * (PN[3] + t * PN[4])));
+  v = PD[0] + t * (PD[1] + t * (PD[2] + t * (PD[3] + t)));
+  t1 = z - t * u / v;
+  r = (z * t1) / (t1 - two) - (w + z * w);
+  z = one - (r - z);
+  z = __scalbnl (z, n);
+  return s * z;
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_rem_pio2l.c b/sysdeps/ieee754/ldbl-128ibm/e_rem_pio2l.c
new file mode 100644 (file)
index 0000000..416547c
--- /dev/null
@@ -0,0 +1,277 @@
+/* Quad-precision floating point argument reduction.
+   Copyright (C) 1999,2004,2006 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Jakub Jelinek <jj@ultra.linux.cz>
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; 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"
+#include <ieee754.h>
+
+/*
+ * Table of constants for 2/pi, 5628 hexadecimal digits of 2/pi
+ */
+static const int32_t two_over_pi[] = {
+0xa2f983, 0x6e4e44, 0x1529fc, 0x2757d1, 0xf534dd, 0xc0db62,
+0x95993c, 0x439041, 0xfe5163, 0xabdebb, 0xc561b7, 0x246e3a,
+0x424dd2, 0xe00649, 0x2eea09, 0xd1921c, 0xfe1deb, 0x1cb129,
+0xa73ee8, 0x8235f5, 0x2ebb44, 0x84e99c, 0x7026b4, 0x5f7e41,
+0x3991d6, 0x398353, 0x39f49c, 0x845f8b, 0xbdf928, 0x3b1ff8,
+0x97ffde, 0x05980f, 0xef2f11, 0x8b5a0a, 0x6d1f6d, 0x367ecf,
+0x27cb09, 0xb74f46, 0x3f669e, 0x5fea2d, 0x7527ba, 0xc7ebe5,
+0xf17b3d, 0x0739f7, 0x8a5292, 0xea6bfb, 0x5fb11f, 0x8d5d08,
+0x560330, 0x46fc7b, 0x6babf0, 0xcfbc20, 0x9af436, 0x1da9e3,
+0x91615e, 0xe61b08, 0x659985, 0x5f14a0, 0x68408d, 0xffd880,
+0x4d7327, 0x310606, 0x1556ca, 0x73a8c9, 0x60e27b, 0xc08c6b,
+0x47c419, 0xc367cd, 0xdce809, 0x2a8359, 0xc4768b, 0x961ca6,
+0xddaf44, 0xd15719, 0x053ea5, 0xff0705, 0x3f7e33, 0xe832c2,
+0xde4f98, 0x327dbb, 0xc33d26, 0xef6b1e, 0x5ef89f, 0x3a1f35,
+0xcaf27f, 0x1d87f1, 0x21907c, 0x7c246a, 0xfa6ed5, 0x772d30,
+0x433b15, 0xc614b5, 0x9d19c3, 0xc2c4ad, 0x414d2c, 0x5d000c,
+0x467d86, 0x2d71e3, 0x9ac69b, 0x006233, 0x7cd2b4, 0x97a7b4,
+0xd55537, 0xf63ed7, 0x1810a3, 0xfc764d, 0x2a9d64, 0xabd770,
+0xf87c63, 0x57b07a, 0xe71517, 0x5649c0, 0xd9d63b, 0x3884a7,
+0xcb2324, 0x778ad6, 0x23545a, 0xb91f00, 0x1b0af1, 0xdfce19,
+0xff319f, 0x6a1e66, 0x615799, 0x47fbac, 0xd87f7e, 0xb76522,
+0x89e832, 0x60bfe6, 0xcdc4ef, 0x09366c, 0xd43f5d, 0xd7de16,
+0xde3b58, 0x929bde, 0x2822d2, 0xe88628, 0x4d58e2, 0x32cac6,
+0x16e308, 0xcb7de0, 0x50c017, 0xa71df3, 0x5be018, 0x34132e,
+0x621283, 0x014883, 0x5b8ef5, 0x7fb0ad, 0xf2e91e, 0x434a48,
+0xd36710, 0xd8ddaa, 0x425fae, 0xce616a, 0xa4280a, 0xb499d3,
+0xf2a606, 0x7f775c, 0x83c2a3, 0x883c61, 0x78738a, 0x5a8caf,
+0xbdd76f, 0x63a62d, 0xcbbff4, 0xef818d, 0x67c126, 0x45ca55,
+0x36d9ca, 0xd2a828, 0x8d61c2, 0x77c912, 0x142604, 0x9b4612,
+0xc459c4, 0x44c5c8, 0x91b24d, 0xf31700, 0xad43d4, 0xe54929,
+0x10d5fd, 0xfcbe00, 0xcc941e, 0xeece70, 0xf53e13, 0x80f1ec,
+0xc3e7b3, 0x28f8c7, 0x940593, 0x3e71c1, 0xb3092e, 0xf3450b,
+0x9c1288, 0x7b20ab, 0x9fb52e, 0xc29247, 0x2f327b, 0x6d550c,
+0x90a772, 0x1fe76b, 0x96cb31, 0x4a1679, 0xe27941, 0x89dff4,
+0x9794e8, 0x84e6e2, 0x973199, 0x6bed88, 0x365f5f, 0x0efdbb,
+0xb49a48, 0x6ca467, 0x427271, 0x325d8d, 0xb8159f, 0x09e5bc,
+0x25318d, 0x3974f7, 0x1c0530, 0x010c0d, 0x68084b, 0x58ee2c,
+0x90aa47, 0x02e774, 0x24d6bd, 0xa67df7, 0x72486e, 0xef169f,
+0xa6948e, 0xf691b4, 0x5153d1, 0xf20acf, 0x339820, 0x7e4bf5,
+0x6863b2, 0x5f3edd, 0x035d40, 0x7f8985, 0x295255, 0xc06437,
+0x10d86d, 0x324832, 0x754c5b, 0xd4714e, 0x6e5445, 0xc1090b,
+0x69f52a, 0xd56614, 0x9d0727, 0x50045d, 0xdb3bb4, 0xc576ea,
+0x17f987, 0x7d6b49, 0xba271d, 0x296996, 0xacccc6, 0x5414ad,
+0x6ae290, 0x89d988, 0x50722c, 0xbea404, 0x940777, 0x7030f3,
+0x27fc00, 0xa871ea, 0x49c266, 0x3de064, 0x83dd97, 0x973fa3,
+0xfd9443, 0x8c860d, 0xde4131, 0x9d3992, 0x8c70dd, 0xe7b717,
+0x3bdf08, 0x2b3715, 0xa0805c, 0x93805a, 0x921110, 0xd8e80f,
+0xaf806c, 0x4bffdb, 0x0f9038, 0x761859, 0x15a562, 0xbbcb61,
+0xb989c7, 0xbd4010, 0x04f2d2, 0x277549, 0xf6b6eb, 0xbb22db,
+0xaa140a, 0x2f2689, 0x768364, 0x333b09, 0x1a940e, 0xaa3a51,
+0xc2a31d, 0xaeedaf, 0x12265c, 0x4dc26d, 0x9c7a2d, 0x9756c0,
+0x833f03, 0xf6f009, 0x8c402b, 0x99316d, 0x07b439, 0x15200c,
+0x5bc3d8, 0xc492f5, 0x4badc6, 0xa5ca4e, 0xcd37a7, 0x36a9e6,
+0x9492ab, 0x6842dd, 0xde6319, 0xef8c76, 0x528b68, 0x37dbfc,
+0xaba1ae, 0x3115df, 0xa1ae00, 0xdafb0c, 0x664d64, 0xb705ed,
+0x306529, 0xbf5657, 0x3aff47, 0xb9f96a, 0xf3be75, 0xdf9328,
+0x3080ab, 0xf68c66, 0x15cb04, 0x0622fa, 0x1de4d9, 0xa4b33d,
+0x8f1b57, 0x09cd36, 0xe9424e, 0xa4be13, 0xb52333, 0x1aaaf0,
+0xa8654f, 0xa5c1d2, 0x0f3f0b, 0xcd785b, 0x76f923, 0x048b7b,
+0x721789, 0x53a6c6, 0xe26e6f, 0x00ebef, 0x584a9b, 0xb7dac4,
+0xba66aa, 0xcfcf76, 0x1d02d1, 0x2df1b1, 0xc1998c, 0x77adc3,
+0xda4886, 0xa05df7, 0xf480c6, 0x2ff0ac, 0x9aecdd, 0xbc5c3f,
+0x6dded0, 0x1fc790, 0xb6db2a, 0x3a25a3, 0x9aaf00, 0x9353ad,
+0x0457b6, 0xb42d29, 0x7e804b, 0xa707da, 0x0eaa76, 0xa1597b,
+0x2a1216, 0x2db7dc, 0xfde5fa, 0xfedb89, 0xfdbe89, 0x6c76e4,
+0xfca906, 0x70803e, 0x156e85, 0xff87fd, 0x073e28, 0x336761,
+0x86182a, 0xeabd4d, 0xafe7b3, 0x6e6d8f, 0x396795, 0x5bbf31,
+0x48d784, 0x16df30, 0x432dc7, 0x356125, 0xce70c9, 0xb8cb30,
+0xfd6cbf, 0xa200a4, 0xe46c05, 0xa0dd5a, 0x476f21, 0xd21262,
+0x845cb9, 0x496170, 0xe0566b, 0x015299, 0x375550, 0xb7d51e,
+0xc4f133, 0x5f6e13, 0xe4305d, 0xa92e85, 0xc3b21d, 0x3632a1,
+0xa4b708, 0xd4b1ea, 0x21f716, 0xe4698f, 0x77ff27, 0x80030c,
+0x2d408d, 0xa0cd4f, 0x99a520, 0xd3a2b3, 0x0a5d2f, 0x42f9b4,
+0xcbda11, 0xd0be7d, 0xc1db9b, 0xbd17ab, 0x81a2ca, 0x5c6a08,
+0x17552e, 0x550027, 0xf0147f, 0x8607e1, 0x640b14, 0x8d4196,
+0xdebe87, 0x2afdda, 0xb6256b, 0x34897b, 0xfef305, 0x9ebfb9,
+0x4f6a68, 0xa82a4a, 0x5ac44f, 0xbcf82d, 0x985ad7, 0x95c7f4,
+0x8d4d0d, 0xa63a20, 0x5f57a4, 0xb13f14, 0x953880, 0x0120cc,
+0x86dd71, 0xb6dec9, 0xf560bf, 0x11654d, 0x6b0701, 0xacb08c,
+0xd0c0b2, 0x485551, 0x0efb1e, 0xc37295, 0x3b06a3, 0x3540c0,
+0x7bdc06, 0xcc45e0, 0xfa294e, 0xc8cad6, 0x41f3e8, 0xde647c,
+0xd8649b, 0x31bed9, 0xc397a4, 0xd45877, 0xc5e369, 0x13daf0,
+0x3c3aba, 0x461846, 0x5f7555, 0xf5bdd2, 0xc6926e, 0x5d2eac,
+0xed440e, 0x423e1c, 0x87c461, 0xe9fd29, 0xf3d6e7, 0xca7c22,
+0x35916f, 0xc5e008, 0x8dd7ff, 0xe26a6e, 0xc6fdb0, 0xc10893,
+0x745d7c, 0xb2ad6b, 0x9d6ecd, 0x7b723e, 0x6a11c6, 0xa9cff7,
+0xdf7329, 0xbac9b5, 0x5100b7, 0x0db2e2, 0x24ba74, 0x607de5,
+0x8ad874, 0x2c150d, 0x0c1881, 0x94667e, 0x162901, 0x767a9f,
+0xbefdfd, 0xef4556, 0x367ed9, 0x13d9ec, 0xb9ba8b, 0xfc97c4,
+0x27a831, 0xc36ef1, 0x36c594, 0x56a8d8, 0xb5a8b4, 0x0ecccf,
+0x2d8912, 0x34576f, 0x89562c, 0xe3ce99, 0xb920d6, 0xaa5e6b,
+0x9c2a3e, 0xcc5f11, 0x4a0bfd, 0xfbf4e1, 0x6d3b8e, 0x2c86e2,
+0x84d4e9, 0xa9b4fc, 0xd1eeef, 0xc9352e, 0x61392f, 0x442138,
+0xc8d91b, 0x0afc81, 0x6a4afb, 0xd81c2f, 0x84b453, 0x8c994e,
+0xcc2254, 0xdc552a, 0xd6c6c0, 0x96190b, 0xb8701a, 0x649569,
+0x605a26, 0xee523f, 0x0f117f, 0x11b5f4, 0xf5cbfc, 0x2dbc34,
+0xeebc34, 0xcc5de8, 0x605edd, 0x9b8e67, 0xef3392, 0xb817c9,
+0x9b5861, 0xbc57e1, 0xc68351, 0x103ed8, 0x4871dd, 0xdd1c2d,
+0xa118af, 0x462c21, 0xd7f359, 0x987ad9, 0xc0549e, 0xfa864f,
+0xfc0656, 0xae79e5, 0x362289, 0x22ad38, 0xdc9367, 0xaae855,
+0x382682, 0x9be7ca, 0xa40d51, 0xb13399, 0x0ed7a9, 0x480569,
+0xf0b265, 0xa7887f, 0x974c88, 0x36d1f9, 0xb39221, 0x4a827b,
+0x21cf98, 0xdc9f40, 0x5547dc, 0x3a74e1, 0x42eb67, 0xdf9dfe,
+0x5fd45e, 0xa4677b, 0x7aacba, 0xa2f655, 0x23882b, 0x55ba41,
+0x086e59, 0x862a21, 0x834739, 0xe6e389, 0xd49ee5, 0x40fb49,
+0xe956ff, 0xca0f1c, 0x8a59c5, 0x2bfa94, 0xc5c1d3, 0xcfc50f,
+0xae5adb, 0x86c547, 0x624385, 0x3b8621, 0x94792c, 0x876110,
+0x7b4c2a, 0x1a2c80, 0x12bf43, 0x902688, 0x893c78, 0xe4c4a8,
+0x7bdbe5, 0xc23ac4, 0xeaf426, 0x8a67f7, 0xbf920d, 0x2ba365,
+0xb1933d, 0x0b7cbd, 0xdc51a4, 0x63dd27, 0xdde169, 0x19949a,
+0x9529a8, 0x28ce68, 0xb4ed09, 0x209f44, 0xca984e, 0x638270,
+0x237c7e, 0x32b90f, 0x8ef5a7, 0xe75614, 0x08f121, 0x2a9db5,
+0x4d7e6f, 0x5119a5, 0xabf9b5, 0xd6df82, 0x61dd96, 0x023616,
+0x9f3ac4, 0xa1a283, 0x6ded72, 0x7a8d39, 0xa9b882, 0x5c326b,
+0x5b2746, 0xed3400, 0x7700d2, 0x55f4fc, 0x4d5901, 0x8071e0,
+0xe13f89, 0xb295f3, 0x64a8f1, 0xaea74b, 0x38fc4c, 0xeab2bb,
+0x47270b, 0xabc3a7, 0x34ba60, 0x52dd34, 0xf8563a, 0xeb7e8a,
+0x31bb36, 0x5895b7, 0x47f7a9, 0x94c3aa, 0xd39225, 0x1e7f3e,
+0xd8974e, 0xbba94f, 0xd8ae01, 0xe661b4, 0x393d8e, 0xa523aa,
+0x33068e, 0x1633b5, 0x3bb188, 0x1d3a9d, 0x4013d0, 0xcc1be5,
+0xf862e7, 0x3bf28f, 0x39b5bf, 0x0bc235, 0x22747e, 0xa247c0,
+0xd52d1f, 0x19add3, 0x9094df, 0x9311d0, 0xb42b25, 0x496db2,
+0xe264b2, 0x5ef135, 0x3bc6a4, 0x1a4ad0, 0xaac92e, 0x64e886,
+0x573091, 0x982cfb, 0x311b1a, 0x08728b, 0xbdcee1, 0x60e142,
+0xeb641d, 0xd0bba3, 0xe559d4, 0x597b8c, 0x2a4483, 0xf332ba,
+0xf84867, 0x2c8d1b, 0x2fa9b0, 0x50f3dd, 0xf9f573, 0xdb61b4,
+0xfe233e, 0x6c41a6, 0xeea318, 0x775a26, 0xbc5e5c, 0xcea708,
+0x94dc57, 0xe20196, 0xf1e839, 0xbe4851, 0x5d2d2f, 0x4e9555,
+0xd96ec2, 0xe7d755, 0x6304e0, 0xc02e0e, 0xfc40a0, 0xbbf9b3,
+0x7125a7, 0x222dfb, 0xf619d8, 0x838c1c, 0x6619e6, 0xb20d55,
+0xbb5137, 0x79e809, 0xaf9149, 0x0d73de, 0x0b0da5, 0xce7f58,
+0xac1934, 0x724667, 0x7a1a13, 0x9e26bc, 0x4555e7, 0x585cb5,
+0x711d14, 0x486991, 0x480d60, 0x56adab, 0xd62f64, 0x96ee0c,
+0x212ff3, 0x5d6d88, 0xa67684, 0x95651e, 0xab9e0a, 0x4ddefe,
+0x571010, 0x836a39, 0xf8ea31, 0x9e381d, 0xeac8b1, 0xcac96b,
+0x37f21e, 0xd505e9, 0x984743, 0x9fc56c, 0x0331b7, 0x3b8bf8,
+0x86e56a, 0x8dc343, 0x6230e7, 0x93cfd5, 0x6a8f2d, 0x733005,
+0x1af021, 0xa09fcb, 0x7415a1, 0xd56b23, 0x6ff725, 0x2f4bc7,
+0xb8a591, 0x7fac59, 0x5c55de, 0x212c38, 0xb13296, 0x5cff50,
+0x366262, 0xfa7b16, 0xf4d9a6, 0x2acfe7, 0xf07403, 0xd4d604,
+0x6fd916, 0x31b1bf, 0xcbb450, 0x5bd7c8, 0x0ce194, 0x6bd643,
+0x4fd91c, 0xdf4543, 0x5f3453, 0xe2b5aa, 0xc9aec8, 0x131485,
+0xf9d2bf, 0xbadb9e, 0x76f5b9, 0xaf15cf, 0xca3182, 0x14b56d,
+0xe9fe4d, 0x50fc35, 0xf5aed5, 0xa2d0c1, 0xc96057, 0x192eb6,
+0xe91d92, 0x07d144, 0xaea3c6, 0x343566, 0x26d5b4, 0x3161e2,
+0x37f1a2, 0x209eff, 0x958e23, 0x493798, 0x35f4a6, 0x4bdc02,
+0xc2be13, 0xbe80a0, 0x0b72a3, 0x115c5f, 0x1e1bd1, 0x0db4d3,
+0x869e85, 0x96976b, 0x2ac91f, 0x8a26c2, 0x3070f0, 0x041412,
+0xfc9fa5, 0xf72a38, 0x9c6878, 0xe2aa76, 0x50cfe1, 0x559274,
+0x934e38, 0x0a92f7, 0x5533f0, 0xa63db4, 0x399971, 0xe2b755,
+0xa98a7c, 0x008f19, 0xac54d2, 0x2ea0b4, 0xf5f3e0, 0x60c849,
+0xffd269, 0xae52ce, 0x7a5fdd, 0xe9ce06, 0xfb0ae8, 0xa50cce,
+0xea9d3e, 0x3766dd, 0xb834f5, 0x0da090, 0x846f88, 0x4ae3d5,
+0x099a03, 0x2eae2d, 0xfcb40a, 0xfb9b33, 0xe281dd, 0x1b16ba,
+0xd8c0af, 0xd96b97, 0xb52dc9, 0x9c277f, 0x5951d5, 0x21ccd6,
+0xb6496b, 0x584562, 0xb3baf2, 0xa1a5c4, 0x7ca2cf, 0xa9b93d,
+0x7b7b89, 0x483d38,
+};
+
+static const long double c[] = {
+/* 93 bits of pi/2 */
+#define PI_2_1 c[0]
+ 1.57079632679489661923132169155131424e+00L, /* 3fff921fb54442d18469898cc5100000 */
+
+/* pi/2 - PI_2_1 */
+#define PI_2_1t c[1]
+ 8.84372056613570112025531863263659260e-29L, /* 3fa1c06e0e68948127044533e63a0106 */
+};
+
+int32_t __ieee754_rem_pio2l(long double x, long double *y)
+{
+  long double z, w, t;
+  double tx[8];
+  int64_t exp, n, ix, hx, ixd;
+  u_int64_t lx, lxd;
+
+  GET_LDOUBLE_WORDS64 (hx, lx, x);
+  ix = hx & 0x7fffffffffffffffLL;
+  if (ix <= 0x3fe921fb54442d10LL)      /* x in <-pi/4, pi/4> */
+    {
+      y[0] = x;
+      y[1] = 0;
+      return 0;
+    }
+
+  if (ix < 0x4002d97c7f3321d0LL)       /* |x| in <pi/4, 3pi/4) */
+    {
+      if (hx > 0)
+       {
+         /* 113 + 93 bit PI is ok */
+         z = x - PI_2_1;
+         y[0] = z - PI_2_1t;
+         y[1] = (z - y[0]) - PI_2_1t;
+         return 1;
+       }
+      else
+        {
+         /* 113 + 93 bit PI is ok */
+         z = x + PI_2_1;
+         y[0] = z + PI_2_1t;
+         y[1] = (z - y[0]) + PI_2_1t;
+         return -1;
+       }
+    }
+
+  if (ix >= 0x7ff0000000000000LL)      /* x is +=oo or NaN */
+    {
+      y[0] = x - x;
+      y[1] = y[0];
+      return 0;
+    }
+
+  /* Handle large arguments.
+     We split the 113 bits of the mantissa into 5 24bit integers
+     stored in a double array.  */
+  /* Make the IBM extended format 105 bit mantissa look like the ieee854 112
+     bit mantissa so the next operatation will give the correct result.  */
+  EXTRACT_IBM_EXTENDED_MANTISSA (ixd, lxd, exp, x);
+  exp = exp - 23;
+  /* This is faster than doing this in floating point, because we
+     have to convert it to integers anyway and like this we can keep
+     both integer and floating point units busy.  */
+  tx [0] = (double)(((ixd >> 25) & 0x7fffff) | 0x800000);
+  tx [1] = (double)((ixd >> 1) & 0xffffff);
+  tx [2] = (double)(((ixd << 23) | (lxd >> 41)) & 0xffffff);
+  tx [3] = (double)((lxd >> 17) & 0xffffff);
+  tx [4] = (double)((lxd << 7) & 0xffffff);
+
+  n = __kernel_rem_pio2 (tx, tx + 5, exp, ((lxd << 7) & 0xffffff) ? 5 : 4,
+                        3, two_over_pi);
+
+  /* The result is now stored in 3 double values, we need to convert it into
+     two long double values.  */
+  t = (long double) tx [6] + (long double) tx [7];
+  w = (long double) tx [5];
+
+  if (hx >= 0)
+    {
+      y[0] = w + t;
+      y[1] = t - (y[0] - w);
+      return n;
+    }
+  else
+    {
+      y[0] = -(w + t);
+      y[1] = -t - (y[0] + w);
+      return -n;
+    }
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_remainderl.c b/sysdeps/ieee754/ldbl-128ibm/e_remainderl.c
new file mode 100644 (file)
index 0000000..b7fa68f
--- /dev/null
@@ -0,0 +1,78 @@
+/* e_fmodl.c -- long double version of e_fmod.c.
+ * Conversion to IEEE quad long double by Jakub Jelinek, jj@ultra.linux.cz.
+ */
+/*
+ * ====================================================
+ * 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_remainderl(x,p)
+ * Return :
+ *     returns  x REM p  =  x - [x/p]*p as if in infinite
+ *     precise arithmetic, where [x/p] is the (infinite bit)
+ *     integer nearest x/p (in half way case choose the even one).
+ * Method :
+ *     Based on fmodl() return x-[x/p]chopped*p exactlp.
+ */
+
+#include "math.h"
+#include "math_private.h"
+
+#ifdef __STDC__
+static const long double zero = 0.0L;
+#else
+static long double zero = 0.0L;
+#endif
+
+
+#ifdef __STDC__
+       long double __ieee754_remainderl(long double x, long double p)
+#else
+       long double __ieee754_remainderl(x,p)
+       long double x,p;
+#endif
+{
+       int64_t hx,hp;
+       u_int64_t sx,lx,lp;
+       long double p_half;
+
+       GET_LDOUBLE_WORDS64(hx,lx,x);
+       GET_LDOUBLE_WORDS64(hp,lp,p);
+       sx = hx&0x8000000000000000ULL;
+       hp &= 0x7fffffffffffffffLL;
+       hx &= 0x7fffffffffffffffLL;
+
+    /* purge off exception values */
+       if((hp|(lp&0x7fffffffffffffff))==0) return (x*p)/(x*p);         /* p = 0 */
+       if((hx>=0x7ff0000000000000LL)||                 /* x not finite */
+         ((hp>=0x7ff0000000000000LL)&&                 /* p is NaN */
+         (((hp-0x7ff0000000000000LL)|lp)!=0)))
+           return (x*p)/(x*p);
+
+
+       if (hp<=0x7fdfffffffffffffLL) x = __ieee754_fmodl(x,p+p);       /* now x < 2p */
+       if (((hx-hp)|(lx-lp))==0) return zero*x;
+       x  = fabsl(x);
+       p  = fabsl(p);
+       if (hp<0x0020000000000000LL) {
+           if(x+x>p) {
+               x-=p;
+               if(x+x>=p) x -= p;
+           }
+       } else {
+           p_half = 0.5L*p;
+           if(x>p_half) {
+               x-=p;
+               if(x>=p_half) x -= p;
+           }
+       }
+       GET_LDOUBLE_MSW64(hx,x);
+       SET_LDOUBLE_MSW64(x,hx^sx);
+       return x;
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_sinhl.c b/sysdeps/ieee754/ldbl-128ibm/e_sinhl.c
new file mode 100644 (file)
index 0000000..38ae71d
--- /dev/null
@@ -0,0 +1,84 @@
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: e_sinh.c,v 1.7 1995/05/10 20:46:13 jtc Exp $";
+#endif
+
+/* __ieee754_sinh(x)
+ * Method :
+ * mathematically sinh(x) if defined to be (exp(x)-exp(-x))/2
+ *     1. Replace x by |x| (sinh(-x) = -sinh(x)).
+ *     2.
+ *                                                 E + E/(E+1)
+ *         0        <= x <= 22     :  sinh(x) := --------------, E=expm1(x)
+ *                                                     2
+ *
+ *         22       <= x <= lnovft :  sinh(x) := exp(x)/2
+ *         lnovft   <= x <= ln2ovft:  sinh(x) := exp(x/2)/2 * exp(x/2)
+ *         ln2ovft  <  x           :  sinh(x) := x*shuge (overflow)
+ *
+ * Special cases:
+ *     sinh(x) is |x| if x is +INF, -INF, or NaN.
+ *     only sinh(0)=0 is exact for finite x.
+ */
+
+#include "math.h"
+#include "math_private.h"
+
+#ifdef __STDC__
+static const long double one = 1.0, shuge = 1.0e307;
+#else
+static long double one = 1.0, shuge = 1.0e307;
+#endif
+
+#ifdef __STDC__
+       long double __ieee754_sinhl(long double x)
+#else
+       long double __ieee754_sinhl(x)
+       long double x;
+#endif
+{
+       long double t,w,h;
+       int64_t ix,jx;
+
+    /* High word of |x|. */
+       GET_LDOUBLE_MSW64(jx,x);
+       ix = jx&0x7fffffffffffffffLL;
+
+    /* x is INF or NaN */
+       if(ix>=0x7ff0000000000000LL) return x+x;
+
+       h = 0.5;
+       if (jx<0) h = -h;
+    /* |x| in [0,22], return sign(x)*0.5*(E+E/(E+1))) */
+       if (ix < 0x4036000000000000LL) {        /* |x|<22 */
+           if (ix<0x3e20000000000000LL)        /* |x|<2**-29 */
+               if(shuge+x>one) return x;/* sinhl(tiny) = tiny with inexact */
+           t = __expm1l(fabsl(x));
+           if(ix<0x3ff0000000000000LL) return h*(2.0*t-t*t/(t+one));
+           return h*(t+t/(t+one));
+       }
+
+    /* |x| in [22, log(maxdouble)] return 0.5*exp(|x|) */
+       if (ix < 0x40862e42fefa39efLL)  return h*__ieee754_expl(fabsl(x));
+
+    /* |x| in [log(maxdouble), overflowthresold] */
+       if (ix <= 0x408633ce8fb9f87dLL) {
+           w = __ieee754_expl(0.5*fabsl(x));
+           t = h*w;
+           return t*w;
+       }
+
+    /* |x| > overflowthresold, sinh(x) overflow */
+       return x*shuge;
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_sqrtl.c b/sysdeps/ieee754/ldbl-128ibm/e_sqrtl.c
new file mode 100644 (file)
index 0000000..1f533ca
--- /dev/null
@@ -0,0 +1,109 @@
+/*
+ * IBM Accurate Mathematical Library
+ * written by International Business Machines Corp.
+ * Copyright (C) 2001, 2004, 2006 Free Software Foundation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser 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.
+ */
+/*********************************************************************/
+/* MODULE_NAME: uroot.c                                              */
+/*                                                                   */
+/* FUNCTION:    usqrt                                                */
+/*                                                                   */
+/* FILES NEEDED: dla.h endian.h mydefs.h uroot.h                     */
+/*               uroot.tbl                                           */
+/*                                                                   */
+/* An ultimate sqrt routine. Given an IEEE double machine number x   */
+/* it computes the correctly rounded (to nearest) value of square    */
+/* root of x.                                                        */
+/* Assumption: Machine arithmetic operations are performed in        */
+/* round to nearest mode of IEEE 754 standard.                       */
+/*                                                                   */
+/*********************************************************************/
+
+#include <math_private.h>
+
+typedef unsigned int int4;
+typedef union {int4 i[4]; long double x; double d[2]; } mynumber;
+
+static const  mynumber
+  t512 = {{0x5ff00000, 0x00000000, 0x00000000, 0x00000000 }},  /* 2^512  */
+  tm256 = {{0x2ff00000, 0x00000000, 0x00000000, 0x00000000 }};  /* 2^-256 */
+static const double
+two54 = 1.80143985094819840000e+16, /* 0x4350000000000000 */
+twom54 = 5.55111512312578270212e-17; /* 0x3C90000000000000 */
+
+/*********************************************************************/
+/* An ultimate sqrt routine. Given an IEEE double machine number x   */
+/* it computes the correctly rounded (to nearest) value of square    */
+/* root of x.                                                        */
+/*********************************************************************/
+long double __ieee754_sqrtl(long double x) 
+{
+  static const long double big = 134217728.0, big1 = 134217729.0;
+  long double t,s,i;
+  mynumber a,c;
+  int4 k, l, m;
+  int n;
+  double d;
+
+  a.x=x;
+  k=a.i[0] & 0x7fffffff;
+  /*----------------- 2^-1022  <= | x |< 2^1024  -----------------*/
+  if (k>0x000fffff && k<0x7ff00000) {
+    if (x < 0) return (big1-big1)/(big-big);
+    l = (k&0x001fffff)|0x3fe00000;
+    if (((a.i[2] & 0x7fffffff) | a.i[3]) != 0) {
+      n = (int) ((l - k) * 2) >> 21;
+      m = (a.i[2] >> 20) & 0x7ff;
+      if (m == 0) {
+       a.d[1] *= two54;
+       m = ((a.i[2] >> 20) & 0x7ff) - 54;
+      }
+      m += n;
+      if (m > 0)
+       a.i[2] = (a.i[2] & 0x800fffff) | (m << 20);
+      else if (m <= -54) {
+       a.i[2] &= 0x80000000;
+       a.i[3] = 0;
+      } else {
+       m += 54;
+       a.i[2] = (a.i[2] & 0x800fffff) | (m << 20);
+       a.d[1] *= twom54;
+      }
+    }
+    a.i[0] = l;
+    s = a.x;
+    d = __ieee754_sqrt (a.d[0]);
+    c.i[0] = 0x20000000+((k&0x7fe00000)>>1);
+    c.i[1] = 0;
+    c.i[2] = 0;
+    c.i[3] = 0;
+    i = d;
+    t = 0.5L * (i + s / i);
+    i = 0.5L * (t + s / t);
+    return c.x * i;
+  }
+  else {
+    if (k>=0x7ff00000) {
+      if (a.i[0] == 0xfff00000 && a.i[1] == 0)
+       return (big1-big1)/(big-big); /* sqrt (-Inf) = NaN.  */
+      return x; /* sqrt (NaN) = NaN, sqrt (+Inf) = +Inf.  */
+    }
+    if (x == 0) return x;
+    if (x < 0) return (big1-big1)/(big-big);
+    return tm256.x*__ieee754_sqrtl(x*t512.x);
+  }
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/ieee754.h b/sysdeps/ieee754/ldbl-128ibm/ieee754.h
new file mode 100644 (file)
index 0000000..94a2091
--- /dev/null
@@ -0,0 +1,210 @@
+/* Copyright (C) 1992, 1995, 1996, 1999, 2004, 2006
+   Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#ifndef _IEEE754_H
+
+#define _IEEE754_H 1
+#include <features.h>
+
+#include <endian.h>
+
+__BEGIN_DECLS
+
+union ieee754_float
+  {
+    float f;
+
+    /* This is the IEEE 754 single-precision format.  */
+    struct
+      {
+#if    __BYTE_ORDER == __BIG_ENDIAN
+       unsigned int negative:1;
+       unsigned int exponent:8;
+       unsigned int mantissa:23;
+#endif                         /* Big endian.  */
+#if    __BYTE_ORDER == __LITTLE_ENDIAN
+       unsigned int mantissa:23;
+       unsigned int exponent:8;
+       unsigned int negative:1;
+#endif                         /* Little endian.  */
+      } ieee;
+
+    /* This format makes it easier to see if a NaN is a signalling NaN.  */
+    struct
+      {
+#if    __BYTE_ORDER == __BIG_ENDIAN
+       unsigned int negative:1;
+       unsigned int exponent:8;
+       unsigned int quiet_nan:1;
+       unsigned int mantissa:22;
+#endif                         /* Big endian.  */
+#if    __BYTE_ORDER == __LITTLE_ENDIAN
+       unsigned int mantissa:22;
+       unsigned int quiet_nan:1;
+       unsigned int exponent:8;
+       unsigned int negative:1;
+#endif                         /* Little endian.  */
+      } ieee_nan;
+  };
+
+#define IEEE754_FLOAT_BIAS     0x7f /* Added to exponent.  */
+
+
+union ieee754_double
+  {
+    double d;
+
+    /* This is the IEEE 754 double-precision format.  */
+    struct
+      {
+#if    __BYTE_ORDER == __BIG_ENDIAN
+       unsigned int negative:1;
+       unsigned int exponent:11;
+       /* Together these comprise the mantissa.  */
+       unsigned int mantissa0:20;
+       unsigned int mantissa1:32;
+#endif                         /* Big endian.  */
+#if    __BYTE_ORDER == __LITTLE_ENDIAN
+       /* Together these comprise the mantissa.  */
+       unsigned int mantissa1:32;
+       unsigned int mantissa0:20;
+       unsigned int exponent:11;
+       unsigned int negative:1;
+#endif                         /* Little endian.  */
+      } ieee;
+
+    /* This format makes it easier to see if a NaN is a signalling NaN.  */
+    struct
+      {
+#if    __BYTE_ORDER == __BIG_ENDIAN
+       unsigned int negative:1;
+       unsigned int exponent:11;
+       unsigned int quiet_nan:1;
+       /* Together these comprise the mantissa.  */
+       unsigned int mantissa0:19;
+       unsigned int mantissa1:32;
+#else
+       /* Together these comprise the mantissa.  */
+       unsigned int mantissa1:32;
+       unsigned int mantissa0:19;
+       unsigned int quiet_nan:1;
+       unsigned int exponent:11;
+       unsigned int negative:1;
+#endif
+      } ieee_nan;
+  };
+
+#define IEEE754_DOUBLE_BIAS    0x3ff /* Added to exponent.  */
+
+
+union ieee854_long_double
+  {
+    long double d;
+
+    /* This is the IEEE 854 quad-precision format.  */
+    struct
+      {
+#if    __BYTE_ORDER == __BIG_ENDIAN
+       unsigned int negative:1;
+       unsigned int exponent:15;
+       /* Together these comprise the mantissa.  */
+       unsigned int mantissa0:16;
+       unsigned int mantissa1:32;
+       unsigned int mantissa2:32;
+       unsigned int mantissa3:32;
+#endif                         /* Big endian.  */
+#if    __BYTE_ORDER == __LITTLE_ENDIAN
+       /* Together these comprise the mantissa.  */
+       unsigned int mantissa3:32;
+       unsigned int mantissa2:32;
+       unsigned int mantissa1:32;
+       unsigned int mantissa0:16;
+       unsigned int exponent:15;
+       unsigned int negative:1;
+#endif                         /* Little endian.  */
+      } ieee;
+
+    /* This format makes it easier to see if a NaN is a signalling NaN.  */
+    struct
+      {
+#if    __BYTE_ORDER == __BIG_ENDIAN
+       unsigned int negative:1;
+       unsigned int exponent:15;
+       unsigned int quiet_nan:1;
+       /* Together these comprise the mantissa.  */
+       unsigned int mantissa0:15;
+       unsigned int mantissa1:32;
+       unsigned int mantissa2:32;
+       unsigned int mantissa3:32;
+#else
+       /* Together these comprise the mantissa.  */
+       unsigned int mantissa3:32;
+       unsigned int mantissa2:32;
+       unsigned int mantissa1:32;
+       unsigned int mantissa0:15;
+       unsigned int quiet_nan:1;
+       unsigned int exponent:15;
+       unsigned int negative:1;
+#endif
+      } ieee_nan;
+  };
+
+#define IEEE854_LONG_DOUBLE_BIAS 0x3fff /* Added to exponent.  */
+
+
+/* IBM extended format for long double.
+
+   Each long double is made up of two IEEE doubles.  The value of the
+   long double is the sum of the values of the two parts.  The most
+   significant part is required to be the value of the long double
+   rounded to the nearest double, as specified by IEEE.  For Inf
+   values, the least significant part is required to be one of +0.0 or
+   -0.0.  No other requirements are made; so, for example, 1.0 may be
+   represented as (1.0, +0.0) or (1.0, -0.0), and the low part of a
+   NaN is don't-care.  */
+
+union ibm_extended_long_double
+  {
+    long double d;
+    double dd[2];
+
+    /* This is the IBM extended format long double.  */
+    struct
+      { /* Big endian.  There is no other.  */
+
+       unsigned int negative:1;
+       unsigned int exponent:11;
+       /* Together Mantissa0-3 comprise the mantissa.  */
+       unsigned int mantissa0:20;
+       unsigned int mantissa1:32;
+
+       unsigned int negative2:1;
+       unsigned int exponent2:11;
+       /* There is an implied 1 here?  */
+       /* Together these comprise the mantissa.  */
+       unsigned int mantissa2:20;
+       unsigned int mantissa3:32;
+      } ieee;
+   };
+
+#define IBM_EXTENDED_LONG_DOUBLE_BIAS 0x3ff /* Added to exponent.  */
+
+__END_DECLS
+
+#endif /* ieee754.h */
diff --git a/sysdeps/ieee754/ldbl-128ibm/k_cosl.c b/sysdeps/ieee754/ldbl-128ibm/k_cosl.c
new file mode 100644 (file)
index 0000000..3baf8b7
--- /dev/null
@@ -0,0 +1,128 @@
+/* Quad-precision floating point cosine on <-pi/4,pi/4>.
+   Copyright (C) 1999,2004,2006 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Jakub Jelinek <jj@ultra.linux.cz>
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; 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"
+
+static const long double c[] = {
+#define ONE c[0]
+ 1.00000000000000000000000000000000000E+00L, /* 3fff0000000000000000000000000000 */
+
+/* cos x ~ ONE + x^2 ( SCOS1 + SCOS2 * x^2 + ... + SCOS4 * x^6 + SCOS5 * x^8 )
+   x in <0,1/256>  */
+#define SCOS1 c[1]
+#define SCOS2 c[2]
+#define SCOS3 c[3]
+#define SCOS4 c[4]
+#define SCOS5 c[5]
+-5.00000000000000000000000000000000000E-01L, /* bffe0000000000000000000000000000 */
+ 4.16666666666666666666666666556146073E-02L, /* 3ffa5555555555555555555555395023 */
+-1.38888888888888888888309442601939728E-03L, /* bff56c16c16c16c16c16a566e42c0375 */
+ 2.48015873015862382987049502531095061E-05L, /* 3fefa01a01a019ee02dcf7da2d6d5444 */
+-2.75573112601362126593516899592158083E-07L, /* bfe927e4f5dce637cb0b54908754bde0 */
+
+/* cos x ~ ONE + x^2 ( COS1 + COS2 * x^2 + ... + COS7 * x^12 + COS8 * x^14 )
+   x in <0,0.1484375>  */
+#define COS1 c[6]
+#define COS2 c[7]
+#define COS3 c[8]
+#define COS4 c[9]
+#define COS5 c[10]
+#define COS6 c[11]
+#define COS7 c[12]
+#define COS8 c[13]
+-4.99999999999999999999999999999999759E-01L, /* bffdfffffffffffffffffffffffffffb */
+ 4.16666666666666666666666666651287795E-02L, /* 3ffa5555555555555555555555516f30 */
+-1.38888888888888888888888742314300284E-03L, /* bff56c16c16c16c16c16c16a463dfd0d */
+ 2.48015873015873015867694002851118210E-05L, /* 3fefa01a01a01a01a0195cebe6f3d3a5 */
+-2.75573192239858811636614709689300351E-07L, /* bfe927e4fb7789f5aa8142a22044b51f */
+ 2.08767569877762248667431926878073669E-09L, /* 3fe21eed8eff881d1e9262d7adff4373 */
+-1.14707451049343817400420280514614892E-11L, /* bfda9397496922a9601ed3d4ca48944b */
+ 4.77810092804389587579843296923533297E-14L, /* 3fd2ae5f8197cbcdcaf7c3fb4523414c */
+
+/* sin x ~ ONE * x + x^3 ( SSIN1 + SSIN2 * x^2 + ... + SSIN4 * x^6 + SSIN5 * x^8 )
+   x in <0,1/256>  */
+#define SSIN1 c[14]
+#define SSIN2 c[15]
+#define SSIN3 c[16]
+#define SSIN4 c[17]
+#define SSIN5 c[18]
+-1.66666666666666666666666666666666659E-01L, /* bffc5555555555555555555555555555 */
+ 8.33333333333333333333333333146298442E-03L, /* 3ff81111111111111111111110fe195d */
+-1.98412698412698412697726277416810661E-04L, /* bff2a01a01a01a01a019e7121e080d88 */
+ 2.75573192239848624174178393552189149E-06L, /* 3fec71de3a556c640c6aaa51aa02ab41 */
+-2.50521016467996193495359189395805639E-08L, /* bfe5ae644ee90c47dc71839de75b2787 */
+};
+
+#define SINCOSL_COS_HI 0
+#define SINCOSL_COS_LO 1
+#define SINCOSL_SIN_HI 2
+#define SINCOSL_SIN_LO 3
+extern const long double __sincosl_table[];
+
+long double
+__kernel_cosl(long double x, long double y)
+{
+  long double h, l, z, sin_l, cos_l_m1;
+  int64_t ix;
+  u_int32_t tix, hix, index;
+  GET_LDOUBLE_MSW64 (ix, x);
+  tix = ((u_int64_t)ix) >> 32;
+  tix &= ~0x80000000;                  /* tix = |x|'s high 32 bits */
+  if (tix < 0x3fc30000)                        /* |x| < 0.1484375 */
+    {
+      /* Argument is small enough to approximate it by a Chebyshev
+        polynomial of degree 16.  */
+      if (tix < 0x3c600000)            /* |x| < 2^-57 */
+       if (!((int)x)) return ONE;      /* generate inexact */
+      z = x * x;
+      return ONE + (z*(COS1+z*(COS2+z*(COS3+z*(COS4+
+                   z*(COS5+z*(COS6+z*(COS7+z*COS8))))))));
+    }
+  else
+    {
+      /* So that we don't have to use too large polynomial,  we find
+        l and h such that x = l + h,  where fabsl(l) <= 1.0/256 with 83
+        possible values for h.  We look up cosl(h) and sinl(h) in
+        pre-computed tables,  compute cosl(l) and sinl(l) using a
+        Chebyshev polynomial of degree 10(11) and compute
+        cosl(h+l) = cosl(h)cosl(l) - sinl(h)sinl(l).  */
+      index = 0x3fe - (tix >> 20);
+      hix = (tix + (0x200 << index)) & (0xfffffc00 << index);
+      x = fabsl (x);
+      switch (index)
+       {
+       case 0: index = ((45 << 14) + hix - 0x3fe00000) >> 12; break;
+       case 1: index = ((13 << 15) + hix - 0x3fd00000) >> 13; break;
+       default:
+       case 2: index = (hix - 0x3fc30000) >> 14; break;
+       }
+
+      SET_LDOUBLE_WORDS64(h, ((u_int64_t)hix) << 32, 0);
+      l = y - (h - x);
+      z = l * l;
+      sin_l = l*(ONE+z*(SSIN1+z*(SSIN2+z*(SSIN3+z*(SSIN4+z*SSIN5)))));
+      cos_l_m1 = z*(SCOS1+z*(SCOS2+z*(SCOS3+z*(SCOS4+z*SCOS5))));
+      return __sincosl_table [index + SINCOSL_COS_HI]
+            + (__sincosl_table [index + SINCOSL_COS_LO]
+               - (__sincosl_table [index + SINCOSL_SIN_HI] * sin_l
+                  - __sincosl_table [index + SINCOSL_COS_HI] * cos_l_m1));
+    }
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/k_sincosl.c b/sysdeps/ieee754/ldbl-128ibm/k_sincosl.c
new file mode 100644 (file)
index 0000000..1cea6fe
--- /dev/null
@@ -0,0 +1,163 @@
+/* Quad-precision floating point sine and cosine on <-pi/4,pi/4>.
+   Copyright (C) 1999,2004,2006 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Jakub Jelinek <jj@ultra.linux.cz>
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; 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"
+
+static const long double c[] = {
+#define ONE c[0]
+ 1.00000000000000000000000000000000000E+00L, /* 3fff0000000000000000000000000000 */
+
+/* cos x ~ ONE + x^2 ( SCOS1 + SCOS2 * x^2 + ... + SCOS4 * x^6 + SCOS5 * x^8 )
+   x in <0,1/256>  */
+#define SCOS1 c[1]
+#define SCOS2 c[2]
+#define SCOS3 c[3]
+#define SCOS4 c[4]
+#define SCOS5 c[5]
+-5.00000000000000000000000000000000000E-01L, /* bffe0000000000000000000000000000 */
+ 4.16666666666666666666666666556146073E-02L, /* 3ffa5555555555555555555555395023 */
+-1.38888888888888888888309442601939728E-03L, /* bff56c16c16c16c16c16a566e42c0375 */
+ 2.48015873015862382987049502531095061E-05L, /* 3fefa01a01a019ee02dcf7da2d6d5444 */
+-2.75573112601362126593516899592158083E-07L, /* bfe927e4f5dce637cb0b54908754bde0 */
+
+/* cos x ~ ONE + x^2 ( COS1 + COS2 * x^2 + ... + COS7 * x^12 + COS8 * x^14 )
+   x in <0,0.1484375>  */
+#define COS1 c[6]
+#define COS2 c[7]
+#define COS3 c[8]
+#define COS4 c[9]
+#define COS5 c[10]
+#define COS6 c[11]
+#define COS7 c[12]
+#define COS8 c[13]
+-4.99999999999999999999999999999999759E-01L, /* bffdfffffffffffffffffffffffffffb */
+ 4.16666666666666666666666666651287795E-02L, /* 3ffa5555555555555555555555516f30 */
+-1.38888888888888888888888742314300284E-03L, /* bff56c16c16c16c16c16c16a463dfd0d */
+ 2.48015873015873015867694002851118210E-05L, /* 3fefa01a01a01a01a0195cebe6f3d3a5 */
+-2.75573192239858811636614709689300351E-07L, /* bfe927e4fb7789f5aa8142a22044b51f */
+ 2.08767569877762248667431926878073669E-09L, /* 3fe21eed8eff881d1e9262d7adff4373 */
+-1.14707451049343817400420280514614892E-11L, /* bfda9397496922a9601ed3d4ca48944b */
+ 4.77810092804389587579843296923533297E-14L, /* 3fd2ae5f8197cbcdcaf7c3fb4523414c */
+
+/* sin x ~ ONE * x + x^3 ( SSIN1 + SSIN2 * x^2 + ... + SSIN4 * x^6 + SSIN5 * x^8 )
+   x in <0,1/256>  */
+#define SSIN1 c[14]
+#define SSIN2 c[15]
+#define SSIN3 c[16]
+#define SSIN4 c[17]
+#define SSIN5 c[18]
+-1.66666666666666666666666666666666659E-01L, /* bffc5555555555555555555555555555 */
+ 8.33333333333333333333333333146298442E-03L, /* 3ff81111111111111111111110fe195d */
+-1.98412698412698412697726277416810661E-04L, /* bff2a01a01a01a01a019e7121e080d88 */
+ 2.75573192239848624174178393552189149E-06L, /* 3fec71de3a556c640c6aaa51aa02ab41 */
+-2.50521016467996193495359189395805639E-08L, /* bfe5ae644ee90c47dc71839de75b2787 */
+
+/* sin x ~ ONE * x + x^3 ( SIN1 + SIN2 * x^2 + ... + SIN7 * x^12 + SIN8 * x^14 )
+   x in <0,0.1484375>  */
+#define SIN1 c[19]
+#define SIN2 c[20]
+#define SIN3 c[21]
+#define SIN4 c[22]
+#define SIN5 c[23]
+#define SIN6 c[24]
+#define SIN7 c[25]
+#define SIN8 c[26]
+-1.66666666666666666666666666666666538e-01L, /* bffc5555555555555555555555555550 */
+ 8.33333333333333333333333333307532934e-03L, /* 3ff811111111111111111111110e7340 */
+-1.98412698412698412698412534478712057e-04L, /* bff2a01a01a01a01a01a019e7a626296 */
+ 2.75573192239858906520896496653095890e-06L, /* 3fec71de3a556c7338fa38527474b8f5 */
+-2.50521083854417116999224301266655662e-08L, /* bfe5ae64567f544e16c7de65c2ea551f */
+ 1.60590438367608957516841576404938118e-10L, /* 3fde6124613a811480538a9a41957115 */
+-7.64716343504264506714019494041582610e-13L, /* bfd6ae7f3d5aef30c7bc660b060ef365 */
+ 2.81068754939739570236322404393398135e-15L, /* 3fce9510115aabf87aceb2022a9a9180 */
+};
+
+#define SINCOSL_COS_HI 0
+#define SINCOSL_COS_LO 1
+#define SINCOSL_SIN_HI 2
+#define SINCOSL_SIN_LO 3
+extern const long double __sincosl_table[];
+
+void
+__kernel_sincosl(long double x, long double y, long double *sinx, long double *cosx, int iy)
+{
+  long double h, l, z, sin_l, cos_l_m1;
+  int64_t ix;
+  u_int32_t tix, hix, index;
+  GET_LDOUBLE_MSW64 (ix, x);
+  tix = ((u_int64_t)ix) >> 32;
+  tix &= ~0x80000000;                  /* tix = |x|'s high 32 bits */
+  if (tix < 0x3fc30000)                        /* |x| < 0.1484375 */
+    {
+      /* Argument is small enough to approximate it by a Chebyshev
+        polynomial of degree 16(17).  */
+      if (tix < 0x3c600000)            /* |x| < 2^-57 */
+       if (!((int)x))                  /* generate inexact */
+         {
+           *sinx = x;
+           *cosx = ONE;
+           return;
+         }
+      z = x * x;
+      *sinx = x + (x * (z*(SIN1+z*(SIN2+z*(SIN3+z*(SIN4+
+                       z*(SIN5+z*(SIN6+z*(SIN7+z*SIN8)))))))));
+      *cosx = ONE + (z*(COS1+z*(COS2+z*(COS3+z*(COS4+
+                    z*(COS5+z*(COS6+z*(COS7+z*COS8))))))));
+    }
+  else
+    {
+      /* So that we don't have to use too large polynomial,  we find
+        l and h such that x = l + h,  where fabsl(l) <= 1.0/256 with 83
+        possible values for h.  We look up cosl(h) and sinl(h) in
+        pre-computed tables,  compute cosl(l) and sinl(l) using a
+        Chebyshev polynomial of degree 10(11) and compute
+        sinl(h+l) = sinl(h)cosl(l) + cosl(h)sinl(l) and
+        cosl(h+l) = cosl(h)cosl(l) - sinl(h)sinl(l).  */
+      index = 0x3fe - (tix >> 20);
+      hix = (tix + (0x2000 << index)) & (0xffffc000 << index);
+      x = fabsl (x);
+      switch (index)
+       {
+       case 0: index = ((45 << 14) + hix - 0x3fe00000) >> 12; break;
+       case 1: index = ((13 << 15) + hix - 0x3fd00000) >> 13; break;
+       default:
+       case 2: index = (hix - 0x3fc30000) >> 14; break;
+       }
+
+      SET_LDOUBLE_WORDS64(h, ((u_int64_t)hix) << 32, 0);
+      if (iy)
+       l = y - (h - x);
+      else
+       l = x - h;
+      z = l * l;
+      sin_l = l*(ONE+z*(SSIN1+z*(SSIN2+z*(SSIN3+z*(SSIN4+z*SSIN5)))));
+      cos_l_m1 = z*(SCOS1+z*(SCOS2+z*(SCOS3+z*(SCOS4+z*SCOS5))));
+      z = __sincosl_table [index + SINCOSL_SIN_HI]
+         + (__sincosl_table [index + SINCOSL_SIN_LO]
+            + (__sincosl_table [index + SINCOSL_SIN_HI] * cos_l_m1)
+            + (__sincosl_table [index + SINCOSL_COS_HI] * sin_l));
+      *sinx = (ix < 0) ? -z : z;
+      *cosx = __sincosl_table [index + SINCOSL_COS_HI]
+             + (__sincosl_table [index + SINCOSL_COS_LO]
+                - (__sincosl_table [index + SINCOSL_SIN_HI] * sin_l
+                   - __sincosl_table [index + SINCOSL_COS_HI] * cos_l_m1));
+    }
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/k_sinl.c b/sysdeps/ieee754/ldbl-128ibm/k_sinl.c
new file mode 100644 (file)
index 0000000..c4dce26
--- /dev/null
@@ -0,0 +1,132 @@
+/* Quad-precision floating point sine on <-pi/4,pi/4>.
+   Copyright (C) 1999,2004,2006 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Jakub Jelinek <jj@ultra.linux.cz>
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; 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"
+
+static const long double c[] = {
+#define ONE c[0]
+ 1.00000000000000000000000000000000000E+00L, /* 3fff0000000000000000000000000000 */
+
+/* cos x ~ ONE + x^2 ( SCOS1 + SCOS2 * x^2 + ... + SCOS4 * x^6 + SCOS5 * x^8 )
+   x in <0,1/256>  */
+#define SCOS1 c[1]
+#define SCOS2 c[2]
+#define SCOS3 c[3]
+#define SCOS4 c[4]
+#define SCOS5 c[5]
+-5.00000000000000000000000000000000000E-01L, /* bffe0000000000000000000000000000 */
+ 4.16666666666666666666666666556146073E-02L, /* 3ffa5555555555555555555555395023 */
+-1.38888888888888888888309442601939728E-03L, /* bff56c16c16c16c16c16a566e42c0375 */
+ 2.48015873015862382987049502531095061E-05L, /* 3fefa01a01a019ee02dcf7da2d6d5444 */
+-2.75573112601362126593516899592158083E-07L, /* bfe927e4f5dce637cb0b54908754bde0 */
+
+/* sin x ~ ONE * x + x^3 ( SIN1 + SIN2 * x^2 + ... + SIN7 * x^12 + SIN8 * x^14 )
+   x in <0,0.1484375>  */
+#define SIN1 c[6]
+#define SIN2 c[7]
+#define SIN3 c[8]
+#define SIN4 c[9]
+#define SIN5 c[10]
+#define SIN6 c[11]
+#define SIN7 c[12]
+#define SIN8 c[13]
+-1.66666666666666666666666666666666538e-01L, /* bffc5555555555555555555555555550 */
+ 8.33333333333333333333333333307532934e-03L, /* 3ff811111111111111111111110e7340 */
+-1.98412698412698412698412534478712057e-04L, /* bff2a01a01a01a01a01a019e7a626296 */
+ 2.75573192239858906520896496653095890e-06L, /* 3fec71de3a556c7338fa38527474b8f5 */
+-2.50521083854417116999224301266655662e-08L, /* bfe5ae64567f544e16c7de65c2ea551f */
+ 1.60590438367608957516841576404938118e-10L, /* 3fde6124613a811480538a9a41957115 */
+-7.64716343504264506714019494041582610e-13L, /* bfd6ae7f3d5aef30c7bc660b060ef365 */
+ 2.81068754939739570236322404393398135e-15L, /* 3fce9510115aabf87aceb2022a9a9180 */
+
+/* sin x ~ ONE * x + x^3 ( SSIN1 + SSIN2 * x^2 + ... + SSIN4 * x^6 + SSIN5 * x^8 )
+   x in <0,1/256>  */
+#define SSIN1 c[14]
+#define SSIN2 c[15]
+#define SSIN3 c[16]
+#define SSIN4 c[17]
+#define SSIN5 c[18]
+-1.66666666666666666666666666666666659E-01L, /* bffc5555555555555555555555555555 */
+ 8.33333333333333333333333333146298442E-03L, /* 3ff81111111111111111111110fe195d */
+-1.98412698412698412697726277416810661E-04L, /* bff2a01a01a01a01a019e7121e080d88 */
+ 2.75573192239848624174178393552189149E-06L, /* 3fec71de3a556c640c6aaa51aa02ab41 */
+-2.50521016467996193495359189395805639E-08L, /* bfe5ae644ee90c47dc71839de75b2787 */
+};
+
+#define SINCOSL_COS_HI 0
+#define SINCOSL_COS_LO 1
+#define SINCOSL_SIN_HI 2
+#define SINCOSL_SIN_LO 3
+extern const long double __sincosl_table[];
+
+long double
+__kernel_sinl(long double x, long double y, int iy)
+{
+  long double h, l, z, sin_l, cos_l_m1;
+  int64_t ix;
+  u_int32_t tix, hix, index;
+  GET_LDOUBLE_MSW64 (ix, x);
+  tix = ((u_int64_t)ix) >> 32;
+  tix &= ~0x80000000;                  /* tix = |x|'s high 32 bits */
+  if (tix < 0x3fc30000)                        /* |x| < 0.1484375 */
+    {
+      /* Argument is small enough to approximate it by a Chebyshev
+        polynomial of degree 17.  */
+      if (tix < 0x3c600000)            /* |x| < 2^-57 */
+       if (!((int)x)) return x;        /* generate inexact */
+      z = x * x;
+      return x + (x * (z*(SIN1+z*(SIN2+z*(SIN3+z*(SIN4+
+                      z*(SIN5+z*(SIN6+z*(SIN7+z*SIN8)))))))));
+    }
+  else
+    {
+      /* So that we don't have to use too large polynomial,  we find
+        l and h such that x = l + h,  where fabsl(l) <= 1.0/256 with 83
+        possible values for h.  We look up cosl(h) and sinl(h) in
+        pre-computed tables,  compute cosl(l) and sinl(l) using a
+        Chebyshev polynomial of degree 10(11) and compute
+        sinl(h+l) = sinl(h)cosl(l) + cosl(h)sinl(l).  */
+      index = 0x3fe - (tix >> 20);
+      hix = (tix + (0x2000 << index)) & (0xffffc000 << index);
+      x = fabsl (x);
+      switch (index)
+       {
+       case 0: index = ((45 << 14) + hix - 0x3fe00000) >> 12; break;
+       case 1: index = ((13 << 15) + hix - 0x3fd00000) >> 13; break;
+       default:
+       case 2: index = (hix - 0x3fc30000) >> 14; break;
+       }
+
+      SET_LDOUBLE_WORDS64(h, ((u_int64_t)hix) << 32, 0);
+      if (iy)
+       l = y - (h - x);
+      else
+       l = x - h;
+      z = l * l;
+      sin_l = l*(ONE+z*(SSIN1+z*(SSIN2+z*(SSIN3+z*(SSIN4+z*SSIN5)))));
+      cos_l_m1 = z*(SCOS1+z*(SCOS2+z*(SCOS3+z*(SCOS4+z*SCOS5))));
+      z = __sincosl_table [index + SINCOSL_SIN_HI]
+         + (__sincosl_table [index + SINCOSL_SIN_LO]
+            + (__sincosl_table [index + SINCOSL_SIN_HI] * cos_l_m1)
+            + (__sincosl_table [index + SINCOSL_COS_HI] * sin_l));
+      return (ix < 0) ? -z : z;
+    }
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/k_tanl.c b/sysdeps/ieee754/ldbl-128ibm/k_tanl.c
new file mode 100644 (file)
index 0000000..6c45b2f
--- /dev/null
@@ -0,0 +1,164 @@
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+/*
+  Long double expansions are
+  Copyright (C) 2001 Stephen L. Moshier <moshier@na-net.ornl.gov>
+  and are incorporated herein by permission of the author.  The author
+  reserves the right to distribute this material elsewhere under different
+  copying permissions.  These modifications are distributed here under
+  the following terms:
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA */
+
+/* __kernel_tanl( x, y, k )
+ * kernel tan function on [-pi/4, pi/4], pi/4 ~ 0.7854
+ * Input x is assumed to be bounded by ~pi/4 in magnitude.
+ * Input y is the tail of x.
+ * Input k indicates whether tan (if k=1) or
+ * -1/tan (if k= -1) is returned.
+ *
+ * Algorithm
+ *     1. Since tan(-x) = -tan(x), we need only to consider positive x.
+ *     2. if x < 2^-57, return x with inexact if x!=0.
+ *     3. tan(x) is approximated by a rational form x + x^3 / 3 + x^5 R(x^2)
+ *          on [0,0.67433].
+ *
+ *        Note: tan(x+y) = tan(x) + tan'(x)*y
+ *                       ~ tan(x) + (1+x*x)*y
+ *        Therefore, for better accuracy in computing tan(x+y), let
+ *             r = x^3 * R(x^2)
+ *        then
+ *             tan(x+y) = x + (x^3 / 3 + (x^2 *(r+y)+y))
+ *
+ *      4. For x in [0.67433,pi/4],  let y = pi/4 - x, then
+ *             tan(x) = tan(pi/4-y) = (1-tan(y))/(1+tan(y))
+ *                    = 1 - 2*(tan(y) - (tan(y)^2)/(1+tan(y)))
+ */
+
+#include "math.h"
+#include "math_private.h"
+#ifdef __STDC__
+static const long double
+#else
+static long double
+#endif
+  one = 1.0L,
+  pio4hi = 7.8539816339744830961566084581987569936977E-1L,
+  pio4lo = 2.1679525325309452561992610065108379921906E-35L,
+
+  /* tan x = x + x^3 / 3 + x^5 T(x^2)/U(x^2)
+     0 <= x <= 0.6743316650390625
+     Peak relative error 8.0e-36  */
+ TH =  3.333333333333333333333333333333333333333E-1L,
+ T0 = -1.813014711743583437742363284336855889393E7L,
+ T1 =  1.320767960008972224312740075083259247618E6L,
+ T2 = -2.626775478255838182468651821863299023956E4L,
+ T3 =  1.764573356488504935415411383687150199315E2L,
+ T4 = -3.333267763822178690794678978979803526092E-1L,
+
+ U0 = -1.359761033807687578306772463253710042010E8L,
+ U1 =  6.494370630656893175666729313065113194784E7L,
+ U2 = -4.180787672237927475505536849168729386782E6L,
+ U3 =  8.031643765106170040139966622980914621521E4L,
+ U4 = -5.323131271912475695157127875560667378597E2L;
+  /* 1.000000000000000000000000000000000000000E0 */
+
+
+#ifdef __STDC__
+long double
+__kernel_tanl (long double x, long double y, int iy)
+#else
+long double
+__kernel_tanl (x, y, iy)
+     long double x, y;
+     int iy;
+#endif
+{
+  long double z, r, v, w, s;
+  int32_t ix, sign;
+  ieee854_long_double_shape_type u, u1;
+
+  u.value = x;
+  ix = u.parts32.w0 & 0x7fffffff;
+  if (ix < 0x3c600000)         /* x < 2**-57 */
+    {
+      if ((int) x == 0)
+       {                       /* generate inexact */
+         if ((ix | u.parts32.w1 | (u.parts32.w2 & 0x7fffffff) | u.parts32.w3
+              | (iy + 1)) == 0)
+           return one / fabs (x);
+         else
+           return (iy == 1) ? x : -one / x;
+       }
+    }
+  if (ix >= 0x3fe59420) /* |x| >= 0.6743316650390625 */
+    {
+      if ((u.parts32.w0 & 0x80000000) != 0)
+       {
+         x = -x;
+         y = -y;
+         sign = -1;
+       }
+      else
+       sign = 1;
+      z = pio4hi - x;
+      w = pio4lo - y;
+      x = z + w;
+      y = 0.0;
+    }
+  z = x * x;
+  r = T0 + z * (T1 + z * (T2 + z * (T3 + z * T4)));
+  v = U0 + z * (U1 + z * (U2 + z * (U3 + z * (U4 + z))));
+  r = r / v;
+
+  s = z * x;
+  r = y + z * (s * r + y);
+  r += TH * s;
+  w = x + r;
+  if (ix >= 0x3fe59420)
+    {
+      v = (long double) iy;
+      w = (v - 2.0 * (x - (w * w / (w + v) - r)));
+      if (sign < 0)
+       w = -w;
+      return w;
+    }
+  if (iy == 1)
+    return w;
+  else
+    {                          /* if allow error up to 2 ulp,
+                                  simply return -1.0/(x+r) here */
+      /*  compute -1.0/(x+r) accurately */
+      u1.value = w;
+      u1.parts32.w2 = 0;
+      u1.parts32.w3 = 0;
+      v = r - (u1.value - x);          /* u1+v = r+x */
+      z = -1.0 / w;
+      u.value = z;
+      u.parts32.w2 = 0;
+      u.parts32.w3 = 0;
+      s = 1.0 + u.value * u1.value;
+      return u.value + z * (s + u.value * v);
+    }
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/ldbl2mpn.c b/sysdeps/ieee754/ldbl-128ibm/ldbl2mpn.c
new file mode 100644 (file)
index 0000000..18a2e67
--- /dev/null
@@ -0,0 +1,175 @@
+/* Copyright (C) 1995,1996,1997,1998,1999,2002,2003,2006
+       Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include "gmp.h"
+#include "gmp-impl.h"
+#include "longlong.h"
+#include <ieee754.h>
+#include <float.h>
+#include <math.h>
+#include <stdlib.h>
+
+/* Convert a `long double' in IBM extended format to a multi-precision
+   integer representing the significand scaled up by its number of
+   bits (106 for long double) and an integral power of two (MPN
+   frexpl). */
+
+mp_size_t
+__mpn_extract_long_double (mp_ptr res_ptr, mp_size_t size,
+                          int *expt, int *is_neg,
+                          long double value)
+{
+  union ibm_extended_long_double u;
+  unsigned long long hi, lo;
+  int ediff;
+  u.d = value;
+
+  *is_neg = u.ieee.negative;
+  *expt = (int) u.ieee.exponent - IBM_EXTENDED_LONG_DOUBLE_BIAS;
+
+  lo = ((long long) u.ieee.mantissa2 << 32) | u.ieee.mantissa3;
+  hi = ((long long) u.ieee.mantissa0 << 32) | u.ieee.mantissa1;
+  /* If the lower double is not a denomal or zero then set the hidden
+     53rd bit.  */
+  if (u.ieee.exponent2 > 0)
+    {
+      lo |= 1LL << 52;
+
+      /* The lower double is normalized separately from the upper.  We may
+        need to adjust the lower manitissa to reflect this.  */
+      ediff = u.ieee.exponent - u.ieee.exponent2;
+      if (ediff > 53)
+       lo = lo >> (ediff-53);
+    }
+  /* The high double may be rounded and the low double reflects the
+     difference between the long double and the rounded high double
+     value.  This is indicated by a differnce between the signs of the
+     high and low doubles.  */
+  if ((u.ieee.negative != u.ieee.negative2)
+      && ((u.ieee.exponent2 != 0) && (lo != 0L)))
+    {
+      lo = (1ULL << 53) - lo;
+      if (hi == 0LL)
+       {
+         /* we have a borrow from the hidden bit, so shift left 1.  */
+         hi = 0x0ffffffffffffeLL | (lo >> 51);
+         lo = 0x1fffffffffffffLL & (lo << 1);
+         (*expt)--;
+       }
+      else
+       hi--;
+    }
+#if BITS_PER_MP_LIMB == 32
+  /* Combine the mantissas to be contiguous.  */
+  res_ptr[0] = lo;
+  res_ptr[1] = (hi << (53 - 32)) | (lo >> 32);
+  res_ptr[2] = hi >> 11;
+  res_ptr[3] = hi >> (32 + 11);
+  #define N 4
+#elif BITS_PER_MP_LIMB == 64
+  /* Combine the two mantissas to be contiguous.  */
+  res_ptr[0] = (hi << 53) | lo;
+  res_ptr[1] = hi >> 11;
+  #define N 2
+#else
+  #error "mp_limb size " BITS_PER_MP_LIMB "not accounted for"
+#endif
+/* The format does not fill the last limb.  There are some zeros.  */
+#define NUM_LEADING_ZEROS (BITS_PER_MP_LIMB \
+                          - (LDBL_MANT_DIG - ((N - 1) * BITS_PER_MP_LIMB)))
+
+  if (u.ieee.exponent == 0)
+    {
+      /* A biased exponent of zero is a special case.
+        Either it is a zero or it is a denormal number.  */
+      if (res_ptr[0] == 0 && res_ptr[1] == 0
+         && res_ptr[N - 2] == 0 && res_ptr[N - 1] == 0) /* Assumes N<=4.  */
+       /* It's zero.  */
+       *expt = 0;
+      else
+       {
+         /* It is a denormal number, meaning it has no implicit leading
+            one bit, and its exponent is in fact the format minimum.  */
+         int cnt;
+
+#if N == 2
+         if (res_ptr[N - 1] != 0)
+           {
+             count_leading_zeros (cnt, res_ptr[N - 1]);
+             cnt -= NUM_LEADING_ZEROS;
+             res_ptr[N - 1] = res_ptr[N - 1] << cnt
+                              | (res_ptr[0] >> (BITS_PER_MP_LIMB - cnt));
+             res_ptr[0] <<= cnt;
+             *expt = LDBL_MIN_EXP - 1 - cnt;
+           }
+         else
+           {
+             count_leading_zeros (cnt, res_ptr[0]);
+             if (cnt >= NUM_LEADING_ZEROS)
+               {
+                 res_ptr[N - 1] = res_ptr[0] << (cnt - NUM_LEADING_ZEROS);
+                 res_ptr[0] = 0;
+               }
+             else
+               {
+                 res_ptr[N - 1] = res_ptr[0] >> (NUM_LEADING_ZEROS - cnt);
+                 res_ptr[0] <<= BITS_PER_MP_LIMB - (NUM_LEADING_ZEROS - cnt);
+               }
+             *expt = LDBL_MIN_EXP - 1
+               - (BITS_PER_MP_LIMB - NUM_LEADING_ZEROS) - cnt;
+           }
+#else
+         int j, k, l;
+
+         for (j = N - 1; j > 0; j--)
+           if (res_ptr[j] != 0)
+             break;
+
+         count_leading_zeros (cnt, res_ptr[j]);
+         cnt -= NUM_LEADING_ZEROS;
+         l = N - 1 - j;
+         if (cnt < 0)
+           {
+             cnt += BITS_PER_MP_LIMB;
+             l--;
+           }
+         if (!cnt)
+           for (k = N - 1; k >= l; k--)
+             res_ptr[k] = res_ptr[k-l];
+         else
+           {
+             for (k = N - 1; k > l; k--)
+               res_ptr[k] = res_ptr[k-l] << cnt
+                            | res_ptr[k-l-1] >> (BITS_PER_MP_LIMB - cnt);
+             res_ptr[k--] = res_ptr[0] << cnt;
+           }
+
+         for (; k >= 0; k--)
+           res_ptr[k] = 0;
+         *expt = LDBL_MIN_EXP - 1 - l * BITS_PER_MP_LIMB - cnt;
+#endif
+       }
+    }
+  else
+    /* Add the implicit leading one bit for a normalized number.  */
+    res_ptr[N - 1] |= (mp_limb_t) 1 << (LDBL_MANT_DIG - 1
+                                       - ((N - 1) * BITS_PER_MP_LIMB));
+
+  return N;
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/math_ldbl.h b/sysdeps/ieee754/ldbl-128ibm/math_ldbl.h
new file mode 100644 (file)
index 0000000..e7e1b96
--- /dev/null
@@ -0,0 +1,124 @@
+#ifndef _MATH_PRIVATE_H_
+#error "Never use <math_ldbl.h> directly; include <math_private.h> instead."
+#endif
+
+#include <sysdeps/ieee754/ldbl-128/math_ldbl.h>
+
+#define EXTRACT_IBM_EXTENDED_MANTISSA(hi64, lo64, expnt, ibm_ext_ldbl) \
+  do                                                                         \
+    {                                                                        \
+      /* We have 105 bits of mantissa plus one implicit digit.  Since        \
+        106 bits are representable without the rest using hexadecimal        \
+        digits we use only the implicit digits for the number before         \
+        the decimal point.  */                                               \
+      unsigned long long hi, lo;                                             \
+      int ediff;                                                             \
+      union ibm_extended_long_double eldbl;                                  \
+      eldbl.d = ibm_ext_ldbl;                                                \
+      expnt = eldbl.ieee.exponent - IBM_EXTENDED_LONG_DOUBLE_BIAS;           \
+                                                                             \
+      lo = ((long long)eldbl.ieee.mantissa2 << 32) | eldbl.ieee.mantissa3;    \
+      hi = ((long long)eldbl.ieee.mantissa0 << 32) | eldbl.ieee.mantissa1;    \
+      /* If the lower double is not a denomal or zero then set the hidden     \
+        53rd bit.  */                                                        \
+      if (eldbl.ieee.exponent2 > 0x001)                                              \
+       {                                                                     \
+         lo |= (1ULL << 52);                                                 \
+         lo = lo << 7; /* pre-shift lo to match ieee854.  */                 \
+          /* The lower double is normalized separately from the upper.  We    \
+            may need to adjust the lower manitissa to reflect this.  */      \
+         ediff = eldbl.ieee.exponent - eldbl.ieee.exponent2;                 \
+         if (ediff > 53)                                                     \
+           lo = lo >> (ediff-53);                                            \
+       }                                                                     \
+      hi |= (1ULL << 52);                                                    \
+                                                                             \
+      if ((eldbl.ieee.negative != eldbl.ieee.negative2)                              \
+         && ((eldbl.ieee.exponent2 != 0) && (lo != 0LL)))                    \
+       {                                                                     \
+         hi--;                                                               \
+         lo = (1ULL << 60) - lo;                                             \
+         if (hi < (1ULL << 52))                                              \
+           {                                                                 \
+             /* we have a borrow from the hidden bit, so shift left 1.  */   \
+             hi = (hi << 1) | (lo >> 59);                                    \
+             lo = 0xfffffffffffffffLL & (lo << 1);                           \
+             expnt--;                                                        \
+           }                                                                 \
+       }                                                                     \
+      lo64 = (hi << 60) | lo;                                                \
+      hi64 = hi >> 4;                                                        \
+    }                                                                        \
+  while (0)
+
+#define INSERT_IBM_EXTENDED_MANTISSA(ibm_ext_ldbl, sign, expnt, hi64, lo64) \
+  do                                                                         \
+    {                                                                        \
+      union ibm_extended_long_double u;                                              \
+      unsigned long hidden2, lzcount;                                        \
+      unsigned long long hi, lo;                                             \
+                                                                             \
+      u.ieee.negative = sign;                                                \
+      u.ieee.negative2 = sign;                                               \
+      u.ieee.exponent = expnt + IBM_EXTENDED_LONG_DOUBLE_BIAS;               \
+      u.ieee.exponent2 = expnt-53 + IBM_EXTENDED_LONG_DOUBLE_BIAS;           \
+      /* Expect 113 bits (112 bits + hidden) right justified in two longs.    \
+        The low order 53 bits (52 + hidden) go into the lower double */      \
+      lo = (lo64 >> 7)& ((1ULL << 53) - 1);                                  \
+      hidden2 = (lo64 >> 59) &  1ULL;                                        \
+      /* The high order 53 bits (52 + hidden) go into the upper double */     \
+      hi = (lo64 >> 60) & ((1ULL << 11) - 1);                                \
+      hi |= (hi64 << 4);                                                     \
+                                                                             \
+      if (lo != 0LL)                                                         \
+       {                                                                     \
+         /* hidden2 bit of low double controls rounding of the high double.  \
+            If hidden2 is '1' then round up hi and adjust lo (2nd mantissa)  \
+            plus change the sign of the low double to compensate.  */        \
+         if (hidden2)                                                        \
+           {                                                                 \
+             hi++;                                                           \
+             u.ieee.negative2 = !sign;                                       \
+             lo = (1ULL << 53) - lo;                                         \
+           }                                                                 \
+         /* The hidden bit of the lo mantissa is zero so we need to          \
+            normalize the it for the low double.  Shift it left until the    \
+            hidden bit is '1' then adjust the 2nd exponent accordingly.  */  \
+                                                                             \
+         if (sizeof (lo) == sizeof (long))                                   \
+           lzcount = __builtin_clzl (lo);                                    \
+         else if ((lo >> 32) != 0)                                           \
+           lzcount = __builtin_clzl ((long) (lo >> 32));                     \
+         else                                                                \
+           lzcount = __builtin_clzl ((long) lo) + 32;                        \
+         lzcount = lzcount - 11;                                             \
+         if (lzcount > 0)                                                    \
+           {                                                                 \
+             int expnt2 = u.ieee.exponent2 - lzcount;                        \
+             if (expnt2 >= 1)                                                \
+               {                                                             \
+                 /* Not denormal.  Normalize and set low exponent.  */       \
+                 lo = lo << lzcount;                                         \
+                 u.ieee.exponent2 = expnt2;                                  \
+               }                                                             \
+             else                                                            \
+               {                                                             \
+                 /* Is denormal.  */                                         \
+                 lo = lo << (lzcount + expnt2);                              \
+                 u.ieee.exponent2 = 0;                                       \
+               }                                                             \
+           }                                                                 \
+       }                                                                     \
+      else                                                                   \
+       {                                                                     \
+         u.ieee.negative2 = 0;                                               \
+         u.ieee.exponent2 = 0;                                               \
+       }                                                                     \
+                                                                             \
+      u.ieee.mantissa3 = lo & ((1ULL << 32) - 1);                            \
+      u.ieee.mantissa2 = (lo >> 32) & ((1ULL << 20) - 1);                    \
+      u.ieee.mantissa1 = hi & ((1ULL << 32) - 1);                            \
+      u.ieee.mantissa0 = (hi >> 32) & ((1ULL << 20) - 1);                    \
+      ibm_ext_ldbl = u.d;                                                    \
+    }                                                                        \
+  while (0)
diff --git a/sysdeps/ieee754/ldbl-128ibm/mpn2ldbl.c b/sysdeps/ieee754/ldbl-128ibm/mpn2ldbl.c
new file mode 100644 (file)
index 0000000..8a2d45e
--- /dev/null
@@ -0,0 +1,103 @@
+/* Copyright (C) 1995, 1996, 1997, 1998, 1999, 2002, 2003, 2004, 2006
+       Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include "gmp.h"
+#include "gmp-impl.h"
+#include <ieee754.h>
+#include <float.h>
+#include <math.h>
+
+/* Convert a multi-precision integer of the needed number of bits (106
+   for long double) and an integral power of two to a `long double' in
+   IBM extended format.  */
+
+long double
+__mpn_construct_long_double (mp_srcptr frac_ptr, int expt, int sign)
+{
+  union ibm_extended_long_double u;
+  unsigned long hidden2, lzcount;
+  unsigned long long hi, lo;
+
+  u.ieee.negative = sign;
+  u.ieee.negative2 = sign;
+  u.ieee.exponent = expt + IBM_EXTENDED_LONG_DOUBLE_BIAS;
+  u.ieee.exponent2 = expt - 53 + IBM_EXTENDED_LONG_DOUBLE_BIAS;
+
+#if BITS_PER_MP_LIMB == 32
+  /* The low order 53 bits (52 + hidden) go into the lower double */
+  lo = frac_ptr[0];
+  lo |= (frac_ptr[1] & ((1LL << (53 - 32)) - 1)) << 32;
+  hidden2 = (frac_ptr[1] >> (52 - 32)) & ((mp_limb_t) 1);
+  /* The high order 53 bits (52 + hidden) go into the upper double */
+  hi = (frac_ptr[1] >> (53 - 32)) & ((1 << 11) - 1);
+  hi |= ((unsigned long long) frac_ptr[2]) << 11;
+  hi |= ((unsigned long long) frac_ptr[3]) << (32 + 11);
+#elif BITS_PER_MP_LIMB == 64
+  /* The low order 53 bits (52 + hidden) go into the lower double */
+  lo = frac_ptr[0] & (((mp_limb_t) 1 << 53) - 1);
+  hidden2 = (frac_ptr[0] >> 52) & ((mp_limb_t) 1);
+  /* The high order 53 bits (52 + hidden) go into the upper double */
+  hi = (frac_ptr[0] >> 53) & (((mp_limb_t) 1 << 11) - 1);
+  hi |= (frac_ptr[1] << 11);
+#else
+  #error "mp_limb size " BITS_PER_MP_LIMB "not accounted for"
+#endif
+
+  if (lo != 0L)
+    {
+      /* hidden2 bit of low double controls rounding of the high double.
+        If hidden2 is '1' then round up hi and adjust lo (2nd mantissa)
+        plus change the sign of the low double to compensate.  */
+      if (hidden2)
+       {
+         hi++;
+         u.ieee.negative2 = !sign;
+         lo = (1LL << 53) - lo;
+       }
+
+      /* The hidden bit of the lo mantissa is zero so we need to normalize
+        it for the low double.  Shift it left until the hidden bit is '1'
+        then adjust the 2nd exponent accordingly.  */
+
+      if (sizeof (lo) == sizeof (long))
+       lzcount = __builtin_clzl (lo);
+      else if ((lo >> 32) != 0)
+       lzcount = __builtin_clzl ((long) (lo >> 32));
+      else
+       lzcount = __builtin_clzl ((long) lo) + 32;
+      lzcount = lzcount - 11;
+      if (lzcount > 0)
+       {
+         lo = lo << lzcount;
+         u.ieee.exponent2 = u.ieee.exponent2 - lzcount;
+       }
+    }
+  else
+    {
+      u.ieee.negative2 = 0;
+      u.ieee.exponent2 = 0;
+    }
+
+  u.ieee.mantissa3 = lo & 0xffffffffLL;
+  u.ieee.mantissa2 = (lo >> 32) & 0xffffff;
+  u.ieee.mantissa1 = hi & 0xffffffffLL;
+  u.ieee.mantissa0 = (hi >> 32) & ((1LL << (LDBL_MANT_DIG - 86)) - 1);
+
+  return u.d;
+}
diff --git a/sysdeps/ieee754/ldbl-128ibm/printf_fphex.c b/sysdeps/ieee754/ldbl-128ibm/printf_fphex.c
new file mode 100644 (file)
index 0000000..2a7b70f
--- /dev/null
@@ -0,0 +1,138 @@
+/* Print floating point number in hexadecimal notation according to ISO C99.
+   Copyright (C) 1997,1998,1999,2000,2001,2002,2004,2006
+       Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#define PRINT_FPHEX_LONG_DOUBLE \
+do {                                                                         \
+      /* We have 105 bits of mantissa plus one implicit digit.  Since        \
+        106 bits are representable without rest using hexadecimal            \
+        digits we use only the implicit digits for the number before         \
+        the decimal point.  */                                               \
+      unsigned long long int num0, num1;                                     \
+      unsigned long long hi, lo;                                             \
+      int ediff;                                                             \
+      union ibm_extended_long_double eldbl;                                  \
+      eldbl.d = fpnum.ldbl.d;                                                \
+                                                                             \
+      assert (sizeof (long double) == 16);                                   \
+                                                                             \
+      lo = ((long long)eldbl.ieee.mantissa2 << 32) | eldbl.ieee.mantissa3;    \
+      hi = ((long long)eldbl.ieee.mantissa0 << 32) | eldbl.ieee.mantissa1;    \
+   /* If the lower double is not a denomal or zero then set the hidden       \
+      53rd bit.  */                                                          \
+      if (eldbl.ieee.exponent2 > 0x001)                                              \
+       {                                                                     \
+         lo |= (1ULL << 52);                                                 \
+         lo = lo << 7; /* pre-shift lo to match ieee854.  */                 \
+         /* The lower double is normalized separately from the upper.  We    \
+            may need to adjust the lower manitissa to reflect this.  */      \
+         ediff = eldbl.ieee.exponent - eldbl.ieee.exponent2;                 \
+         if (ediff > 53)                                                     \
+           lo = lo >> (ediff-53);                                            \
+       }                                                                     \
+                                                                             \
+      if ((eldbl.ieee.negative != eldbl.ieee.negative2)                              \
+         && ((eldbl.ieee.exponent2 != 0) && (lo != 0L)))                     \
+       {                                                                     \
+         lo = (1ULL << 60) - lo;                                             \
+         if (hi == 0L)                                                       \
+           {                                                                 \
+             /* we have a borrow from the hidden bit, so shift left 1.  */   \
+             hi = 0xffffffffffffeLL | (lo >> 59);                            \
+             lo = 0xfffffffffffffffLL & (lo << 1);                           \
+             eldbl.ieee.exponent--;                                          \
+           }                                                                 \
+         else                                                                \
+           hi--;                                                             \
+        }                                                                    \
+      num1 = (hi << 60) | lo;                                                \
+      num0 = hi >> 4;                                                        \
+                                                                             \
+      zero_mantissa = (num0|num1) == 0;                                              \
+                                                                             \
+      if (sizeof (unsigned long int) > 6)                                    \
+       {                                                                     \
+         numstr = _itoa_word (num1, numbuf + sizeof numbuf, 16,              \
+                              info->spec == 'A');                            \
+         wnumstr = _itowa_word (num1,                                        \
+                                wnumbuf + sizeof (wnumbuf) / sizeof (wchar_t),\
+                                16, info->spec == 'A');                      \
+       }                                                                     \
+      else                                                                   \
+       {                                                                     \
+         numstr = _itoa (num1, numbuf + sizeof numbuf, 16,                   \
+                         info->spec == 'A');                                 \
+         wnumstr = _itowa (num1,                                             \
+                           wnumbuf + sizeof (wnumbuf) / sizeof (wchar_t),    \
+                           16, info->spec == 'A');                           \
+       }                                                                     \
+                                                                             \
+      while (numstr > numbuf + (sizeof numbuf - 64 / 4))                     \
+       {                                                                     \
+         *--numstr = '0';                                                    \
+         *--wnumstr = L'0';                                                  \
+       }                                                                     \
+                                                                             \
+      if (sizeof (unsigned long int) > 6)                                    \
+       {                                                                     \
+         numstr = _itoa_word (num0, numstr, 16, info->spec == 'A');          \
+         wnumstr = _itowa_word (num0, wnumstr, 16, info->spec == 'A');       \
+       }                                                                     \
+      else                                                                   \
+       {                                                                     \
+         numstr = _itoa (num0, numstr, 16, info->spec == 'A');               \
+         wnumstr = _itowa (num0, wnumstr, 16, info->spec == 'A');            \
+       }                                                                     \
+                                                                             \
+      /* Fill with zeroes.  */                                               \
+      while (numstr > numbuf + (sizeof numbuf - 112 / 4))                    \
+       {                                                                     \
+         *--numstr = '0';                                                    \
+         *--wnumstr = L'0';                                                  \
+       }                                                                     \
+                                                                             \
+      leading = eldbl.ieee.exponent == 0 ? '0' : '1';                        \
+                                                                             \
+      exponent = eldbl.ieee.exponent;                                        \
+                                                                             \
+      if (exponent == 0)                                                     \
+       {                                                                     \
+         if (zero_mantissa)                                                  \
+           expnegative = 0;                                                  \
+         else                                                                \
+           {                                                                 \
+             /* This is a denormalized number.  */                           \
+             expnegative = 1;                                                \
+             exponent = IBM_EXTENDED_LONG_DOUBLE_BIAS - 1;                   \
+           }                                                                 \
+       }                                                                     \
+      else if (exponent >= IBM_EXTENDED_LONG_DOUBLE_BIAS)                    \
+       {                                                                     \
+         expnegative = 0;                                                    \
+         exponent -= IBM_EXTENDED_LONG_DOUBLE_BIAS;                          \
+       }                                                                     \
+      else                                                                   \
+       {                                                                     \
+         expnegative = 1;                                                    \
+         exponent = -(exponent - IBM_EXTENDED_LONG_DOUBLE_BIAS);             \
+       }                                                                     \
+} while (0)
+
+#include <stdio-common/printf_fphex.c>
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_asinhl.c b/sysdeps/ieee754/ldbl-128ibm/s_asinhl.c
new file mode 100644 (file)
index 0000000..d1b63bb
--- /dev/null
@@ -0,0 +1,67 @@
+/* @(#)s_asinh.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.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: s_asinh.c,v 1.9 1995/05/12 04:57:37 jtc Exp $";
+#endif
+
+/* asinh(x)
+ * Method :
+ *     Based on
+ *             asinh(x) = sign(x) * log [ |x| + sqrt(x*x+1) ]
+ *     we have
+ *     asinh(x) := x  if  1+x*x=1,
+ *              := sign(x)*(log(x)+ln2)) for large |x|, else
+ *              := sign(x)*log(2|x|+1/(|x|+sqrt(x*x+1))) if|x|>2, else
+ *              := sign(x)*log1p(|x| + x^2/(1 + sqrt(1+x^2)))
+ */
+
+#include "math.h"
+#include "math_private.h"
+#include <math_ldbl_opt.h>
+
+#ifdef __STDC__
+static const long double
+#else
+static long double
+#endif
+one =  1.00000000000000000000e+00L, /* 0x3ff0000000000000, 0 */
+ln2 =  0.6931471805599453094172321214581766L, /* 0x3fe62e42fefa39ef, 0x3c7abc9e3b398040 */
+huge=  1.00000000000000000000e+300L;
+
+#ifdef __STDC__
+       long double __asinhl(long double x)
+#else
+       long double __asinhl(x)
+       long double x;
+#endif
+{
+       long double t,w;
+       int64_t hx,ix;
+       GET_LDOUBLE_MSW64(hx,x);
+       ix = hx&0x7fffffffffffffffLL;
+       if(ix>=0x7ff0000000000000LL) return x+x;        /* x is inf or NaN */
+       if(ix< 0x3e20000000000000LL) {  /* |x|<2**-29 */
+           if(huge+x>one) return x;    /* return x inexact except 0 */
+       }
+       if(ix>0x41b0000000000000LL) {   /* |x| > 2**28 */
+           w = __ieee754_logl(fabs(x))+ln2;
+       } else if (ix>0x4000000000000000LL) {   /* 2**28 > |x| > 2.0 */
+           t = fabs(x);
+           w = __ieee754_logl(2.0*t+one/(__ieee754_sqrtl(x*x+one)+t));
+       } else {                /* 2.0 > |x| > 2**-29 */
+           t = x*x;
+           w =__log1pl(fabsl(x)+t/(one+__ieee754_sqrtl(one+t)));
+       }
+       if(hx>0) return w; else return -w;
+}
+long_double_symbol (libm, __asinhl, asinhl);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_atanl.c b/sysdeps/ieee754/ldbl-128ibm/s_atanl.c
new file mode 100644 (file)
index 0000000..b6195f1
--- /dev/null
@@ -0,0 +1,234 @@
+/*                                                     s_atanl.c
+ *
+ *     Inverse circular tangent for 128-bit long double precision
+ *      (arctangent)
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * long double x, y, atanl();
+ *
+ * y = atanl( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns radian angle between -pi/2 and +pi/2 whose tangent is x.
+ *
+ * The function uses a rational approximation of the form
+ * t + t^3 P(t^2)/Q(t^2), optimized for |t| < 0.09375.
+ *
+ * The argument is reduced using the identity
+ *    arctan x - arctan u  =  arctan ((x-u)/(1 + ux))
+ * and an 83-entry lookup table for arctan u, with u = 0, 1/8, ..., 10.25.
+ * Use of the table improves the execution speed of the routine.
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      -19, 19       4e5       1.7e-34     5.4e-35
+ *
+ *
+ * WARNING:
+ *
+ * This program uses integer operations on bit fields of floating-point
+ * numbers.  It does not work with data structures other than the
+ * structure assumed.
+ *
+ */
+
+/* Copyright 2001 by Stephen L. Moshier <moshier@na-net.ornl.gov>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA */
+
+
+#include "math_private.h"
+#include <math_ldbl_opt.h>
+
+/* arctan(k/8), k = 0, ..., 82 */
+static const long double atantbl[84] = {
+  0.0000000000000000000000000000000000000000E0L,
+  1.2435499454676143503135484916387102557317E-1L, /* arctan(0.125)  */
+  2.4497866312686415417208248121127581091414E-1L,
+  3.5877067027057222039592006392646049977698E-1L,
+  4.6364760900080611621425623146121440202854E-1L,
+  5.5859931534356243597150821640166127034645E-1L,
+  6.4350110879328438680280922871732263804151E-1L,
+  7.1882999962162450541701415152590465395142E-1L,
+  7.8539816339744830961566084581987572104929E-1L,
+  8.4415398611317100251784414827164750652594E-1L,
+  8.9605538457134395617480071802993782702458E-1L,
+  9.4200004037946366473793717053459358607166E-1L,
+  9.8279372324732906798571061101466601449688E-1L,
+  1.0191413442663497346383429170230636487744E0L,
+  1.0516502125483736674598673120862998296302E0L,
+  1.0808390005411683108871567292171998202703E0L,
+  1.1071487177940905030170654601785370400700E0L,
+  1.1309537439791604464709335155363278047493E0L,
+  1.1525719972156675180401498626127513797495E0L,
+  1.1722738811284763866005949441337046149712E0L,
+  1.1902899496825317329277337748293183376012E0L,
+  1.2068173702852525303955115800565576303133E0L,
+  1.2220253232109896370417417439225704908830E0L,
+  1.2360594894780819419094519711090786987027E0L,
+  1.2490457723982544258299170772810901230778E0L,
+  1.2610933822524404193139408812473357720101E0L,
+  1.2722973952087173412961937498224804940684E0L,
+  1.2827408797442707473628852511364955306249E0L,
+  1.2924966677897852679030914214070816845853E0L,
+  1.3016288340091961438047858503666855921414E0L,
+  1.3101939350475556342564376891719053122733E0L,
+  1.3182420510168370498593302023271362531155E0L,
+  1.3258176636680324650592392104284756311844E0L,
+  1.3329603993374458675538498697331558093700E0L,
+  1.3397056595989995393283037525895557411039E0L,
+  1.3460851583802539310489409282517796256512E0L,
+  1.3521273809209546571891479413898128509842E0L,
+  1.3578579772154994751124898859640585287459E0L,
+  1.3633001003596939542892985278250991189943E0L,
+  1.3684746984165928776366381936948529556191E0L,
+  1.3734007669450158608612719264449611486510E0L,
+  1.3780955681325110444536609641291551522494E0L,
+  1.3825748214901258580599674177685685125566E0L,
+  1.3868528702577214543289381097042486034883E0L,
+  1.3909428270024183486427686943836432060856E0L,
+  1.3948567013423687823948122092044222644895E0L,
+  1.3986055122719575950126700816114282335732E0L,
+  1.4021993871854670105330304794336492676944E0L,
+  1.4056476493802697809521934019958079881002E0L,
+  1.4089588955564736949699075250792569287156E0L,
+  1.4121410646084952153676136718584891599630E0L,
+  1.4152014988178669079462550975833894394929E0L,
+  1.4181469983996314594038603039700989523716E0L,
+  1.4209838702219992566633046424614466661176E0L,
+  1.4237179714064941189018190466107297503086E0L,
+  1.4263547484202526397918060597281265695725E0L,
+  1.4288992721907326964184700745371983590908E0L,
+  1.4313562697035588982240194668401779312122E0L,
+  1.4337301524847089866404719096698873648610E0L,
+  1.4360250423171655234964275337155008780675E0L,
+  1.4382447944982225979614042479354815855386E0L,
+  1.4403930189057632173997301031392126865694E0L,
+  1.4424730991091018200252920599377292525125E0L,
+  1.4444882097316563655148453598508037025938E0L,
+  1.4464413322481351841999668424758804165254E0L,
+  1.4483352693775551917970437843145232637695E0L,
+  1.4501726582147939000905940595923466567576E0L,
+  1.4519559822271314199339700039142990228105E0L,
+  1.4536875822280323362423034480994649820285E0L,
+  1.4553696664279718992423082296859928222270E0L,
+  1.4570043196511885530074841089245667532358E0L,
+  1.4585935117976422128825857356750737658039E0L,
+  1.4601391056210009726721818194296893361233E0L,
+  1.4616428638860188872060496086383008594310E0L,
+  1.4631064559620759326975975316301202111560E0L,
+  1.4645314639038178118428450961503371619177E0L,
+  1.4659193880646627234129855241049975398470E0L,
+  1.4672716522843522691530527207287398276197E0L,
+  1.4685896086876430842559640450619880951144E0L,
+  1.4698745421276027686510391411132998919794E0L,
+  1.4711276743037345918528755717617308518553E0L,
+  1.4723501675822635384916444186631899205983E0L,
+  1.4735431285433308455179928682541563973416E0L, /* arctan(10.25) */
+  1.5707963267948966192313216916397514420986E0L  /* pi/2 */
+};
+
+
+/* arctan t = t + t^3 p(t^2) / q(t^2)
+   |t| <= 0.09375
+   peak relative error 5.3e-37 */
+
+static const long double
+  p0 = -4.283708356338736809269381409828726405572E1L,
+  p1 = -8.636132499244548540964557273544599863825E1L,
+  p2 = -5.713554848244551350855604111031839613216E1L,
+  p3 = -1.371405711877433266573835355036413750118E1L,
+  p4 = -8.638214309119210906997318946650189640184E-1L,
+  q0 = 1.285112506901621042780814422948906537959E2L,
+  q1 = 3.361907253914337187957855834229672347089E2L,
+  q2 = 3.180448303864130128268191635189365331680E2L,
+  q3 = 1.307244136980865800160844625025280344686E2L,
+  q4 = 2.173623741810414221251136181221172551416E1L;
+  /* q5 = 1.000000000000000000000000000000000000000E0 */
+
+
+long double
+__atanl (long double x)
+{
+  int k, sign;
+  long double t, u, p, q;
+  ieee854_long_double_shape_type s;
+
+  s.value = x;
+  k = s.parts32.w0;
+  if (k & 0x80000000)
+    sign = 1;
+  else
+    sign = 0;
+
+  /* Check for IEEE special cases.  */
+  k &= 0x7fffffff;
+  if (k >= 0x7ff00000)
+    {
+      /* NaN. */
+      if ((k & 0xfffff) | s.parts32.w1 )
+       return (x + x);
+
+      /* Infinity. */
+      if (sign)
+       return -atantbl[83];
+      else
+       return atantbl[83];
+    }
+
+  if (sign)
+      x = -x;
+
+  if (k >= 0x40248000) /* 10.25 */
+    {
+      k = 83;
+      t = -1.0/x;
+    }
+  else
+    {
+      /* Index of nearest table element.
+        Roundoff to integer is asymmetrical to avoid cancellation when t < 0
+         (cf. fdlibm). */
+      k = 8.0 * x + 0.25;
+      u = 0.125 * k;
+      /* Small arctan argument.  */
+      t = (x - u) / (1.0 + x * u);
+    }
+
+  /* Arctan of small argument t.  */
+  u = t * t;
+  p =     ((((p4 * u) + p3) * u + p2) * u + p1) * u + p0;
+  q = ((((u + q4) * u + q3) * u + q2) * u + q1) * u + q0;
+  u = t * u * p / q  +  t;
+
+  /* arctan x = arctan u  +  arctan t */
+  u = atantbl[k] + u;
+  if (sign)
+    return (-u);
+  else
+    return u;
+}
+
+long_double_symbol (libm, __atanl, atanl);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_cbrtl.c b/sysdeps/ieee754/ldbl-128ibm/s_cbrtl.c
new file mode 100644 (file)
index 0000000..010a671
--- /dev/null
@@ -0,0 +1,6 @@
+/* Looks like we can use ieee854 s_cbrtl.c as is for IBM extended format. */
+#include <math_ldbl_opt.h>
+#undef weak_alias
+#define weak_alias(n,a)
+#include <sysdeps/ieee754/ldbl-128/s_cbrtl.c>
+long_double_symbol (libm, __cbrtl, cbrtl);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_ceill.c b/sysdeps/ieee754/ldbl-128ibm/s_ceill.c
new file mode 100644 (file)
index 0000000..a4cbbe1
--- /dev/null
@@ -0,0 +1,119 @@
+/* Ceil (round to +inf) long double floating-point values.
+   IBM extended format long double version.
+   Copyright (C) 2006 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+/* This has been coded in assembler because GCC makes such a mess of it
+   when it's coded in C.  */
+
+#include <math.h>
+#include <fenv.h>
+#include <math_ldbl_opt.h>
+#include <float.h>
+#include <ieee754.h>
+
+
+#ifdef __STDC__
+long double
+__ceill (long double x)
+#else
+long double
+__ceill (x)
+     long double x;
+#endif
+{
+  static const double TWO52 = 4503599627370496.0L;
+  int mode = fegetround();
+  union ibm_extended_long_double u;
+
+  u.d = x;
+
+  if (fabs (u.dd[0]) < TWO52)
+    {      
+      fesetround(FE_UPWARD);
+      if (u.dd[0] > 0.0)
+       {
+         u.dd[0] += TWO52;
+         u.dd[0] -= TWO52;
+       }
+      else if (u.dd[0] < 0.0)
+       {
+         u.dd[0] -= TWO52;
+         u.dd[0] += TWO52;
+       }
+      u.dd[1] = 0.0;      
+      fesetround(mode);
+    }
+  else if (fabs (u.dd[1]) < TWO52 && u.dd[1] != 0.0)
+    {
+      double high, low;
+      /* In this case we have to round the low double and handle any
+         adjustment to the high double that may be caused by rounding
+         (up).  This is complicated by the fact that the high double
+         may already be rounded and the low double may have the
+         opposite sign to compensate.  */
+      if (u.dd[0] > 0.0)
+       {
+         if (u.dd[1] > 0.0)
+           {
+             /* If the high/low doubles are the same sign then simply
+                round the low double.  */
+             high = u.dd[0];
+             low = u.dd[1];
+           }
+         else if (u.dd[1] < 0.0)
+           {
+             /* Else the high double is pre rounded and we need to
+                adjust for that.  */
+             high = nextafter (u.dd[0], 0.0);
+             low = u.dd[1] + (u.dd[0] - high);
+           }      
+          fesetround(FE_UPWARD);
+         low += TWO52;
+         low -= TWO52;     
+          fesetround(mode);
+       }
+      else if (u.dd[0] < 0.0)
+       {
+         if (u.dd[1] < 0.0)
+           {
+             /* If the high/low doubles are the same sign then simply
+                round the low double.  */
+             high = u.dd[0];
+             low = u.dd[1];
+           }
+         else if (u.dd[1] > 0.0)
+           {
+             /* Else the high double is pre rounded and we need to
+                adjust for that.  */
+             high = nextafter (u.dd[0], 0.0);
+             low = u.dd[1] + (u.dd[0] - high);
+           }      
+          fesetround(FE_UPWARD);
+         low -= TWO52;
+         low += TWO52;      
+          fesetround(mode);
+       }
+      u.dd[0] = high + low;
+      u.dd[1] = high - u.dd[0] + low;
+    }
+
+  return u.d;
+}
+
+long_double_symbol (libm, __ceill, ceill);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_copysignl.c b/sysdeps/ieee754/ldbl-128ibm/s_copysignl.c
new file mode 100644 (file)
index 0000000..7e7b441
--- /dev/null
@@ -0,0 +1,45 @@
+/* s_copysignl.c -- long double version of s_copysign.c.
+ * Conversion to long double by Jakub Jelinek, jj@ultra.linux.cz.
+ */
+
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: $";
+#endif
+
+/*
+ * copysignl(long double x, long double y)
+ * copysignl(x,y) returns a value with the magnitude of x and
+ * with the sign bit of y.
+ */
+
+#include "math.h"
+#include "math_private.h"
+
+#ifdef __STDC__
+       long double __copysignl(long double x, long double y)
+#else
+       long double __copysignl(x,y)
+       long double x,y;
+#endif
+{
+  if (y < 0.0)
+    {
+      if (x >= 0.0)
+       x = -x;
+    }
+  else if (x < 0.0)
+    x = -x;
+  return x;
+}
+weak_alias (__copysignl, copysignl)
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_cosl.c b/sysdeps/ieee754/ldbl-128ibm/s_cosl.c
new file mode 100644 (file)
index 0000000..59a8196
--- /dev/null
@@ -0,0 +1,88 @@
+/* s_cosl.c -- long double version of s_cos.c.
+ * Conversion to long double by Jakub Jelinek, jj@ultra.linux.cz.
+ */
+
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+/* cosl(x)
+ * Return cosine function of x.
+ *
+ * kernel function:
+ *     __kernel_sinl           ... sine function on [-pi/4,pi/4]
+ *     __kernel_cosl           ... cosine function on [-pi/4,pi/4]
+ *     __ieee754_rem_pio2l     ... argument reduction routine
+ *
+ * Method.
+ *      Let S,C and T denote the sin, cos and tan respectively on
+ *     [-PI/4, +PI/4]. Reduce the argument x to y1+y2 = x-k*pi/2
+ *     in [-pi/4 , +pi/4], and let n = k mod 4.
+ *     We have
+ *
+ *          n        sin(x)      cos(x)        tan(x)
+ *     ----------------------------------------------------------
+ *         0          S           C             T
+ *         1          C          -S            -1/T
+ *         2         -S          -C             T
+ *         3         -C           S            -1/T
+ *     ----------------------------------------------------------
+ *
+ * Special cases:
+ *      Let trig be any of sin, cos, or tan.
+ *      trig(+-INF)  is NaN, with signals;
+ *      trig(NaN)    is that NaN;
+ *
+ * Accuracy:
+ *     TRIG(x) returns trig(x) nearly rounded
+ */
+
+#include "math.h"
+#include "math_private.h"
+#include <math_ldbl_opt.h>
+
+#ifdef __STDC__
+       long double __cosl(long double x)
+#else
+       long double __cosl(x)
+       long double x;
+#endif
+{
+       long double y[2],z=0.0L;
+       int64_t n, ix;
+
+    /* High word of x. */
+       GET_LDOUBLE_MSW64(ix,x);
+
+    /* |x| ~< pi/4 */
+       ix &= 0x7fffffffffffffffLL;
+       if(ix <= 0x3fe921fb54442d18LL)
+         return __kernel_cosl(x,z);
+
+    /* cos(Inf or NaN) is NaN */
+       else if (ix>=0x7ff0000000000000LL)
+           return x-x;
+
+    /* argument reduction needed */
+       else {
+           n = __ieee754_rem_pio2l(x,y);
+           switch(n&3) {
+               case 0:
+                   return  __kernel_cosl(y[0],y[1]);
+               case 1:
+                   return -__kernel_sinl(y[0],y[1],1);
+               case 2:
+                   return -__kernel_cosl(y[0],y[1]);
+               default:
+                   return  __kernel_sinl(y[0],y[1],1);
+           }
+       }
+}
+long_double_symbol (libm, __cosl, cosl);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_erfl.c b/sysdeps/ieee754/ldbl-128ibm/s_erfl.c
new file mode 100644 (file)
index 0000000..02b450e
--- /dev/null
@@ -0,0 +1,958 @@
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+/* Modifications and expansions for 128-bit long double are
+   Copyright (C) 2001 Stephen L. Moshier <moshier@na-net.ornl.gov>
+   and are incorporated herein by permission of the author.  The author
+   reserves the right to distribute this material elsewhere under different
+   copying permissions.  These modifications are distributed here under
+   the following terms:
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA */
+
+/* double erf(double x)
+ * double erfc(double x)
+ *                          x
+ *                   2      |\
+ *     erf(x)  =  ---------  | exp(-t*t)dt
+ *                sqrt(pi) \|
+ *                          0
+ *
+ *     erfc(x) =  1-erf(x)
+ *  Note that
+ *             erf(-x) = -erf(x)
+ *             erfc(-x) = 2 - erfc(x)
+ *
+ * Method:
+ *     1.  erf(x)  = x + x*R(x^2) for |x| in [0, 7/8]
+ *        Remark. The formula is derived by noting
+ *          erf(x) = (2/sqrt(pi))*(x - x^3/3 + x^5/10 - x^7/42 + ....)
+ *        and that
+ *          2/sqrt(pi) = 1.128379167095512573896158903121545171688
+ *        is close to one.
+ *
+ *      1a. erf(x)  = 1 - erfc(x), for |x| > 1.0
+ *          erfc(x) = 1 - erf(x)  if |x| < 1/4
+ *
+ *      2. For |x| in [7/8, 1], let s = |x| - 1, and
+ *         c = 0.84506291151 rounded to single (24 bits)
+ *     erf(s + c)  = sign(x) * (c  + P1(s)/Q1(s))
+ *        Remark: here we use the taylor series expansion at x=1.
+ *             erf(1+s) = erf(1) + s*Poly(s)
+ *                      = 0.845.. + P1(s)/Q1(s)
+ *        Note that |P1/Q1|< 0.078 for x in [0.84375,1.25]
+ *
+ *      3. For x in [1/4, 5/4],
+ *     erfc(s + const)  = erfc(const)  + s P1(s)/Q1(s)
+ *              for const = 1/4, 3/8, ..., 9/8
+ *              and 0 <= s <= 1/8 .
+ *
+ *      4. For x in [5/4, 107],
+ *     erfc(x) = (1/x)*exp(-x*x-0.5625 + R(z))
+ *              z=1/x^2
+ *         The interval is partitioned into several segments
+ *         of width 1/8 in 1/x.
+ *
+ *      Note1:
+ *        To compute exp(-x*x-0.5625+R/S), let s be a single
+ *        precision number and s := x; then
+ *             -x*x = -s*s + (s-x)*(s+x)
+ *             exp(-x*x-0.5626+R/S) =
+ *                     exp(-s*s-0.5625)*exp((s-x)*(s+x)+R/S);
+ *      Note2:
+ *        Here 4 and 5 make use of the asymptotic series
+ *                       exp(-x*x)
+ *             erfc(x) ~ ---------- * ( 1 + Poly(1/x^2) )
+ *                       x*sqrt(pi)
+ *
+ *      5. For inf > x >= 107
+ *     erf(x)  = sign(x) *(1 - tiny)  (raise inexact)
+ *     erfc(x) = tiny*tiny (raise underflow) if x > 0
+ *                     = 2 - tiny if x<0
+ *
+ *      7. Special case:
+ *     erf(0)  = 0, erf(inf)  = 1, erf(-inf) = -1,
+ *     erfc(0) = 1, erfc(inf) = 0, erfc(-inf) = 2,
+ *             erfc/erf(NaN) is NaN
+ */
+
+#include "math.h"
+#include "math_private.h"
+#include <math_ldbl_opt.h>
+
+/* Evaluate P[n] x^n  +  P[n-1] x^(n-1)  +  ...  +  P[0] */
+
+static long double
+neval (long double x, const long double *p, int n)
+{
+  long double y;
+
+  p += n;
+  y = *p--;
+  do
+    {
+      y = y * x + *p--;
+    }
+  while (--n > 0);
+  return y;
+}
+
+
+/* Evaluate x^n+1  +  P[n] x^(n)  +  P[n-1] x^(n-1)  +  ...  +  P[0] */
+
+static long double
+deval (long double x, const long double *p, int n)
+{
+  long double y;
+
+  p += n;
+  y = x + *p--;
+  do
+    {
+      y = y * x + *p--;
+    }
+  while (--n > 0);
+  return y;
+}
+
+
+
+#ifdef __STDC__
+static const long double
+#else
+static long double
+#endif
+tiny = 1e-300L,
+  half = 0.5L,
+  one = 1.0L,
+  two = 2.0L,
+  /* 2/sqrt(pi) - 1 */
+  efx = 1.2837916709551257389615890312154517168810E-1L,
+  /* 8 * (2/sqrt(pi) - 1) */
+  efx8 = 1.0270333367641005911692712249723613735048E0L;
+
+
+/* erf(x)  = x  + x R(x^2)
+   0 <= x <= 7/8
+   Peak relative error 1.8e-35  */
+#define NTN1 8
+static const long double TN1[NTN1 + 1] =
+{
+ -3.858252324254637124543172907442106422373E10L,
+  9.580319248590464682316366876952214879858E10L,
+  1.302170519734879977595901236693040544854E10L,
+  2.922956950426397417800321486727032845006E9L,
+  1.764317520783319397868923218385468729799E8L,
+  1.573436014601118630105796794840834145120E7L,
+  4.028077380105721388745632295157816229289E5L,
+  1.644056806467289066852135096352853491530E4L,
+  3.390868480059991640235675479463287886081E1L
+};
+#define NTD1 8
+static const long double TD1[NTD1 + 1] =
+{
+  -3.005357030696532927149885530689529032152E11L,
+  -1.342602283126282827411658673839982164042E11L,
+  -2.777153893355340961288511024443668743399E10L,
+  -3.483826391033531996955620074072768276974E9L,
+  -2.906321047071299585682722511260895227921E8L,
+  -1.653347985722154162439387878512427542691E7L,
+  -6.245520581562848778466500301865173123136E5L,
+  -1.402124304177498828590239373389110545142E4L,
+  -1.209368072473510674493129989468348633579E2L
+/* 1.0E0 */
+};
+
+
+/* erf(z+1)  = erf_const + P(z)/Q(z)
+   -.125 <= z <= 0
+   Peak relative error 7.3e-36  */
+static const long double erf_const = 0.845062911510467529296875L;
+#define NTN2 8
+static const long double TN2[NTN2 + 1] =
+{
+ -4.088889697077485301010486931817357000235E1L,
+  7.157046430681808553842307502826960051036E3L,
+ -2.191561912574409865550015485451373731780E3L,
+  2.180174916555316874988981177654057337219E3L,
+  2.848578658049670668231333682379720943455E2L,
+  1.630362490952512836762810462174798925274E2L,
+  6.317712353961866974143739396865293596895E0L,
+  2.450441034183492434655586496522857578066E1L,
+  5.127662277706787664956025545897050896203E-1L
+};
+#define NTD2 8
+static const long double TD2[NTD2 + 1] =
+{
+  1.731026445926834008273768924015161048885E4L,
+  1.209682239007990370796112604286048173750E4L,
+  1.160950290217993641320602282462976163857E4L,
+  5.394294645127126577825507169061355698157E3L,
+  2.791239340533632669442158497532521776093E3L,
+  8.989365571337319032943005387378993827684E2L,
+  2.974016493766349409725385710897298069677E2L,
+  6.148192754590376378740261072533527271947E1L,
+  1.178502892490738445655468927408440847480E1L
+ /* 1.0E0 */
+};
+
+
+/* erfc(x + 0.25) = erfc(0.25) + x R(x)
+   0 <= x < 0.125
+   Peak relative error 1.4e-35  */
+#define NRNr13 8
+static const long double RNr13[NRNr13 + 1] =
+{
+ -2.353707097641280550282633036456457014829E3L,
+  3.871159656228743599994116143079870279866E2L,
+ -3.888105134258266192210485617504098426679E2L,
+ -2.129998539120061668038806696199343094971E1L,
+ -8.125462263594034672468446317145384108734E1L,
+  8.151549093983505810118308635926270319660E0L,
+ -5.033362032729207310462422357772568553670E0L,
+ -4.253956621135136090295893547735851168471E-2L,
+ -8.098602878463854789780108161581050357814E-2L
+};
+#define NRDr13 7
+static const long double RDr13[NRDr13 + 1] =
+{
+  2.220448796306693503549505450626652881752E3L,
+  1.899133258779578688791041599040951431383E2L,
+  1.061906712284961110196427571557149268454E3L,
+  7.497086072306967965180978101974566760042E1L,
+  2.146796115662672795876463568170441327274E2L,
+  1.120156008362573736664338015952284925592E1L,
+  2.211014952075052616409845051695042741074E1L,
+  6.469655675326150785692908453094054988938E-1L
+ /* 1.0E0 */
+};
+/* erfc(0.25) = C13a + C13b to extra precision.  */
+static const long double C13a = 0.723663330078125L;
+static const long double C13b = 1.0279753638067014931732235184287934646022E-5L;
+
+
+/* erfc(x + 0.375) = erfc(0.375) + x R(x)
+   0 <= x < 0.125
+   Peak relative error 1.2e-35  */
+#define NRNr14 8
+static const long double RNr14[NRNr14 + 1] =
+{
+ -2.446164016404426277577283038988918202456E3L,
+  6.718753324496563913392217011618096698140E2L,
+ -4.581631138049836157425391886957389240794E2L,
+ -2.382844088987092233033215402335026078208E1L,
+ -7.119237852400600507927038680970936336458E1L,
+  1.313609646108420136332418282286454287146E1L,
+ -6.188608702082264389155862490056401365834E0L,
+ -2.787116601106678287277373011101132659279E-2L,
+ -2.230395570574153963203348263549700967918E-2L
+};
+#define NRDr14 7
+static const long double RDr14[NRDr14 + 1] =
+{
+  2.495187439241869732696223349840963702875E3L,
+  2.503549449872925580011284635695738412162E2L,
+  1.159033560988895481698051531263861842461E3L,
+  9.493751466542304491261487998684383688622E1L,
+  2.276214929562354328261422263078480321204E2L,
+  1.367697521219069280358984081407807931847E1L,
+  2.276988395995528495055594829206582732682E1L,
+  7.647745753648996559837591812375456641163E-1L
+ /* 1.0E0 */
+};
+/* erfc(0.375) = C14a + C14b to extra precision.  */
+static const long double C14a = 0.5958709716796875L;
+static const long double C14b = 1.2118885490201676174914080878232469565953E-5L;
+
+/* erfc(x + 0.5) = erfc(0.5) + x R(x)
+   0 <= x < 0.125
+   Peak relative error 4.7e-36  */
+#define NRNr15 8
+static const long double RNr15[NRNr15 + 1] =
+{
+ -2.624212418011181487924855581955853461925E3L,
+  8.473828904647825181073831556439301342756E2L,
+ -5.286207458628380765099405359607331669027E2L,
+ -3.895781234155315729088407259045269652318E1L,
+ -6.200857908065163618041240848728398496256E1L,
+  1.469324610346924001393137895116129204737E1L,
+ -6.961356525370658572800674953305625578903E0L,
+  5.145724386641163809595512876629030548495E-3L,
+  1.990253655948179713415957791776180406812E-2L
+};
+#define NRDr15 7
+static const long double RDr15[NRDr15 + 1] =
+{
+  2.986190760847974943034021764693341524962E3L,
+  5.288262758961073066335410218650047725985E2L,
+  1.363649178071006978355113026427856008978E3L,
+  1.921707975649915894241864988942255320833E2L,
+  2.588651100651029023069013885900085533226E2L,
+  2.628752920321455606558942309396855629459E1L,
+  2.455649035885114308978333741080991380610E1L,
+  1.378826653595128464383127836412100939126E0L
+  /* 1.0E0 */
+};
+/* erfc(0.5) = C15a + C15b to extra precision.  */
+static const long double C15a = 0.4794921875L;
+static const long double C15b = 7.9346869534623172533461080354712635484242E-6L;
+
+/* erfc(x + 0.625) = erfc(0.625) + x R(x)
+   0 <= x < 0.125
+   Peak relative error 5.1e-36  */
+#define NRNr16 8
+static const long double RNr16[NRNr16 + 1] =
+{
+ -2.347887943200680563784690094002722906820E3L,
+  8.008590660692105004780722726421020136482E2L,
+ -5.257363310384119728760181252132311447963E2L,
+ -4.471737717857801230450290232600243795637E1L,
+ -4.849540386452573306708795324759300320304E1L,
+  1.140885264677134679275986782978655952843E1L,
+ -6.731591085460269447926746876983786152300E0L,
+  1.370831653033047440345050025876085121231E-1L,
+  2.022958279982138755020825717073966576670E-2L,
+};
+#define NRDr16 7
+static const long double RDr16[NRDr16 + 1] =
+{
+  3.075166170024837215399323264868308087281E3L,
+  8.730468942160798031608053127270430036627E2L,
+  1.458472799166340479742581949088453244767E3L,
+  3.230423687568019709453130785873540386217E2L,
+  2.804009872719893612081109617983169474655E2L,
+  4.465334221323222943418085830026979293091E1L,
+  2.612723259683205928103787842214809134746E1L,
+  2.341526751185244109722204018543276124997E0L,
+  /* 1.0E0 */
+};
+/* erfc(0.625) = C16a + C16b to extra precision.  */
+static const long double C16a = 0.3767547607421875L;
+static const long double C16b = 4.3570693945275513594941232097252997287766E-6L;
+
+/* erfc(x + 0.75) = erfc(0.75) + x R(x)
+   0 <= x < 0.125
+   Peak relative error 1.7e-35  */
+#define NRNr17 8
+static const long double RNr17[NRNr17 + 1] =
+{
+  -1.767068734220277728233364375724380366826E3L,
+  6.693746645665242832426891888805363898707E2L,
+  -4.746224241837275958126060307406616817753E2L,
+  -2.274160637728782675145666064841883803196E1L,
+  -3.541232266140939050094370552538987982637E1L,
+  6.988950514747052676394491563585179503865E0L,
+  -5.807687216836540830881352383529281215100E0L,
+  3.631915988567346438830283503729569443642E-1L,
+  -1.488945487149634820537348176770282391202E-2L
+};
+#define NRDr17 7
+static const long double RDr17[NRDr17 + 1] =
+{
+  2.748457523498150741964464942246913394647E3L,
+  1.020213390713477686776037331757871252652E3L,
+  1.388857635935432621972601695296561952738E3L,
+  3.903363681143817750895999579637315491087E2L,
+  2.784568344378139499217928969529219886578E2L,
+  5.555800830216764702779238020065345401144E1L,
+  2.646215470959050279430447295801291168941E1L,
+  2.984905282103517497081766758550112011265E0L,
+  /* 1.0E0 */
+};
+/* erfc(0.75) = C17a + C17b to extra precision.  */
+static const long double C17a = 0.2888336181640625L;
+static const long double C17b = 1.0748182422368401062165408589222625794046E-5L;
+
+
+/* erfc(x + 0.875) = erfc(0.875) + x R(x)
+   0 <= x < 0.125
+   Peak relative error 2.2e-35  */
+#define NRNr18 8
+static const long double RNr18[NRNr18 + 1] =
+{
+ -1.342044899087593397419622771847219619588E3L,
+  6.127221294229172997509252330961641850598E2L,
+ -4.519821356522291185621206350470820610727E2L,
+  1.223275177825128732497510264197915160235E1L,
+ -2.730789571382971355625020710543532867692E1L,
+  4.045181204921538886880171727755445395862E0L,
+ -4.925146477876592723401384464691452700539E0L,
+  5.933878036611279244654299924101068088582E-1L,
+ -5.557645435858916025452563379795159124753E-2L
+};
+#define NRDr18 7
+static const long double RDr18[NRDr18 + 1] =
+{
+  2.557518000661700588758505116291983092951E3L,
+  1.070171433382888994954602511991940418588E3L,
+  1.344842834423493081054489613250688918709E3L,
+  4.161144478449381901208660598266288188426E2L,
+  2.763670252219855198052378138756906980422E2L,
+  5.998153487868943708236273854747564557632E1L,
+  2.657695108438628847733050476209037025318E1L,
+  3.252140524394421868923289114410336976512E0L,
+  /* 1.0E0 */
+};
+/* erfc(0.875) = C18a + C18b to extra precision.  */
+static const long double C18a = 0.215911865234375L;
+static const long double C18b = 1.3073705765341685464282101150637224028267E-5L;
+
+/* erfc(x + 1.0) = erfc(1.0) + x R(x)
+   0 <= x < 0.125
+   Peak relative error 1.6e-35  */
+#define NRNr19 8
+static const long double RNr19[NRNr19 + 1] =
+{
+ -1.139180936454157193495882956565663294826E3L,
+  6.134903129086899737514712477207945973616E2L,
+ -4.628909024715329562325555164720732868263E2L,
+  4.165702387210732352564932347500364010833E1L,
+ -2.286979913515229747204101330405771801610E1L,
+  1.870695256449872743066783202326943667722E0L,
+ -4.177486601273105752879868187237000032364E0L,
+  7.533980372789646140112424811291782526263E-1L,
+ -8.629945436917752003058064731308767664446E-2L
+};
+#define NRDr19 7
+static const long double RDr19[NRDr19 + 1] =
+{
+  2.744303447981132701432716278363418643778E3L,
+  1.266396359526187065222528050591302171471E3L,
+  1.466739461422073351497972255511919814273E3L,
+  4.868710570759693955597496520298058147162E2L,
+  2.993694301559756046478189634131722579643E2L,
+  6.868976819510254139741559102693828237440E1L,
+  2.801505816247677193480190483913753613630E1L,
+  3.604439909194350263552750347742663954481E0L,
+  /* 1.0E0 */
+};
+/* erfc(1.0) = C19a + C19b to extra precision.  */
+static const long double C19a = 0.15728759765625L;
+static const long double C19b = 1.1609394035130658779364917390740703933002E-5L;
+
+/* erfc(x + 1.125) = erfc(1.125) + x R(x)
+   0 <= x < 0.125
+   Peak relative error 3.6e-36  */
+#define NRNr20 8
+static const long double RNr20[NRNr20 + 1] =
+{
+ -9.652706916457973956366721379612508047640E2L,
+  5.577066396050932776683469951773643880634E2L,
+ -4.406335508848496713572223098693575485978E2L,
+  5.202893466490242733570232680736966655434E1L,
+ -1.931311847665757913322495948705563937159E1L,
+ -9.364318268748287664267341457164918090611E-2L,
+ -3.306390351286352764891355375882586201069E0L,
+  7.573806045289044647727613003096916516475E-1L,
+ -9.611744011489092894027478899545635991213E-2L
+};
+#define NRDr20 7
+static const long double RDr20[NRDr20 + 1] =
+{
+  3.032829629520142564106649167182428189014E3L,
+  1.659648470721967719961167083684972196891E3L,
+  1.703545128657284619402511356932569292535E3L,
+  6.393465677731598872500200253155257708763E2L,
+  3.489131397281030947405287112726059221934E2L,
+  8.848641738570783406484348434387611713070E1L,
+  3.132269062552392974833215844236160958502E1L,
+  4.430131663290563523933419966185230513168E0L
+ /* 1.0E0 */
+};
+/* erfc(1.125) = C20a + C20b to extra precision.  */
+static const long double C20a = 0.111602783203125L;
+static const long double C20b = 8.9850951672359304215530728365232161564636E-6L;
+
+/* erfc(1/x) = 1/x exp (-1/x^2 - 0.5625 + R(1/x^2))
+   7/8 <= 1/x < 1
+   Peak relative error 1.4e-35  */
+#define NRNr8 9
+static const long double RNr8[NRNr8 + 1] =
+{
+  3.587451489255356250759834295199296936784E1L,
+  5.406249749087340431871378009874875889602E2L,
+  2.931301290625250886238822286506381194157E3L,
+  7.359254185241795584113047248898753470923E3L,
+  9.201031849810636104112101947312492532314E3L,
+  5.749697096193191467751650366613289284777E3L,
+  1.710415234419860825710780802678697889231E3L,
+  2.150753982543378580859546706243022719599E2L,
+  8.740953582272147335100537849981160931197E0L,
+  4.876422978828717219629814794707963640913E-2L
+};
+#define NRDr8 8
+static const long double RDr8[NRDr8 + 1] =
+{
+  6.358593134096908350929496535931630140282E1L,
+  9.900253816552450073757174323424051765523E2L,
+  5.642928777856801020545245437089490805186E3L,
+  1.524195375199570868195152698617273739609E4L,
+  2.113829644500006749947332935305800887345E4L,
+  1.526438562626465706267943737310282977138E4L,
+  5.561370922149241457131421914140039411782E3L,
+  9.394035530179705051609070428036834496942E2L,
+  6.147019596150394577984175188032707343615E1L
+  /* 1.0E0 */
+};
+
+/* erfc(1/x) = 1/x exp (-1/x^2 - 0.5625 + R(1/x^2))
+   0.75 <= 1/x <= 0.875
+   Peak relative error 2.0e-36  */
+#define NRNr7 9
+static const long double RNr7[NRNr7 + 1] =
+{
+ 1.686222193385987690785945787708644476545E1L,
+ 1.178224543567604215602418571310612066594E3L,
+ 1.764550584290149466653899886088166091093E4L,
+ 1.073758321890334822002849369898232811561E5L,
+ 3.132840749205943137619839114451290324371E5L,
+ 4.607864939974100224615527007793867585915E5L,
+ 3.389781820105852303125270837910972384510E5L,
+ 1.174042187110565202875011358512564753399E5L,
+ 1.660013606011167144046604892622504338313E4L,
+ 6.700393957480661937695573729183733234400E2L
+};
+#define NRDr7 9
+static const long double RDr7[NRDr7 + 1] =
+{
+-1.709305024718358874701575813642933561169E3L,
+-3.280033887481333199580464617020514788369E4L,
+-2.345284228022521885093072363418750835214E5L,
+-8.086758123097763971926711729242327554917E5L,
+-1.456900414510108718402423999575992450138E6L,
+-1.391654264881255068392389037292702041855E6L,
+-6.842360801869939983674527468509852583855E5L,
+-1.597430214446573566179675395199807533371E5L,
+-1.488876130609876681421645314851760773480E4L,
+-3.511762950935060301403599443436465645703E2L
+ /* 1.0E0 */
+};
+
+/* erfc(1/x) = 1/x exp(-1/x^2 - 0.5625 + R(1/x^2))
+   5/8 <= 1/x < 3/4
+   Peak relative error 1.9e-35  */
+#define NRNr6 9
+static const long double RNr6[NRNr6 + 1] =
+{
+ 1.642076876176834390623842732352935761108E0L,
+ 1.207150003611117689000664385596211076662E2L,
+ 2.119260779316389904742873816462800103939E3L,
+ 1.562942227734663441801452930916044224174E4L,
+ 5.656779189549710079988084081145693580479E4L,
+ 1.052166241021481691922831746350942786299E5L,
+ 9.949798524786000595621602790068349165758E4L,
+ 4.491790734080265043407035220188849562856E4L,
+ 8.377074098301530326270432059434791287601E3L,
+ 4.506934806567986810091824791963991057083E2L
+};
+#define NRDr6 9
+static const long double RDr6[NRDr6 + 1] =
+{
+-1.664557643928263091879301304019826629067E2L,
+-3.800035902507656624590531122291160668452E3L,
+-3.277028191591734928360050685359277076056E4L,
+-1.381359471502885446400589109566587443987E5L,
+-3.082204287382581873532528989283748656546E5L,
+-3.691071488256738343008271448234631037095E5L,
+-2.300482443038349815750714219117566715043E5L,
+-6.873955300927636236692803579555752171530E4L,
+-8.262158817978334142081581542749986845399E3L,
+-2.517122254384430859629423488157361983661E2L
+ /* 1.00 */
+};
+
+/* erfc(1/x) = 1/x exp(-1/x^2 - 0.5625 + R(1/x^2))
+   1/2 <= 1/x < 5/8
+   Peak relative error 4.6e-36  */
+#define NRNr5 10
+static const long double RNr5[NRNr5 + 1] =
+{
+-3.332258927455285458355550878136506961608E-3L,
+-2.697100758900280402659586595884478660721E-1L,
+-6.083328551139621521416618424949137195536E0L,
+-6.119863528983308012970821226810162441263E1L,
+-3.176535282475593173248810678636522589861E2L,
+-8.933395175080560925809992467187963260693E2L,
+-1.360019508488475978060917477620199499560E3L,
+-1.075075579828188621541398761300910213280E3L,
+-4.017346561586014822824459436695197089916E2L,
+-5.857581368145266249509589726077645791341E1L,
+-2.077715925587834606379119585995758954399E0L
+};
+#define NRDr5 9
+static const long double RDr5[NRDr5 + 1] =
+{
+ 3.377879570417399341550710467744693125385E-1L,
+ 1.021963322742390735430008860602594456187E1L,
+ 1.200847646592942095192766255154827011939E2L,
+ 7.118915528142927104078182863387116942836E2L,
+ 2.318159380062066469386544552429625026238E3L,
+ 4.238729853534009221025582008928765281620E3L,
+ 4.279114907284825886266493994833515580782E3L,
+ 2.257277186663261531053293222591851737504E3L,
+ 5.570475501285054293371908382916063822957E2L,
+ 5.142189243856288981145786492585432443560E1L
+ /* 1.0E0 */
+};
+
+/* erfc(1/x) = 1/x exp(-1/x^2 - 0.5625 + R(1/x^2))
+   3/8 <= 1/x < 1/2
+   Peak relative error 2.0e-36  */
+#define NRNr4 10
+static const long double RNr4[NRNr4 + 1] =
+{
+ 3.258530712024527835089319075288494524465E-3L,
+ 2.987056016877277929720231688689431056567E-1L,
+ 8.738729089340199750734409156830371528862E0L,
+ 1.207211160148647782396337792426311125923E2L,
+ 8.997558632489032902250523945248208224445E2L,
+ 3.798025197699757225978410230530640879762E3L,
+ 9.113203668683080975637043118209210146846E3L,
+ 1.203285891339933238608683715194034900149E4L,
+ 8.100647057919140328536743641735339740855E3L,
+ 2.383888249907144945837976899822927411769E3L,
+ 2.127493573166454249221983582495245662319E2L
+};
+#define NRDr4 10
+static const long double RDr4[NRDr4 + 1] =
+{
+-3.303141981514540274165450687270180479586E-1L,
+-1.353768629363605300707949368917687066724E1L,
+-2.206127630303621521950193783894598987033E2L,
+-1.861800338758066696514480386180875607204E3L,
+-8.889048775872605708249140016201753255599E3L,
+-2.465888106627948210478692168261494857089E4L,
+-3.934642211710774494879042116768390014289E4L,
+-3.455077258242252974937480623730228841003E4L,
+-1.524083977439690284820586063729912653196E4L,
+-2.810541887397984804237552337349093953857E3L,
+-1.343929553541159933824901621702567066156E2L
+ /* 1.0E0 */
+};
+
+/* erfc(1/x) = 1/x exp(-1/x^2 - 0.5625 + R(1/x^2))
+   1/4 <= 1/x < 3/8
+   Peak relative error 8.4e-37  */
+#define NRNr3 11
+static const long double RNr3[NRNr3 + 1] =
+{
+-1.952401126551202208698629992497306292987E-6L,
+-2.130881743066372952515162564941682716125E-4L,
+-8.376493958090190943737529486107282224387E-3L,
+-1.650592646560987700661598877522831234791E-1L,
+-1.839290818933317338111364667708678163199E0L,
+-1.216278715570882422410442318517814388470E1L,
+-4.818759344462360427612133632533779091386E1L,
+-1.120994661297476876804405329172164436784E2L,
+-1.452850765662319264191141091859300126931E2L,
+-9.485207851128957108648038238656777241333E1L,
+-2.563663855025796641216191848818620020073E1L,
+-1.787995944187565676837847610706317833247E0L
+};
+#define NRDr3 10
+static const long double RDr3[NRDr3 + 1] =
+{
+ 1.979130686770349481460559711878399476903E-4L,
+ 1.156941716128488266238105813374635099057E-2L,
+ 2.752657634309886336431266395637285974292E-1L,
+ 3.482245457248318787349778336603569327521E0L,
+ 2.569347069372696358578399521203959253162E1L,
+ 1.142279000180457419740314694631879921561E2L,
+ 3.056503977190564294341422623108332700840E2L,
+ 4.780844020923794821656358157128719184422E2L,
+ 4.105972727212554277496256802312730410518E2L,
+ 1.724072188063746970865027817017067646246E2L,
+ 2.815939183464818198705278118326590370435E1L
+ /* 1.0E0 */
+};
+
+/* erfc(1/x) = 1/x exp(-1/x^2 - 0.5625 + R(1/x^2))
+   1/8 <= 1/x < 1/4
+   Peak relative error 1.5e-36  */
+#define NRNr2 11
+static const long double RNr2[NRNr2 + 1] =
+{
+-2.638914383420287212401687401284326363787E-8L,
+-3.479198370260633977258201271399116766619E-6L,
+-1.783985295335697686382487087502222519983E-4L,
+-4.777876933122576014266349277217559356276E-3L,
+-7.450634738987325004070761301045014986520E-2L,
+-7.068318854874733315971973707247467326619E-1L,
+-4.113919921935944795764071670806867038732E0L,
+-1.440447573226906222417767283691888875082E1L,
+-2.883484031530718428417168042141288943905E1L,
+-2.990886974328476387277797361464279931446E1L,
+-1.325283914915104866248279787536128997331E1L,
+-1.572436106228070195510230310658206154374E0L
+};
+#define NRDr2 10
+static const long double RDr2[NRDr2 + 1] =
+{
+ 2.675042728136731923554119302571867799673E-6L,
+ 2.170997868451812708585443282998329996268E-4L,
+ 7.249969752687540289422684951196241427445E-3L,
+ 1.302040375859768674620410563307838448508E-1L,
+ 1.380202483082910888897654537144485285549E0L,
+ 8.926594113174165352623847870299170069350E0L,
+ 3.521089584782616472372909095331572607185E1L,
+ 8.233547427533181375185259050330809105570E1L,
+ 1.072971579885803033079469639073292840135E2L,
+ 6.943803113337964469736022094105143158033E1L,
+ 1.775695341031607738233608307835017282662E1L
+ /* 1.0E0 */
+};
+
+/* erfc(1/x) = 1/x exp(-1/x^2 - 0.5625 + R(1/x^2))
+   1/128 <= 1/x < 1/8
+   Peak relative error 2.2e-36  */
+#define NRNr1 9
+static const long double RNr1[NRNr1 + 1] =
+{
+-4.250780883202361946697751475473042685782E-8L,
+-5.375777053288612282487696975623206383019E-6L,
+-2.573645949220896816208565944117382460452E-4L,
+-6.199032928113542080263152610799113086319E-3L,
+-8.262721198693404060380104048479916247786E-2L,
+-6.242615227257324746371284637695778043982E-1L,
+-2.609874739199595400225113299437099626386E0L,
+-5.581967563336676737146358534602770006970E0L,
+-5.124398923356022609707490956634280573882E0L,
+-1.290865243944292370661544030414667556649E0L
+};
+#define NRDr1 8
+static const long double RDr1[NRDr1 + 1] =
+{
+ 4.308976661749509034845251315983612976224E-6L,
+ 3.265390126432780184125233455960049294580E-4L,
+ 9.811328839187040701901866531796570418691E-3L,
+ 1.511222515036021033410078631914783519649E-1L,
+ 1.289264341917429958858379585970225092274E0L,
+ 6.147640356182230769548007536914983522270E0L,
+ 1.573966871337739784518246317003956180750E1L,
+ 1.955534123435095067199574045529218238263E1L,
+ 9.472613121363135472247929109615785855865E0L
+  /* 1.0E0 */
+};
+
+
+#ifdef __STDC__
+long double
+__erfl (long double x)
+#else
+double
+__erfl (x)
+     long double x;
+#endif
+{
+  long double a, y, z;
+  int32_t i, ix, sign;
+  ieee854_long_double_shape_type u;
+
+  u.value = x;
+  sign = u.parts32.w0;
+  ix = sign & 0x7fffffff;
+
+  if (ix >= 0x7ff00000)
+    {                          /* erf(nan)=nan */
+      i = ((sign & 0xfff00000) >> 31) << 1;
+      return (long double) (1 - i) + one / x;  /* erf(+-inf)=+-1 */
+    }
+
+  if (ix >= 0x3ff00000) /* |x| >= 1.0 */
+    {
+      y = __erfcl (x);
+      return (one - y);
+      /*    return (one - __erfcl (x)); */
+    }
+  u.parts32.w0 = ix;
+  a = u.value;
+  z = x * x;
+  if (ix < 0x3fec0000)  /* a < 0.875 */
+    {
+      if (ix < 0x3c600000) /* |x|<2**-57 */
+       {
+         if (ix < 0x00800000)
+           {
+             /* erf (-0) = -0.  Unfortunately, for IBM extended double
+                0.125 * (8.0 * x + efx8 * x) for x = -0 evaluates to 0.  */
+             if (x == 0)
+               return x;
+             return 0.125 * (8.0 * x + efx8 * x);      /*avoid underflow */
+           }
+         return x + efx * x;
+       }
+      y = a + a * neval (z, TN1, NTN1) / deval (z, TD1, NTD1);
+    }
+  else
+    {
+      a = a - one;
+      y = erf_const + neval (a, TN2, NTN2) / deval (a, TD2, NTD2);
+    }
+
+  if (sign & 0x80000000) /* x < 0 */
+    y = -y;
+  return( y );
+}
+
+long_double_symbol (libm, __erfl, erfl);
+#ifdef __STDC__
+     long double
+     __erfcl (long double x)
+#else
+     long double
+     __erfcl (x)
+     double
+       x;
+#endif
+{
+  long double y, z, p, r;
+  int32_t i, ix, sign;
+  ieee854_long_double_shape_type u;
+
+  u.value = x;
+  sign = u.parts32.w0;
+  ix = sign & 0x7fffffff;
+  u.parts32.w0 = ix;
+
+  if (ix >= 0x7ff00000)
+    {                          /* erfc(nan)=nan */
+      /* erfc(+-inf)=0,2 */
+      return (long double) (((u_int32_t) sign >> 31) << 1) + one / x;
+    }
+
+  if (ix < 0x3fd00000) /* |x| <1/4 */
+    {
+      if (ix < 0x38d00000) /* |x|<2**-114 */
+       return one - x;
+      return one - __erfl (x);
+    }
+  if (ix < 0x3ff40000) /* 1.25 */
+    {
+      x = u.value;
+      i = 8.0 * x;
+      switch (i)
+       {
+       case 2:
+         z = x - 0.25L;
+         y = C13b + z * neval (z, RNr13, NRNr13) / deval (z, RDr13, NRDr13);
+         y += C13a;
+         break;
+       case 3:
+         z = x - 0.375L;
+         y = C14b + z * neval (z, RNr14, NRNr14) / deval (z, RDr14, NRDr14);
+         y += C14a;
+         break;
+       case 4:
+         z = x - 0.5L;
+         y = C15b + z * neval (z, RNr15, NRNr15) / deval (z, RDr15, NRDr15);
+         y += C15a;
+         break;
+       case 5:
+         z = x - 0.625L;
+         y = C16b + z * neval (z, RNr16, NRNr16) / deval (z, RDr16, NRDr16);
+         y += C16a;
+         break;
+       case 6:
+         z = x - 0.75L;
+         y = C17b + z * neval (z, RNr17, NRNr17) / deval (z, RDr17, NRDr17);
+         y += C17a;
+         break;
+       case 7:
+         z = x - 0.875L;
+         y = C18b + z * neval (z, RNr18, NRNr18) / deval (z, RDr18, NRDr18);
+         y += C18a;
+         break;
+       case 8:
+         z = x - 1.0L;
+         y = C19b + z * neval (z, RNr19, NRNr19) / deval (z, RDr19, NRDr19);
+         y += C19a;
+         break;
+       case 9:
+         z = x - 1.125L;
+         y = C20b + z * neval (z, RNr20, NRNr20) / deval (z, RDr20, NRDr20);
+         y += C20a;
+         break;
+       }
+      if (sign & 0x80000000)
+       y = 2.0L - y;
+      return y;
+    }
+  /* 1.25 < |x| < 107 */
+  if (ix < 0x405ac000)
+    {
+      /* x < -9 */
+      if ((ix >= 0x40220000) && (sign & 0x80000000))
+       return two - tiny;
+
+      x = fabsl (x);
+      z = one / (x * x);
+      i = 8.0 / x;
+      switch (i)
+       {
+       default:
+       case 0:
+         p = neval (z, RNr1, NRNr1) / deval (z, RDr1, NRDr1);
+         break;
+       case 1:
+         p = neval (z, RNr2, NRNr2) / deval (z, RDr2, NRDr2);
+         break;
+       case 2:
+         p = neval (z, RNr3, NRNr3) / deval (z, RDr3, NRDr3);
+         break;
+       case 3:
+         p = neval (z, RNr4, NRNr4) / deval (z, RDr4, NRDr4);
+         break;
+       case 4:
+         p = neval (z, RNr5, NRNr5) / deval (z, RDr5, NRDr5);
+         break;
+       case 5:
+         p = neval (z, RNr6, NRNr6) / deval (z, RDr6, NRDr6);
+         break;
+       case 6:
+         p = neval (z, RNr7, NRNr7) / deval (z, RDr7, NRDr7);
+         break;
+       case 7:
+         p = neval (z, RNr8, NRNr8) / deval (z, RDr8, NRDr8);
+         break;
+       }
+      u.value = x;
+      u.parts32.w3 = 0;
+      u.parts32.w2 &= 0xffffe000;
+      z = u.value;
+      r = __ieee754_expl (-z * z - 0.5625) *
+       __ieee754_expl ((z - x) * (z + x) + p);
+      if ((sign & 0x80000000) == 0)
+       return r / x;
+      else
+       return two - r / x;
+    }
+  else
+    {
+      if ((sign & 0x80000000) == 0)
+       return tiny * tiny;
+      else
+       return two - tiny;
+    }
+}
+
+long_double_symbol (libm, __erfcl, erfcl);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_expm1l.c b/sysdeps/ieee754/ldbl-128ibm/s_expm1l.c
new file mode 100644 (file)
index 0000000..4908d4e
--- /dev/null
@@ -0,0 +1,160 @@
+/*                                                     expm1l.c
+ *
+ *     Exponential function, minus 1
+ *      128-bit long double precision
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * long double x, y, expm1l();
+ *
+ * y = expm1l( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns e (2.71828...) raised to the x power, minus one.
+ *
+ * Range reduction is accomplished by separating the argument
+ * into an integer k and fraction f such that
+ *
+ *     x    k  f
+ *    e  = 2  e.
+ *
+ * An expansion x + .5 x^2 + x^3 R(x) approximates exp(f) - 1
+ * in the basic range [-0.5 ln 2, 0.5 ln 2].
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE    -79,+MAXLOG    100,000     1.7e-34     4.5e-35
+ *
+ */
+
+/* Copyright 2001 by Stephen L. Moshier
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; 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"
+#include <math_ldbl_opt.h>
+
+/* exp(x) - 1 = x + 0.5 x^2 + x^3 P(x)/Q(x)
+   -.5 ln 2  <  x  <  .5 ln 2
+   Theoretical peak relative error = 8.1e-36  */
+
+static const long double
+  P0 = 2.943520915569954073888921213330863757240E8L,
+  P1 = -5.722847283900608941516165725053359168840E7L,
+  P2 = 8.944630806357575461578107295909719817253E6L,
+  P3 = -7.212432713558031519943281748462837065308E5L,
+  P4 = 4.578962475841642634225390068461943438441E4L,
+  P5 = -1.716772506388927649032068540558788106762E3L,
+  P6 = 4.401308817383362136048032038528753151144E1L,
+  P7 = -4.888737542888633647784737721812546636240E-1L,
+  Q0 = 1.766112549341972444333352727998584753865E9L,
+  Q1 = -7.848989743695296475743081255027098295771E8L,
+  Q2 = 1.615869009634292424463780387327037251069E8L,
+  Q3 = -2.019684072836541751428967854947019415698E7L,
+  Q4 = 1.682912729190313538934190635536631941751E6L,
+  Q5 = -9.615511549171441430850103489315371768998E4L,
+  Q6 = 3.697714952261803935521187272204485251835E3L,
+  Q7 = -8.802340681794263968892934703309274564037E1L,
+  /* Q8 = 1.000000000000000000000000000000000000000E0 */
+/* C1 + C2 = ln 2 */
+
+  C1 = 6.93145751953125E-1L,
+  C2 = 1.428606820309417232121458176568075500134E-6L,
+/* ln (2^16384 * (1 - 2^-113)) */
+  maxlog = 1.1356523406294143949491931077970764891253E4L,
+/* ln 2^-114 */
+  minarg = -7.9018778583833765273564461846232128760607E1L, big = 2e307L;
+
+
+long double
+__expm1l (long double x)
+{
+  long double px, qx, xx;
+  int32_t ix, sign;
+  ieee854_long_double_shape_type u;
+  int k;
+
+  /* Detect infinity and NaN.  */
+  u.value = x;
+  ix = u.parts32.w0;
+  sign = ix & 0x80000000;
+  ix &= 0x7fffffff;
+  if (ix >= 0x7ff00000)
+    {
+      /* Infinity. */
+      if (((ix & 0xfffff) | u.parts32.w1 | (u.parts32.w2&0x7fffffff) | u.parts32.w3) == 0)
+       {
+         if (sign)
+           return -1.0L;
+         else
+           return x;
+       }
+      /* NaN. No invalid exception. */
+      return x;
+    }
+
+  /* expm1(+- 0) = +- 0.  */
+  if ((ix == 0) && (u.parts32.w1 | (u.parts32.w2&0x7fffffff) | u.parts32.w3) == 0)
+    return x;
+
+  /* Overflow.  */
+  if (x > maxlog)
+    return (big * big);
+
+  /* Minimum value.  */
+  if (x < minarg)
+    return (4.0/big - 1.0L);
+
+  /* Express x = ln 2 (k + remainder), remainder not exceeding 1/2. */
+  xx = C1 + C2;                        /* ln 2. */
+  px = __floorl (0.5 + x / xx);
+  k = px;
+  /* remainder times ln 2 */
+  x -= px * C1;
+  x -= px * C2;
+
+  /* Approximate exp(remainder ln 2).  */
+  px = (((((((P7 * x
+             + P6) * x
+            + P5) * x + P4) * x + P3) * x + P2) * x + P1) * x + P0) * x;
+
+  qx = (((((((x
+             + Q7) * x
+            + Q6) * x + Q5) * x + Q4) * x + Q3) * x + Q2) * x + Q1) * x + Q0;
+
+  xx = x * x;
+  qx = x + (0.5 * xx + xx * px / qx);
+
+  /* exp(x) = exp(k ln 2) exp(remainder ln 2) = 2^k exp(remainder ln 2).
+
+  We have qx = exp(remainder ln 2) - 1, so
+  exp(x) - 1 = 2^k (qx + 1) - 1
+             = 2^k qx + 2^k - 1.  */
+
+  px = ldexpl (1.0L, k);
+  x = px * qx + (px - 1.0);
+  return x;
+}
+libm_hidden_def (__expm1l)
+long_double_symbol (libm, __expm1l, expm1l);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_fabsl.c b/sysdeps/ieee754/ldbl-128ibm/s_fabsl.c
new file mode 100644 (file)
index 0000000..6266312
--- /dev/null
@@ -0,0 +1,43 @@
+/* s_fabsl.c -- long double version of s_fabs.c.
+ * Conversion to IEEE quad long double by Jakub Jelinek, jj@ultra.linux.cz.
+ */
+
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: $";
+#endif
+
+
+/*
+ * fabsl(x) returns the absolute value of x.
+ */
+
+#include "math.h"
+#include "math_private.h"
+#include <math_ldbl_opt.h>
+
+#ifdef __STDC__
+       long double __fabsl(long double x)
+#else
+       long double __fabsl(x)
+       long double x;
+#endif
+{
+       u_int64_t hx, lx;
+       GET_LDOUBLE_WORDS64(hx,lx,x);
+       lx = lx ^ ( hx & 0x8000000000000000LL );
+       hx = hx & 0x7fffffffffffffffLL;
+       SET_LDOUBLE_WORDS64(hx,lx,x);
+        return x;
+}
+long_double_symbol (libm, __fabsl, fabsl);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_finitel.c b/sysdeps/ieee754/ldbl-128ibm/s_finitel.c
new file mode 100644 (file)
index 0000000..142d3ed
--- /dev/null
@@ -0,0 +1,42 @@
+/* s_finitel.c -- long double version of s_finite.c.
+ * Conversion to IEEE quad long double by Jakub Jelinek, jj@ultra.linux.cz.
+ */
+
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: $";
+#endif
+
+/*
+ * finitel(x) returns 1 is x is finite, else 0;
+ * no branching!
+ */
+
+#include "math.h"
+#include "math_private.h"
+#include <math_ldbl_opt.h>
+
+int
+___finitel (long double x)
+{
+       int64_t hx;
+       GET_LDOUBLE_MSW64(hx,x);
+       return (int)((u_int64_t)((hx&0x7fffffffffffffffLL)
+                                -0x7ff0000000000000LL)>>63);
+}
+hidden_ver (___finitel, __finitel)
+#ifndef IS_IN_libm
+weak_alias (___finitel, ____finitel)
+long_double_symbol (libc, ___finitel, finitel);
+long_double_symbol (libc, ____finitel, __finitel);
+#endif
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_floorl.c b/sysdeps/ieee754/ldbl-128ibm/s_floorl.c
new file mode 100644 (file)
index 0000000..e8ef6e8
--- /dev/null
@@ -0,0 +1,118 @@
+/* Round to int long double floating-point values.
+   IBM extended format long double version.
+   Copyright (C) 2006 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+/* This has been coded in assembler because GCC makes such a mess of it
+   when it's coded in C.  */
+
+#include <math.h>
+#include <fenv.h>
+#include <math_ldbl_opt.h>
+#include <float.h>
+#include <ieee754.h>
+
+
+#ifdef __STDC__
+long double
+__floorl (long double x)
+#else
+long double
+__floorl (x)
+     long double x;
+#endif
+{
+  static const double TWO52 = 4503599627370496.0L;
+  int mode = fegetround();
+  union ibm_extended_long_double u;
+
+  u.d = x;
+
+  if (fabs (u.dd[0]) < TWO52)
+    {     
+      fesetround(FE_DOWNWARD);
+      if (u.dd[0] > 0.0)
+       {
+         u.dd[0] += TWO52;
+         u.dd[0] -= TWO52;
+       }
+      else if (u.dd[0] < 0.0)
+       {
+         u.dd[0] -= TWO52;
+         u.dd[0] += TWO52;
+       }
+      u.dd[1] = 0.0;
+      fesetround(mode);
+    }
+  else if (fabs (u.dd[1]) < TWO52 && u.dd[1] != 0.0)
+    {
+      double high, low;
+      /* In this case we have to round the low double and handle any
+         adjustment to the high double that may be caused by rounding
+         (up).  This is complicated by the fact that the high double
+         may already be rounded and the low double may have the
+         opposite sign to compensate.  */
+      if (u.dd[0] > 0.0)
+       {
+         if (u.dd[1] > 0.0)
+           {
+             /* If the high/low doubles are the same sign then simply
+                round the low double.  */
+             high = u.dd[0];
+             low = u.dd[1];
+           }
+         else if (u.dd[1] < 0.0)
+           {
+             /* Else the high double is pre rounded and we need to
+                adjust for that.  */
+             high = nextafter (u.dd[0], 0.0);
+             low = u.dd[1] + (u.dd[0] - high);
+           }
+          fesetround(FE_DOWNWARD);
+         low += TWO52;
+         low -= TWO52;
+       }
+      else if (u.dd[0] < 0.0)
+       {
+         if (u.dd[1] < 0.0)
+           {
+             /* If the high/low doubles are the same sign then simply
+                round the low double.  */
+             high = u.dd[0];
+             low = u.dd[1];
+           }
+         else if (u.dd[1] > 0.0)
+           {
+             /* Else the high double is pre rounded and we need to
+                adjust for that.  */
+             high = nextafter (u.dd[0], 0.0);
+             low = u.dd[1] + (u.dd[0] - high);
+           }
+          fesetround(FE_DOWNWARD);
+         low -= TWO52;
+         low += TWO52;
+       }
+      fesetround(mode);
+      u.dd[0] = high + low;
+      u.dd[1] = high - u.dd[0] + low;
+    }
+
+  return u.d;
+}
+
+long_double_symbol (libm, __floorl, floorl);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_fpclassifyl.c b/sysdeps/ieee754/ldbl-128ibm/s_fpclassifyl.c
new file mode 100644 (file)
index 0000000..3ca178a
--- /dev/null
@@ -0,0 +1,82 @@
+/* Return classification value corresponding to argument.
+   Copyright (C) 1997,1999,2002,2004,2006 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997 and
+                 Jakub Jelinek <jj@ultra.linux.cz>, 1999.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; 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"
+#include <math_ldbl_opt.h>
+
+  /*
+   *           hx                  lx
+   * +NaN      7ffn nnnn nnnn nnnn xxxx xxxx xxxx xxxx
+   * -NaN      fffn nnnn nnnn nnnn xxxx xxxx xxxx xxxx
+   * +Inf      7ff0 0000 0000 0000 xxxx xxxx xxxx xxxx
+   * -Inf      fff0 0000 0000 0000 xxxx xxxx xxxx xxxx
+   * +0                0000 0000 0000 0000
+   * -0                8000 0000 0000 0000
+   * +normal   001n nnnn nnnn nnnn (smallest)
+   * -normal   801n nnnn nnnn nnnn (smallest)
+   * +normal   7fen nnnn nnnn nnnn (largest)
+   * -normal   ffen nnnn nnnn nnnn (largest)
+   * +denorm   000n nnnn nnnn nnnn
+   * -denorm   800n nnnn nnnn nnnn
+   */
+
+int
+___fpclassifyl (long double x)
+{
+  u_int64_t hx, lx;
+  int retval = FP_NORMAL;
+
+  GET_LDOUBLE_WORDS64 (hx, lx, x);
+  if ((hx & 0x7ff0000000000000ULL) == 0x7ff0000000000000ULL) {
+      /* +/-NaN or +/-Inf */
+      if (hx & 0x000fffffffffffffULL) {
+         /* +/-NaN */
+         retval = FP_NAN;
+      } else {
+         retval = FP_INFINITE;
+      }
+  } else {
+      /* +/-zero or +/- normal or +/- denormal */
+      if (hx & 0x7fffffffffffffffULL) {
+         /* +/- normal or +/- denormal */
+         if ((hx & 0x7ff0000000000000ULL) >= 0x0360000000000000ULL) {
+             /* +/- normal */
+             retval = FP_NORMAL;
+         } else {
+             /* +/- denormal */
+             retval = FP_SUBNORMAL;
+         }
+      } else {
+         /* +/- zero */
+         retval = FP_ZERO;
+      }
+  }
+
+  return retval;
+}
+long_double_symbol (libm, ___fpclassifyl, __fpclassifyl);
+#ifdef __LONG_DOUBLE_MATH_OPTIONAL
+libm_hidden_ver (___fpclassifyl, __fpclassifyl)
+#else
+libm_hidden_def (__fpclassifyl)
+#endif
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_frexpl.c b/sysdeps/ieee754/ldbl-128ibm/s_frexpl.c
new file mode 100644 (file)
index 0000000..fab566d
--- /dev/null
@@ -0,0 +1,92 @@
+/* s_frexpl.c -- long double version of s_frexp.c.
+ * Conversion to IEEE quad long double by Jakub Jelinek, jj@ultra.linux.cz.
+ */
+
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: $";
+#endif
+
+/*
+ * for non-zero x
+ *     x = frexpl(arg,&exp);
+ * return a long double fp quantity x such that 0.5 <= |x| <1.0
+ * and the corresponding binary exponent "exp". That is
+ *     arg = x*2^exp.
+ * If arg is inf, 0.0, or NaN, then frexpl(arg,&exp) returns arg
+ * with *exp=0.
+ */
+
+#include "math.h"
+#include "math_private.h"
+#include <math_ldbl_opt.h>
+
+#ifdef __STDC__
+static const long double
+#else
+static long double
+#endif
+two107 = 162259276829213363391578010288128.0; /* 0x4670000000000000, 0 */
+
+#ifdef __STDC__
+       long double __frexpl(long double x, int *eptr)
+#else
+       long double __frexpl(x, eptr)
+       long double x; int *eptr;
+#endif
+{
+       u_int64_t hx, lx, ix, ixl;
+       int64_t explo;
+       GET_LDOUBLE_WORDS64(hx,lx,x);
+       ixl = 0x7fffffffffffffffULL&lx;
+       ix =  0x7fffffffffffffffULL&hx;
+       *eptr = 0;
+       if(ix>=0x7ff0000000000000ULL||((ix|ixl)==0)) return x;  /* 0,inf,nan */
+       if (ix<0x0010000000000000ULL) {         /* subnormal */
+           x *= two107;
+           GET_LDOUBLE_MSW64(hx,x);
+           ix = hx&0x7fffffffffffffffULL;
+           *eptr = -107;
+       }
+       *eptr += (ix>>52)-1022;
+
+       if (ixl != 0ULL) {
+         explo = (ixl>>52) - (ix>>52) + 0x3fe;
+         if ((ixl&0x7ff0000000000000ULL) == 0LL) {
+           /* the lower double is a denomal so we need to correct its
+              mantissa and perhaps its exponent.  */
+           int cnt;
+
+           if (sizeof (ixl) == sizeof (long))
+             cnt = __builtin_clzl (ixl);
+           else if ((ixl >> 32) != 0)
+             cnt = __builtin_clzl ((long) (ixl >> 32));
+           else
+             cnt = __builtin_clzl ((long) ixl) + 32;
+           cnt = cnt - 12;
+           lx = (lx&0x8000000000000000ULL) | ((explo-cnt)<<52)
+              | ((ixl<<(cnt+1))&0x000fffffffffffffULL);
+         } else
+           lx = (lx&0x800fffffffffffffULL) | (explo<<52);
+       } else
+         lx = 0ULL;
+
+       hx = (hx&0x800fffffffffffffULL) | 0x3fe0000000000000ULL;
+       SET_LDOUBLE_WORDS64(x,hx,lx);
+       return x;
+}
+#ifdef IS_IN_libm
+long_double_symbol (libm, __frexpl, frexpl);
+#else
+long_double_symbol (libc, __frexpl, frexpl);
+#endif
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_ilogbl.c b/sysdeps/ieee754/ldbl-128ibm/s_ilogbl.c
new file mode 100644 (file)
index 0000000..428854d
--- /dev/null
@@ -0,0 +1,63 @@
+/* s_ilogbl.c -- long double version of s_ilogb.c.
+ * Conversion to IEEE quad long double by Jakub Jelinek, jj@ultra.linux.cz.
+ */
+
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: $";
+#endif
+
+/* ilogbl(long double x)
+ * return the binary exponent of non-zero x
+ * ilogbl(0) = FP_ILOGB0
+ * ilogbl(NaN) = FP_ILOGBNAN (no signal is raised)
+ * ilogbl(+-Inf) = INT_MAX (no signal is raised)
+ */
+
+#include <limits.h>
+#include "math.h"
+#include "math_private.h"
+#include <math_ldbl_opt.h>
+
+#ifdef __STDC__
+       int __ilogbl(long double x)
+#else
+       int __ilogbl(x)
+       long double x;
+#endif
+{
+       int64_t hx,lx;
+       int ix;
+
+       GET_LDOUBLE_WORDS64(hx,lx,x);
+       hx &= 0x7fffffffffffffffLL;
+       if(hx <= 0x0010000000000000LL) {
+           if((hx|(lx&0x7fffffffffffffffLL))==0)
+               return FP_ILOGB0;       /* ilogbl(0) = FP_ILOGB0 */
+           else                        /* subnormal x */
+               if(hx==0) {
+                   for (ix = -1043; lx>0; lx<<=1) ix -=1;
+               } else {
+                   for (ix = -1022, hx<<=11; hx>0; hx<<=1) ix -=1;
+               }
+           return ix;
+       }
+       else if (hx<0x7ff0000000000000LL) return (hx>>52)-0x3ff;
+       else if (FP_ILOGBNAN != INT_MAX) {
+           /* ISO C99 requires ilogbl(+-Inf) == INT_MAX.  */
+           if (((hx^0x7ff0000000000000LL)|lx) == 0)
+               return INT_MAX;
+       }
+       return FP_ILOGBNAN;
+}
+long_double_symbol (libm, __ilogbl, ilogbl);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_isinfl.c b/sysdeps/ieee754/ldbl-128ibm/s_isinfl.c
new file mode 100644 (file)
index 0000000..717b574
--- /dev/null
@@ -0,0 +1,35 @@
+/*
+ * Written by J.T. Conklin <jtc@netbsd.org>.
+ * Change for long double by Jakub Jelinek <jj@ultra.linux.cz>
+ * Public domain.
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: $";
+#endif
+
+/*
+ * isinfl(x) returns 1 if x is inf, -1 if x is -inf, else 0;
+ * no branching!
+ */
+
+#include "math.h"
+#include "math_private.h"
+#include <math_ldbl_opt.h>
+
+int
+___isinfl (long double x)
+{
+       int64_t hx,lx;
+       GET_LDOUBLE_WORDS64(hx,lx,x);
+       lx = (lx & 0x7fffffffffffffffLL);
+       lx |= (hx & 0x7fffffffffffffffLL) ^ 0x7ff0000000000000LL;
+       lx |= -lx;
+       return ~(lx >> 63) & (hx >> 62);
+}
+hidden_ver (___isinfl, __isinfl)
+#ifndef IS_IN_libm
+weak_alias (___isinfl, ____isinfl)
+long_double_symbol (libc, ___isinfl, isinfl);
+long_double_symbol (libc, ____isinfl, __isinfl);
+#endif
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_isnanl.c b/sysdeps/ieee754/ldbl-128ibm/s_isnanl.c
new file mode 100644 (file)
index 0000000..ae5ba8e
--- /dev/null
@@ -0,0 +1,43 @@
+/* s_isnanl.c -- long double version of s_isnan.c.
+ * Conversion to long double by Jakub Jelinek, jj@ultra.linux.cz.
+ */
+
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: $";
+#endif
+
+/*
+ * isnanl(x) returns 1 is x is nan, else 0;
+ * no branching!
+ */
+
+#include "math.h"
+#include "math_private.h"
+#include <math_ldbl_opt.h>
+
+int
+___isnanl (long double x)
+{
+       int64_t hx,lx;
+       GET_LDOUBLE_WORDS64(hx,lx,x);
+       hx &= 0x7fffffffffffffffLL;
+       hx = 0x7ff0000000000000LL - hx;
+       return (int)((u_int64_t)hx>>63);
+}
+hidden_ver (___isnanl, __isnanl)
+#ifndef IS_IN_libm
+weak_alias (___isnanl, ____isnanl)
+long_double_symbol (libc, ___isnanl, isnanl);
+long_double_symbol (libc, ____isnanl, __isnanl);
+#endif
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_llrintl.c b/sysdeps/ieee754/ldbl-128ibm/s_llrintl.c
new file mode 100644 (file)
index 0000000..bacf1be
--- /dev/null
@@ -0,0 +1,124 @@
+/* Round to int long double floating-point values.
+   IBM extended format long double version.
+   Copyright (C) 2006 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+/* This has been coded in assembler because GCC makes such a mess of it
+   when it's coded in C.  */
+
+#include <math.h>
+#include <math_ldbl_opt.h>
+#include <float.h>
+#include <ieee754.h>
+
+
+#ifdef __STDC__
+long long
+__llrintl (long double x)
+#else
+long long
+__llrintl (x)
+     long double x;
+#endif
+{
+  static const double TWO52 = 4503599627370496.0L;
+  union ibm_extended_long_double u;
+  long long result = __LONG_LONG_MAX__;
+
+  u.d = x;
+
+  if (fabs (u.dd[0]) < TWO52)
+    {
+      double high = u.dd[0];
+      if (high > 0.0)
+       {
+         high += TWO52;
+         high -= TWO52;
+          if (high == -0.0) high = 0.0;
+       }
+      else if (high < 0.0)
+       {
+         high -= TWO52;
+         high += TWO52;
+          if (high == 0.0) high = -0.0;
+       }
+      result = high;
+    }
+  else if (fabs (u.dd[1]) < TWO52 && u.dd[1] != 0.0)
+    {
+      double high, low, tau;
+      long long lowint;
+      /* In this case we have to round the low double and handle any
+         adjustment to the high double that may be caused by rounding
+         (up).  This is complicated by the fact that the high double
+         may already be rounded and the low double may have the
+         opposite sign to compensate.  */
+      if (u.dd[0] > 0.0)
+       {
+         if (u.dd[1] > 0.0)
+           {
+             /* If the high/low doubles are the same sign then simply
+                round the low double.  */
+             high = u.dd[0];
+             low = u.dd[1];
+           }
+         else if (u.dd[1] < 0.0)
+           {
+             /* Else the high double is pre rounded and we need to
+                adjust for that.  */
+             
+             tau = nextafter (u.dd[0], 0.0);
+             tau =  (u.dd[0] - tau) * 2.0;
+             high = u.dd[0] - tau;
+             low = u.dd[1] + tau;
+           }
+         low += TWO52;
+         low -= TWO52;
+       }
+      else if (u.dd[0] < 0.0)
+       {
+         if (u.dd[1] < 0.0)
+           {
+             /* If the high/low doubles are the same sign then simply
+                round the low double.  */
+             high = u.dd[0];
+             low = u.dd[1];
+           }
+         else if (u.dd[1] > 0.0)
+           {
+             /* Else the high double is pre rounded and we need to
+                adjust for that.  */
+             tau = nextafter (u.dd[0], 0.0);
+             tau = (u.dd[0] - tau) * 2.0;
+             high = u.dd[0] - tau;
+             low = u.dd[1] + tau;
+           }
+         low = TWO52 - low;
+         low = -(low - TWO52);
+       }
+      lowint = low;
+      result = high;
+      result += lowint;
+    }
+  else
+   result = u.dd[0];     
+
+  return result;
+}
+
+long_double_symbol (libm, __llrintl, llrintl);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_llroundl.c b/sysdeps/ieee754/ldbl-128ibm/s_llroundl.c
new file mode 100644 (file)
index 0000000..567e7ec
--- /dev/null
@@ -0,0 +1,128 @@
+/* Round to long long, long double floating-point values.
+   IBM extended format long double version.
+   Copyright (C) 2006 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+/* This has been coded in assembler because GCC makes such a mess of it
+   when it's coded in C.  */
+
+#include <math.h>
+#include <fenv.h>
+#include <math_ldbl_opt.h>
+#include <float.h>
+#include <ieee754.h>
+
+
+#ifdef __STDC__
+long long
+__llroundl (long double x)
+#else
+long long
+__llroundl (x)
+     long double x;
+#endif
+{
+  static const double TWO52 = 4503599627370496.0;
+  static const double HALF = 0.5;
+  int mode = fegetround();
+  union ibm_extended_long_double u;
+  long long result = __LONG_LONG_MAX__;
+
+  u.d = x;
+
+  if (fabs (u.dd[0]) < TWO52)
+    {      
+      fesetround(FE_TOWARDZERO);
+      if (u.dd[0] > 0.0)
+       {
+         u.dd[0] += HALF;
+         u.dd[0] += TWO52;
+         u.dd[0] -= TWO52;
+       }
+      else if (u.dd[0] < 0.0)
+       {
+         u.dd[0] = TWO52 - (u.dd[0] - HALF);
+         u.dd[0] = -(u.dd[0] - TWO52);
+       }
+      fesetround(mode);
+      result = u.dd[0];
+    }
+  else if (fabs (u.dd[1]) < TWO52 && u.dd[1] != 0.0)
+    {
+      double high, low;
+      long long lowint;
+      /* In this case we have to round the low double and handle any
+         adjustment to the high double that may be caused by rounding
+         (up).  This is complicated by the fact that the high double
+         may already be rounded and the low double may have the
+         opposite sign to compensate.  */
+      if (u.dd[0] > 0.0)
+       {
+         if (u.dd[1] > 0.0)
+           {
+             /* If the high/low doubles are the same sign then simply
+                round the low double.  */
+             high = u.dd[0];
+             low = u.dd[1];
+           }
+         else if (u.dd[1] < 0.0)
+           {
+             /* Else the high double is pre rounded and we need to
+                adjust for that.  */
+             high = nextafter (u.dd[0], 0.0);
+             low = u.dd[1] + (u.dd[0] - high);
+           }     
+          fesetround(FE_TOWARDZERO);
+         low += HALF;
+         low += TWO52;
+         low -= TWO52;
+       }
+      else if (u.dd[0] < 0.0)
+       {
+         if (u.dd[1] < 0.0)
+           {
+             /* If the high/low doubles are the same sign then simply
+                round the low double.  */
+             high = u.dd[0];
+             low = u.dd[1];
+           }
+         else if (u.dd[1] > 0.0)
+           {
+             /* Else the high double is pre rounded and we need to
+                adjust for that.  */
+             high = nextafter (u.dd[0], 0.0);
+             low = u.dd[1] + (u.dd[0] - high);
+           }     
+          fesetround(FE_TOWARDZERO);
+         low -= HALF;
+         low = TWO52 - low;
+         low = -(low - TWO52);
+       }
+      fesetround(mode);
+      lowint = low;
+      result = high;
+      result += lowint;
+    }
+  else
+   {
+      result = u.dd[0];     
+   }
+  return result;
+}
+
+long_double_symbol (libm, __llroundl, llroundl);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_log1pl.c b/sysdeps/ieee754/ldbl-128ibm/s_log1pl.c
new file mode 100644 (file)
index 0000000..f1863fb
--- /dev/null
@@ -0,0 +1,257 @@
+/*                                                     log1pl.c
+ *
+ *      Relative error logarithm
+ *     Natural logarithm of 1+x, 128-bit long double precision
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * long double x, y, log1pl();
+ *
+ * y = log1pl( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns the base e (2.718...) logarithm of 1+x.
+ *
+ * The argument 1+x is separated into its exponent and fractional
+ * parts.  If the exponent is between -1 and +1, the logarithm
+ * of the fraction is approximated by
+ *
+ *     log(1+x) = x - 0.5 x^2 + x^3 P(x)/Q(x).
+ *
+ * Otherwise, setting  z = 2(w-1)/(w+1),
+ *
+ *     log(w) = z + z^3 P(z)/Q(z).
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      -1, 8       100000      1.9e-34     4.3e-35
+ */
+
+/* Copyright 2001 by Stephen L. Moshier
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; 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"
+#include <math_ldbl_opt.h>
+
+/* Coefficients for log(1+x) = x - x^2 / 2 + x^3 P(x)/Q(x)
+ * 1/sqrt(2) <= 1+x < sqrt(2)
+ * Theoretical peak relative error = 5.3e-37,
+ * relative peak error spread = 2.3e-14
+ */
+static const long double
+  P12 = 1.538612243596254322971797716843006400388E-6L,
+  P11 = 4.998469661968096229986658302195402690910E-1L,
+  P10 = 2.321125933898420063925789532045674660756E1L,
+  P9 = 4.114517881637811823002128927449878962058E2L,
+  P8 = 3.824952356185897735160588078446136783779E3L,
+  P7 = 2.128857716871515081352991964243375186031E4L,
+  P6 = 7.594356839258970405033155585486712125861E4L,
+  P5 = 1.797628303815655343403735250238293741397E5L,
+  P4 = 2.854829159639697837788887080758954924001E5L,
+  P3 = 3.007007295140399532324943111654767187848E5L,
+  P2 = 2.014652742082537582487669938141683759923E5L,
+  P1 = 7.771154681358524243729929227226708890930E4L,
+  P0 = 1.313572404063446165910279910527789794488E4L,
+  /* Q12 = 1.000000000000000000000000000000000000000E0L, */
+  Q11 = 4.839208193348159620282142911143429644326E1L,
+  Q10 = 9.104928120962988414618126155557301584078E2L,
+  Q9 = 9.147150349299596453976674231612674085381E3L,
+  Q8 = 5.605842085972455027590989944010492125825E4L,
+  Q7 = 2.248234257620569139969141618556349415120E5L,
+  Q6 = 6.132189329546557743179177159925690841200E5L,
+  Q5 = 1.158019977462989115839826904108208787040E6L,
+  Q4 = 1.514882452993549494932585972882995548426E6L,
+  Q3 = 1.347518538384329112529391120390701166528E6L,
+  Q2 = 7.777690340007566932935753241556479363645E5L,
+  Q1 = 2.626900195321832660448791748036714883242E5L,
+  Q0 = 3.940717212190338497730839731583397586124E4L;
+
+/* Coefficients for log(x) = z + z^3 P(z^2)/Q(z^2),
+ * where z = 2(x-1)/(x+1)
+ * 1/sqrt(2) <= x < sqrt(2)
+ * Theoretical peak relative error = 1.1e-35,
+ * relative peak error spread 1.1e-9
+ */
+static const long double
+  R5 = -8.828896441624934385266096344596648080902E-1L,
+  R4 = 8.057002716646055371965756206836056074715E1L,
+  R3 = -2.024301798136027039250415126250455056397E3L,
+  R2 = 2.048819892795278657810231591630928516206E4L,
+  R1 = -8.977257995689735303686582344659576526998E4L,
+  R0 = 1.418134209872192732479751274970992665513E5L,
+  /* S6 = 1.000000000000000000000000000000000000000E0L, */
+  S5 = -1.186359407982897997337150403816839480438E2L,
+  S4 = 3.998526750980007367835804959888064681098E3L,
+  S3 = -5.748542087379434595104154610899551484314E4L,
+  S2 = 4.001557694070773974936904547424676279307E5L,
+  S1 = -1.332535117259762928288745111081235577029E6L,
+  S0 = 1.701761051846631278975701529965589676574E6L;
+
+/* C1 + C2 = ln 2 */
+static const long double C1 = 6.93145751953125E-1L;
+static const long double C2 = 1.428606820309417232121458176568075500134E-6L;
+
+static const long double sqrth = 0.7071067811865475244008443621048490392848L;
+/* ln (2^16384 * (1 - 2^-113)) */
+static const long double maxlog = 1.1356523406294143949491931077970764891253E4L;
+static const long double big = 2e300L;
+static const long double zero = 0.0L;
+
+#if 1
+/* Make sure these are prototyped.  */
+long double frexpl (long double, int *);
+long double ldexpl (long double, int);
+#endif
+
+
+long double
+__log1pl (long double xm1)
+{
+  long double x, y, z, r, s;
+  ieee854_long_double_shape_type u;
+  int32_t hx;
+  int e;
+
+  /* Test for NaN or infinity input. */
+  u.value = xm1;
+  hx = u.parts32.w0;
+  if (hx >= 0x7ff00000)
+    return xm1;
+
+  /* log1p(+- 0) = +- 0.  */
+  if (((hx & 0x7fffffff) == 0)
+      && (u.parts32.w1 | (u.parts32.w2 & 0x7fffffff) | u.parts32.w3) == 0)
+    return xm1;
+
+  x = xm1 + 1.0L;
+
+  /* log1p(-1) = -inf */
+  if (x <= 0.0L)
+    {
+      if (x == 0.0L)
+       return (-1.0L / (x - x));
+      else
+       return (zero / (x - x));
+    }
+
+  /* Separate mantissa from exponent.  */
+
+  /* Use frexp used so that denormal numbers will be handled properly.  */
+  x = frexpl (x, &e);
+
+  /* Logarithm using log(x) = z + z^3 P(z^2)/Q(z^2),
+     where z = 2(x-1)/x+1).  */
+  if ((e > 2) || (e < -2))
+    {
+      if (x < sqrth)
+       {                       /* 2( 2x-1 )/( 2x+1 ) */
+         e -= 1;
+         z = x - 0.5L;
+         y = 0.5L * z + 0.5L;
+       }
+      else
+       {                       /*  2 (x-1)/(x+1)   */
+         z = x - 0.5L;
+         z -= 0.5L;
+         y = 0.5L * x + 0.5L;
+       }
+      x = z / y;
+      z = x * x;
+      r = ((((R5 * z
+             + R4) * z
+            + R3) * z
+           + R2) * z
+          + R1) * z
+       + R0;
+      s = (((((z
+              + S5) * z
+             + S4) * z
+            + S3) * z
+           + S2) * z
+          + S1) * z
+       + S0;
+      z = x * (z * r / s);
+      z = z + e * C2;
+      z = z + x;
+      z = z + e * C1;
+      return (z);
+    }
+
+
+  /* Logarithm using log(1+x) = x - .5x^2 + x^3 P(x)/Q(x). */
+
+  if (x < sqrth)
+    {
+      e -= 1;
+      if (e != 0)
+       x = 2.0L * x - 1.0L;    /*  2x - 1  */
+      else
+       x = xm1;
+    }
+  else
+    {
+      if (e != 0)
+       x = x - 1.0L;
+      else
+       x = xm1;
+    }
+  z = x * x;
+  r = (((((((((((P12 * x
+                + P11) * x
+               + P10) * x
+              + P9) * x
+             + P8) * x
+            + P7) * x
+           + P6) * x
+          + P5) * x
+         + P4) * x
+        + P3) * x
+       + P2) * x
+       + P1) * x
+    + P0;
+  s = (((((((((((x
+                + Q11) * x
+               + Q10) * x
+              + Q9) * x
+             + Q8) * x
+            + Q7) * x
+           + Q6) * x
+          + Q5) * x
+         + Q4) * x
+        + Q3) * x
+       + Q2) * x
+       + Q1) * x
+    + Q0;
+  y = x * (z * r / s);
+  y = y + e * C2;
+  z = y - 0.5L * z;
+  z = z + x;
+  z = z + e * C1;
+  return (z);
+}
+
+long_double_symbol (libm, __log1pl, log1pl);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_logbl.c b/sysdeps/ieee754/ldbl-128ibm/s_logbl.c
new file mode 100644 (file)
index 0000000..0c61cda
--- /dev/null
@@ -0,0 +1,47 @@
+/* s_logbl.c -- long double version of s_logb.c.
+ * Conversion to IEEE quad long double by Jakub Jelinek, jj@ultra.linux.cz.
+ */
+
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: $";
+#endif
+
+/*
+ * long double logbl(x)
+ * IEEE 754 logb. Included to pass IEEE test suite. Not recommend.
+ * Use ilogb instead.
+ */
+
+#include "math.h"
+#include "math_private.h"
+#include <math_ldbl_opt.h>
+
+#ifdef __STDC__
+       long double __logbl(long double x)
+#else
+       long double __logbl(x)
+       long double x;
+#endif
+{
+       int64_t lx,hx;
+       GET_LDOUBLE_WORDS64(hx,lx,x);
+       hx &= 0x7fffffffffffffffLL;             /* high |x| */
+       if((hx|(lx&0x7fffffffffffffffLL))==0) return -1.0/fabs(x);
+       if(hx>=0x7ff0000000000000LL) return x*x;
+       if((hx>>=52)==0)                        /* IEEE 754 logb */
+               return -1022.0;
+       else
+               return (long double) (hx-0x3ff);
+}
+long_double_symbol (libm, __logbl, logbl);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_lrintl.c b/sysdeps/ieee754/ldbl-128ibm/s_lrintl.c
new file mode 100644 (file)
index 0000000..0292475
--- /dev/null
@@ -0,0 +1,9 @@
+/* FIXME */
+#include <math.h>
+#include <math_ldbl_opt.h>
+
+long int __lrintl (long double d)
+{
+  return llrintl (d);
+}
+long_double_symbol (libm, __lrintl, lrintl);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_lroundl.c b/sysdeps/ieee754/ldbl-128ibm/s_lroundl.c
new file mode 100644 (file)
index 0000000..7c5de36
--- /dev/null
@@ -0,0 +1,9 @@
+/* FIXME */
+#include <math.h>
+#include <math_ldbl_opt.h>
+
+long int __lroundl (long double d)
+{
+  return llroundl (d);
+}
+long_double_symbol (libm, __lroundl, lroundl);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_modfl.c b/sysdeps/ieee754/ldbl-128ibm/s_modfl.c
new file mode 100644 (file)
index 0000000..f2e65f0
--- /dev/null
@@ -0,0 +1,94 @@
+/* s_modfl.c -- long double version of s_modf.c.
+ * Conversion to IEEE quad long double by Jakub Jelinek, jj@ultra.linux.cz.
+ */
+
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: $";
+#endif
+
+/*
+ * modfl(long double x, long double *iptr)
+ * return fraction part of x, and return x's integral part in *iptr.
+ * Method:
+ *     Bit twiddling.
+ *
+ * Exception:
+ *     No exception.
+ */
+
+#include "math.h"
+#include "math_private.h"
+#include <math_ldbl_opt.h>
+
+#ifdef __STDC__
+static const long double one = 1.0;
+#else
+static long double one = 1.0;
+#endif
+
+#ifdef __STDC__
+       long double __modfl(long double x, long double *iptr)
+#else
+       long double __modfl(x, iptr)
+       long double x,*iptr;
+#endif
+{
+       int64_t i0,i1,j0;
+       u_int64_t i;
+       GET_LDOUBLE_WORDS64(i0,i1,x);
+       i1 &= 0x000fffffffffffffLL;
+       j0 = ((i0>>52)&0x7ff)-0x3ff;    /* exponent of x */
+       if(j0<52) {                     /* integer part in high x */
+           if(j0<0) {                  /* |x|<1 */
+               /* *iptr = +-0 */
+               SET_LDOUBLE_WORDS64(*iptr,i0&0x8000000000000000ULL,0);
+               return x;
+           } else {
+               i = (0x000fffffffffffffLL)>>j0;
+               if(((i0&i)|(i1&0x7fffffffffffffffLL))==0) {             /* x is integral */
+                   *iptr = x;
+                   /* return +-0 */
+                   SET_LDOUBLE_WORDS64(x,i0&0x8000000000000000ULL,0);
+                   return x;
+               } else {
+                   SET_LDOUBLE_WORDS64(*iptr,i0&(~i),0);
+                   return x - *iptr;
+               }
+           }
+       } else if (j0>103) {            /* no fraction part */
+           *iptr = x*one;
+           /* We must handle NaNs separately.  */
+           if (j0 == 0x400 && ((i0 & 0x000fffffffffffffLL) | i1))
+             return x*one;
+           /* return +-0 */
+           SET_LDOUBLE_WORDS64(x,i0&0x8000000000000000ULL,0);
+           return x;
+       } else {                        /* fraction part in low x */
+           i = -1ULL>>(j0-52);
+           if((i1&i)==0) {             /* x is integral */
+               *iptr = x;
+               /* return +-0 */
+               SET_LDOUBLE_WORDS64(x,i0&0x8000000000000000ULL,0);
+               return x;
+           } else {
+               SET_LDOUBLE_WORDS64(*iptr,i0,i1&(~i));
+               return x - *iptr;
+           }
+       }
+}
+#ifdef IS_IN_libm
+long_double_symbol (libm, __modfl, modfl);
+#else
+long_double_symbol (libc, __modfl, modfl);
+#endif
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_nearbyintl.c b/sysdeps/ieee754/ldbl-128ibm/s_nearbyintl.c
new file mode 100644 (file)
index 0000000..2561fda
--- /dev/null
@@ -0,0 +1,125 @@
+/* Round to int long double floating-point values without raising inexact.
+   IBM extended format long double version.
+   Copyright (C) 2006 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+/* This has been coded in assembler because GCC makes such a mess of it
+   when it's coded in C.  */
+
+#include <math.h>
+#include <fenv.h>
+#include <math_ldbl_opt.h>
+#include <float.h>
+#include <ieee754.h>
+
+
+#ifdef __STDC__
+long double
+__nearbyintl (long double x)
+#else
+long double
+__nearbyintl (x)
+     long double x;
+#endif
+{
+  fenv_t env;
+  static const long double TWO52 = 4503599627370496.0L;
+  union ibm_extended_long_double u;
+  u.d = x;
+
+  if (fabs (u.dd[0]) < TWO52)
+    {
+      double high = u.dd[0];
+      feholdexcept (&env);
+      if (high > 0.0)
+       {
+         high += TWO52;
+         high -= TWO52;
+          if (high == -0.0) high = 0.0;
+       }
+      else if (high < 0.0)
+       {
+         high -= TWO52;
+         high += TWO52;
+          if (high == 0.0) high = -0.0;
+       }
+      u.dd[0] = high;
+      u.dd[1] = 0.0;
+      fesetenv (&env);
+    }
+  else if (fabs (u.dd[1]) < TWO52 && u.dd[1] != 0.0)
+    {
+      double high, low, tau;
+      /* In this case we have to round the low double and handle any
+         adjustment to the high double that may be caused by rounding
+         (up).  This is complicated by the fact that the high double
+         may already be rounded and the low double may have the
+         opposite sign to compensate.  */
+      feholdexcept (&env);
+      if (u.dd[0] > 0.0)
+       {
+         if (u.dd[1] > 0.0)
+           {
+             /* If the high/low doubles are the same sign then simply
+                round the low double.  */
+             high = u.dd[0];
+             low = u.dd[1];
+           }
+         else if (u.dd[1] < 0.0)
+           {
+             /* Else the high double is pre rounded and we need to
+                adjust for that.  */
+             
+             tau = nextafter (u.dd[0], 0.0);
+             tau = (u.dd[0] - tau) * 2.0;
+             high = u.dd[0] - tau;
+             low = u.dd[1] + tau;
+           }
+         low += TWO52;
+         low -= TWO52;
+       }
+      else if (u.dd[0] < 0.0)
+       {
+         if (u.dd[1] < 0.0)
+           {
+             /* If the high/low doubles are the same sign then simply
+                round the low double.  */
+             high = u.dd[0];
+             low = u.dd[1];
+           }
+         else if (u.dd[1] > 0.0)
+           {
+             /* Else the high double is pre rounded and we need to
+                adjust for that.  */
+             tau = nextafter (u.dd[0], 0.0);
+             tau = (u.dd[0] - tau) * 2.0;
+             high = u.dd[0] - tau;
+             low = u.dd[1] + tau;
+           }
+         low = TWO52 - low;
+         low = -(low - TWO52);
+       }
+      u.dd[0] = high + low;
+      u.dd[1] = high - u.dd[0] + low;
+      fesetenv (&env);
+    }
+
+  return u.d;
+}
+
+long_double_symbol (libm, __nearbyintl, nearbyintl);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_nextafterl.c b/sysdeps/ieee754/ldbl-128ibm/s_nextafterl.c
new file mode 100644 (file)
index 0000000..e35ce50
--- /dev/null
@@ -0,0 +1,108 @@
+/* s_nextafterl.c -- long double version of s_nextafter.c.
+ * Conversion to IEEE quad long double by Jakub Jelinek, jj@ultra.linux.cz.
+ */
+
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: $";
+#endif
+
+/* IEEE functions
+ *     nextafterl(x,y)
+ *     return the next machine floating-point number of x in the
+ *     direction toward y.
+ *   Special cases:
+ */
+
+#include "math.h"
+#include "math_private.h"
+#include <math_ldbl_opt.h>
+
+#ifdef __STDC__
+       long double __nextafterl(long double x, long double y)
+#else
+       long double __nextafterl(x,y)
+       long double x,y;
+#endif
+{
+       int64_t hx,hy,ihx,ihy,ilx,ily;
+       u_int64_t lx,ly;
+
+       GET_LDOUBLE_WORDS64(hx,lx,x);
+       GET_LDOUBLE_WORDS64(hy,ly,y);
+       ihx = hx&0x7fffffffffffffffLL;          /* |hx| */
+       ilx = lx&0x7fffffffffffffffLL;          /* |lx| */
+       ihy = hy&0x7fffffffffffffffLL;          /* |hy| */
+       ily = ly&0x7fffffffffffffffLL;          /* |ly| */
+
+       if((((ihx&0x7ff0000000000000LL)==0x7ff0000000000000LL)&&
+           ((ihx&0x000fffffffffffffLL)!=0)) ||   /* x is nan */
+          (((ihy&0x7ff0000000000000LL)==0x7ff0000000000000LL)&&
+           ((ihy&0x000fffffffffffffLL)!=0)))     /* y is nan */
+           return x+y; /* signal the nan */
+       if(x==y)
+           return y;           /* x=y, return y */
+       if(ihx == 0 && ilx == 0) {                      /* x == 0 */
+           SET_LDOUBLE_WORDS64(x,hy&0x8000000000000000ULL,1);/* return +-minsubnormal */
+           y = x*x;
+           if(y==x) return y; else return x;   /* raise underflow flag */
+       }
+       if(ihx>=0) {                    /* x > 0 */
+           if(ihx>ihy||((ihx==ihy)&&(ilx>ily))) {      /* x > y, x -= ulp */
+
+               if(ilx==0)
+                   hx--;
+               else
+                   lx--;
+           } else {                            /* x < y, x += ulp */
+               if((hx==0x7fefffffffffffffLL)&&(lx==0x7c8ffffffffffffeLL))
+                 {
+                   SET_LDOUBLE_WORDS64(x,0x7ff0000000000000,0x8000000000000000);
+                   return x;
+                 }
+               else if((hx==0xffefffffffffffffLL)&&(lx==0xfc8ffffffffffffeLL))
+                 {
+                   SET_LDOUBLE_WORDS64(x,0xfff0000000000000,0x8000000000000000);
+                   return x;
+                 }
+               else if((lx&0x7fffffffffffffff)==0) hx++;
+               else
+                 lx++;
+           }
+       } else {                                /* x < 0 */
+           if(ihy>=0||ihx>ihy||((ihx==ihy)&&(ilx>ily))){/* x < y, x -= ulp */
+               if((lx&0x7fffffffffffffff)==0)
+                   hx--;
+               else
+                   lx--;
+           } else {                            /* x > y, x += ulp */
+               if((lx&0x7fffffffffffffff)==0) hx++;
+               else
+                 lx++;
+           }
+       }
+       hy = hx&0x7ff0000000000000LL;
+       if(hy==0x7ff0000000000000LL) return x+x;/* overflow  */
+       if(hy==0) {                             /* underflow */
+           y = x*x;
+           if(y!=x) {          /* raise underflow flag */
+               SET_LDOUBLE_WORDS64(y,hx,lx);
+               return y;
+           }
+       }
+       SET_LDOUBLE_WORDS64(x,hx,lx);
+       return x;
+}
+strong_alias (__nextafterl, __nexttowardl)
+long_double_symbol (libm, __nextafterl, nextafterl);
+long_double_symbol (libm, __nexttowardl, nexttowardl);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_nexttoward.c b/sysdeps/ieee754/ldbl-128ibm/s_nexttoward.c
new file mode 100644 (file)
index 0000000..3335100
--- /dev/null
@@ -0,0 +1,106 @@
+/* s_nexttoward.c
+ * Conversion from s_nextafter.c by Ulrich Drepper, Cygnus Support,
+ * drepper@cygnus.com and Jakub Jelinek, jj@ultra.linux.cz.
+ */
+
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: $";
+#endif
+
+/* IEEE functions
+ *     nexttoward(x,y)
+ *     return the next machine floating-point number of x in the
+ *     direction toward y.
+ *   Special cases:
+ */
+
+#include "math.h"
+#include "math_private.h"
+#include <math_ldbl_opt.h>
+#include <float.h>
+
+#ifdef __STDC__
+       double __nexttoward(double x, long double y)
+#else
+       double __nexttoward(x,y)
+       double x;
+       long double y;
+#endif
+{
+       int32_t hx,ix;
+       int64_t hy,iy;
+       u_int32_t lx;
+       u_int64_t ly,uly;
+
+       EXTRACT_WORDS(hx,lx,x);
+       GET_LDOUBLE_WORDS64(hy,ly,y);
+       ix = hx&0x7fffffff;             /* |x| */
+       iy = hy&0x7fffffffffffffffLL;   /* |y| */
+       uly = ly&0x7fffffffffffffffLL;  /* |y| */
+
+       if(((ix>=0x7ff00000)&&((ix-0x7ff00000)|lx)!=0) ||   /* x is nan */
+          ((iy>=0x7ff0000000000000LL)&&((iy-0x7ff0000000000000LL)|uly)!=0))
+                                                           /* y is nan */
+          return x+y;
+       if((long double) x==y) return y;        /* x=y, return y */
+       if((ix|lx)==0) {                        /* x == 0 */
+           double x2;
+           INSERT_WORDS(x,(u_int32_t)((hy>>32)&0x80000000),1);/* return +-minsub */
+           x2 = x*x;
+           if(x2==x) return x2; else return x; /* raise underflow flag */
+       }
+       if(hx>=0) {                             /* x > 0 */
+           if (hy<0||(ix>>20)>(iy>>52)
+               || ((ix>>20)==(iy>>52)
+                   && (((((int64_t)hx)<<32)|(lx))>(hy&0x000fffffffffffffLL)
+                       || (((((int64_t)hx)<<32)|(lx))==(hy&0x000fffffffffffffLL)
+                           )))) {      /* x > y, x -= ulp */
+               if(lx==0) hx -= 1;
+               lx -= 1;
+           } else {                            /* x < y, x += ulp */
+               lx += 1;
+               if(lx==0) hx += 1;
+           }
+       } else {                                /* x < 0 */
+           if (hy>=0||(ix>>20)>(iy>>52)
+               || ((ix>>20)==(iy>>52)
+                   && (((((int64_t)hx)<<32)|(lx))>(hy&0x000fffffffffffffLL)
+                       || (((((int64_t)hx)<<32)|(lx))==(hy&0x000fffffffffffffLL)
+                          )))) {       /* x < y, x -= ulp */
+               if(lx==0) hx -= 1;
+               lx -= 1;
+           } else {                            /* x > y, x += ulp */
+               lx += 1;
+               if(lx==0) hx += 1;
+           }
+       }
+       hy = hx&0x7ff00000;
+       if(hy>=0x7ff00000) {
+         x = x+x;      /* overflow  */
+         if (FLT_EVAL_METHOD != 0 && FLT_EVAL_METHOD != 1)
+           /* Force conversion to float.  */
+           asm ("" : "=m"(x) : "m"(x));
+         return x;
+       }
+       if(hy<0x00100000) {             /* underflow */
+           double x2 = x*x;
+           if(x2!=x) {         /* raise underflow flag */
+               INSERT_WORDS(x2,hx,lx);
+               return x2;
+           }
+       }
+       INSERT_WORDS(x,hx,lx);
+       return x;
+}
+long_double_symbol (libm, __nexttoward, nexttoward);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_nexttowardf.c b/sysdeps/ieee754/ldbl-128ibm/s_nexttowardf.c
new file mode 100644 (file)
index 0000000..a9373ff
--- /dev/null
@@ -0,0 +1,83 @@
+/* s_nexttowardf.c -- float version of s_nextafter.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com
+ * and Jakub Jelinek, jj@ultra.linux.cz.
+ */
+
+/*
+ * ====================================================
+ * 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.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: $";
+#endif
+
+#include "math.h"
+#include "math_private.h"
+#include <math_ldbl_opt.h>
+
+#ifdef __STDC__
+       float __nexttowardf(float x, long double y)
+#else
+       float __nexttowardf(x,y)
+       float x;
+       long double y;
+#endif
+{
+       int32_t hx,ix;
+       int64_t hy,iy;
+       u_int64_t ly, uly;
+
+       GET_FLOAT_WORD(hx,x);
+       GET_LDOUBLE_WORDS64(hy,ly,y);
+       ix = hx&0x7fffffff;             /* |x| */
+       iy = hy&0x7fffffffffffffffLL;   /* |y| */
+       uly = ly&0x7fffffffffffffffLL;  /* |y| */
+
+       if((ix>0x7f800000) ||   /* x is nan */
+          ((iy>=0x7ff0000000000000LL)&&((iy-0x7ff0000000000000LL)|uly)!=0))
+                               /* y is nan */
+          return x+y;
+       if((long double) x==y) return y;        /* x=y, return y */
+       if(ix==0) {                             /* x == 0 */
+           float x2;
+           SET_FLOAT_WORD(x,(u_int32_t)((hy>>32)&0x80000000)|1);/* return +-minsub*/
+           x2 = x*x;
+           if(x2==x) return x2; else return x; /* raise underflow flag */
+       }
+       if(hx>=0) {                             /* x > 0 */
+           if(hy<0||(ix>>23)>(iy>>52)-0x380
+              || ((ix>>23)==(iy>>52)-0x380
+                  && (ix&0x7fffff)>((hy>>29)&0x7fffff))) {/* x > y, x -= ulp */
+               hx -= 1;
+           } else {                            /* x < y, x += ulp */
+               hx += 1;
+           }
+       } else {                                /* x < 0 */
+           if(hy>=0||(ix>>23)>(iy>>52)-0x380
+              || ((ix>>23)==(iy>>52)-0x380
+                  && (ix&0x7fffff)>((hy>>29)&0x7fffff))) {/* x < y, x -= ulp */
+               hx -= 1;
+           } else {                            /* x > y, x += ulp */
+               hx += 1;
+           }
+       }
+       hy = hx&0x7f800000;
+       if(hy>=0x7f800000) return x+x;  /* overflow  */
+       if(hy<0x00800000) {             /* underflow */
+           float x2 = x*x;
+           if(x2!=x) {         /* raise underflow flag */
+               SET_FLOAT_WORD(x2,hx);
+               return x2;
+           }
+       }
+       SET_FLOAT_WORD(x,hx);
+       return x;
+}
+long_double_symbol (libm, __nexttowardf, nexttowardf);
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_remquol.c b/sysdeps/ieee754/ldbl-128ibm/s_remquol.c
new file mode 100644 (file)
index 0000000..ca504a0
--- /dev/null
@@ -0,0 +1,111 @@
+/* Compute remainder and a congruent to the quotient.
+   Copyright (C) 1997,1999,2002,2004,2006 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997 and
+                 Jakub Jelinek <jj@ultra.linux.cz>, 1999.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either