- remove isinff, isnanf. this has been moved to libc

- remove never-enabled signbit.  libc has is now
- add C99 implementations, from freebsd, for nan(), nanf() (needed
to write _digittoint for it), exp2(), exp2f(), remquo(), remquof(),
needed STRICT_ASSIGN macro for math_private.h
- bump major
man pages will follow
exp2{,f} has been requested by chl@
ok millert@

diff --git a/lib/libm/Makefile b/lib/libm/Makefile
index 18754d3..3c4c1ca 100644 (file)
--- a/lib/libm/Makefile
+++ b/lib/libm/Makefile
@@ -1,5 +1,5 @@
 #  $NetBSD: Makefile,v 1.28 1995/11/20 22:06:19 jtc Exp $
-#  $OpenBSD: Makefile,v 1.48 2008/07/21 20:30:35 martynas Exp $
+#  $OpenBSD: Makefile,v 1.49 2008/07/24 09:40:16 martynas Exp $
 #
 #  @(#)Makefile 5.1beta 93/09/24 
 # 
@@ -113,12 +113,13 @@ COMMON_SRCS = b_exp__D.c b_log__D.c b_tgamma.c \
        s_lround.c s_lroundf.c s_llround.c s_llroundf.c \
        s_asinh.c s_asinhf.c s_atan.c s_atanf.c s_cbrt.c s_cbrtf.c s_ceil.c \
        s_ceilf.c s_copysign.c s_copysignf.c s_cos.c s_cosf.c s_erf.c s_erff.c \
-       s_expm1.c s_expm1f.c s_fabsf.c s_finite.c s_finitef.c \
+       s_exp2.c s_exp2f.c s_expm1.c s_expm1f.c s_fabsf.c s_finite.c s_finitef.c \
        s_floor.c s_floorf.c s_frexpf.c s_ilogb.c s_ilogbf.c \
-       s_isinff.c s_isnanf.c s_ldexpf.c s_lib_version.c s_log1p.c \
+       s_ldexpf.c s_lib_version.c s_log1p.c \
        s_log1pf.c s_logb.c s_logbf.c s_llrint.c s_llrintf.c s_lrint.c \
-       s_lrintf.c s_matherr.c s_modff.c \
-       s_nextafter.c s_nextafterf.c s_rint.c s_rintf.c s_round.c s_roundf.c \
+       s_lrintf.c s_matherr.c s_modff.c s_nan.c \
+       s_nextafter.c s_nextafterf.c s_remquo.c s_remquof.c s_rint.c \
+       s_rintf.c s_round.c s_roundf.c \
        s_scalbn.c s_scalbnf.c s_signgam.c s_significand.c s_significandf.c \
        s_sin.c s_sinf.c s_tan.c s_tanf.c s_tanh.c s_tanhf.c s_trunc.c s_truncf.c \
        w_acos.c w_acosf.c w_acosh.c w_acoshf.c w_asin.c w_asinf.c w_atan2.c \
@@ -140,7 +141,8 @@ NOIEEE_SRCS = n_asincos.c n_acosh.c n_asinh.c n_atan.c n_atanh.c n_cosh.c \
 
 
 # OpenBSD's C library supplies these functions:
-#COMMON_SRCS+= s_fabs.c s_frexp.c s_isinf.c s_isnan.c s_ldexp.c s_modf.c
+#COMMON_SRCS+= s_fabs.c s_frexp.c s_isinf.c s_isinff.c s_isnan.c s_isnanf.c \
+#              s_ldexp.c s_modf.c
 
 .if (${MACHINE_ARCH} == "vax")
 SRCS=  ${NOIEEE_SRCS} ${NOIEEE_ARCH}

diff --git a/lib/libm/arch/amd64/s_signbitl_e.c b/lib/libm/arch/amd64/s_signbitl_e.c
deleted file mode 100644 (file)
index 110377a..0000000
--- a/lib/libm/arch/amd64/s_signbitl_e.c
+++ /dev/null
@@ -1,19 +0,0 @@
-/*     $OpenBSD: s_signbitl_e.c,v 1.1 2007/06/01 05:56:50 jason Exp $  */
-
-/*
- * Written by Jason L. Wright (jason@thought.net) in 2007 and placed
- * into the public domain.
- */
-
-#include "math.h"
-#include "math_private.h"
-
-/* __signbitl for extended long double */
-
-int
-__signbitl(long double l)
-{
-       ieee_quad_shape_type e;
-       e.value = l;
-       return (e.parts.mswlo & 0x8000);
-}

diff --git a/lib/libm/arch/i387/s_signbitl_e.c b/lib/libm/arch/i387/s_signbitl_e.c
deleted file mode 100644 (file)
index a21c45e..0000000
--- a/lib/libm/arch/i387/s_signbitl_e.c
+++ /dev/null
@@ -1,19 +0,0 @@
-/*     $OpenBSD: s_signbitl_e.c,v 1.1 2007/06/01 05:52:42 jason Exp $  */
-
-/*
- * Written by Jason L. Wright (jason@thought.net) in 2007 and placed
- * into the public domain.
- */
-
-#include "math.h"
-#include "math_private.h"
-
-/* __signbitl for extended long double */
-
-int
-__signbitl(long double l)
-{
-       ieee_extended_shape_type e;
-       e.value = l;
-       return (e.parts.msw & 0x8000);
-}

diff --git a/lib/libm/arch/mc68881/s_signbitl_e.c b/lib/libm/arch/mc68881/s_signbitl_e.c
deleted file mode 100644 (file)
index 2824f4e..0000000
--- a/lib/libm/arch/mc68881/s_signbitl_e.c
+++ /dev/null
@@ -1,19 +0,0 @@
-/*     $OpenBSD: s_signbitl_e.c,v 1.1 2007/06/01 05:53:27 jason Exp $  */
-
-/*
- * Written by Jason L. Wright (jason@thought.net) in 2007 and placed
- * into the public domain.
- */
-
-#include "math.h"
-#include "math_private.h"
-
-/* __signbitl for extended long double */
-
-int
-__signbitl(long double l)
-{
-       ieee_extended_shape_type e;
-       e.value = l;
-       return (e.parts.msw & 0x80000000);
-}

diff --git a/lib/libm/arch/vax/n_support.S b/lib/libm/arch/vax/n_support.S
index 7b1ef84..7c3dcda 100644 (file)
--- a/lib/libm/arch/vax/n_support.S
+++ b/lib/libm/arch/vax/n_support.S
@@ -1,4 +1,4 @@
-/*     $OpenBSD: n_support.S,v 1.11 2008/06/21 08:26:19 martynas Exp $ */
+/*     $OpenBSD: n_support.S,v 1.12 2008/07/24 09:40:16 martynas Exp $ */
 /*     $NetBSD: n_support.S,v 1.1 1995/10/10 23:40:30 ragge Exp $      */
 /*
  * Copyright (c) 1985, 1993
@@ -40,8 +40,6 @@
  * scalbn(x,N),
  * finite(x),
  * remainder(x,y),
- * isinff(x),
- * isnanf(x),
  * Coded in vax assembly language by K.C. Ng,  3/14/85.
  * Revised by K.C. Ng on 4/9/85.
  */
@@ -209,34 +207,3 @@ Rop:                                       #Reserved operand
 Ret:
        movq    $0x8000,r0              #propagate reserved op
        ret
-
-/*
- * int
- * isinff(float x)
- */
-
-ENTRY(isinff, 0)
-       clrl    r0
-       ret
-
-/*
- * int
- * isnanf(float x)
- */
-        
-ENTRY(isnanf, 0)
-       clrl    r0
-       ret
-
-/*
- * signbit(x), signbitl(x), signbitf(x) -- returns zero if x is
- *    non-negative.
- */
-       _ALIGN_TEXT
-ALTENTRY(__signbitf)
-ALTENTRY(__signbitl)
-ENTRY(__signbit, 0)
-        movw 4(ap), r0
-        bicl2 $-32769,r0
-        ret
-

diff --git a/lib/libm/noieee_src/n_support.c b/lib/libm/noieee_src/n_support.c
index c0aa3dc..63c6706 100644 (file)
--- a/lib/libm/noieee_src/n_support.c
+++ b/lib/libm/noieee_src/n_support.c
@@ -1,4 +1,4 @@
-/*     $OpenBSD: n_support.c,v 1.14 2008/07/18 13:08:58 martynas Exp $ */
+/*     $OpenBSD: n_support.c,v 1.15 2008/07/24 09:40:16 martynas Exp $ */
 /*     $NetBSD: n_support.c,v 1.1 1995/10/10 23:37:06 ragge Exp $      */
 /*
  * Copyright (c) 1985, 1993
@@ -137,30 +137,6 @@ copysign(double x, double y)
         return(x);
 }
 
-int
-__signbitf(float x)
-{
-       unsigned short *px = (unsigned short *)&x;
-
-       return (*px & ~msign);
-}
-
-int
-__signbit(double x)
-{
-       unsigned short *px = (unsigned short *)&x;
-
-       return (*px & ~msign);
-}
-
-int
-__signbitl(long double x)
-{
-       unsigned short *px = (unsigned short *)&x;
-
-       return (*px & ~msign);
-}
-
 double
 logb(double x)
 {

diff --git a/lib/libm/shlib_version b/lib/libm/shlib_version
index c87e1c6..012c141 100644 (file)
--- a/lib/libm/shlib_version
+++ b/lib/libm/shlib_version
@@ -1,2 +1,2 @@
-major=2
-minor=4
+major=3
+minor=0

diff --git a/lib/libm/src/math_private.h b/lib/libm/src/math_private.h
index 59382ba..cdfd07a 100644 (file)
--- a/lib/libm/src/math_private.h
+++ b/lib/libm/src/math_private.h
@@ -1,4 +1,4 @@
-/*     $OpenBSD: math_private.h,v 1.8 2008/06/11 20:53:27 martynas Exp $       */
+/*     $OpenBSD: math_private.h,v 1.9 2008/07/24 09:40:16 martynas Exp $       */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
@@ -193,6 +193,26 @@ do {                                                               \
   (d) = sf_u.value;                                            \
 } while (0)
 
+#ifdef FLT_EVAL_METHOD
+/*
+ * Attempt to get strict C99 semantics for assignment with non-C99 compilers.
+ */
+#if FLT_EVAL_METHOD == 0 || __GNUC__ == 0
+#define        STRICT_ASSIGN(type, lval, rval) ((lval) = (rval))
+#else
+#define        STRICT_ASSIGN(type, lval, rval) do {    \
+       volatile type __lval;                   \
+                                               \
+       if (sizeof(type) >= sizeof(double))     \
+               (lval) = (rval);                \
+       else {                                  \
+               __lval = (rval);                \
+               (lval) = __lval;                \
+       }                                       \
+} while (0)
+#endif
+#endif
+
 /* ieee style elementary functions */
 extern double __ieee754_sqrt(double);
 extern double __ieee754_acos(double);

diff --git a/lib/libm/src/s_exp2.c b/lib/libm/src/s_exp2.c
new file mode 100644 (file)
index 0000000..0a864a4
--- /dev/null
+++ b/lib/libm/src/s_exp2.c
@@ -0,0 +1,391 @@
+/*     $OpenBSD: s_exp2.c,v 1.1 2008/07/24 09:40:16 martynas Exp $     */
+/*-
+ * Copyright (c) 2005 David Schultz <das@FreeBSD.ORG>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+#include <float.h>
+
+#include "math.h"
+#include "math_private.h"
+
+#define        TBLBITS 8
+#define        TBLSIZE (1 << TBLBITS)
+
+static const double
+    huge     = 0x1p1000,
+    redux    = 0x1.8p52 / TBLSIZE,
+    P1      = 0x1.62e42fefa39efp-1,
+    P2      = 0x1.ebfbdff82c575p-3,
+    P3      = 0x1.c6b08d704a0a6p-5,
+    P4      = 0x1.3b2ab88f70400p-7,
+    P5      = 0x1.5d88003875c74p-10;
+
+static volatile double twom1000 = 0x1p-1000;
+
+static const double tbl[TBLSIZE * 2] = {
+/*     exp2(z + eps)           eps     */
+       0x1.6a09e667f3d5dp-1,    0x1.9880p-44,
+       0x1.6b052fa751744p-1,    0x1.8000p-50,
+       0x1.6c012750bd9fep-1,   -0x1.8780p-45,
+       0x1.6cfdcddd476bfp-1,    0x1.ec00p-46,
+       0x1.6dfb23c651a29p-1,   -0x1.8000p-50,
+       0x1.6ef9298593ae3p-1,   -0x1.c000p-52,
+       0x1.6ff7df9519386p-1,   -0x1.fd80p-45,
+       0x1.70f7466f42da3p-1,   -0x1.c880p-45,
+       0x1.71f75e8ec5fc3p-1,    0x1.3c00p-46,
+       0x1.72f8286eacf05p-1,   -0x1.8300p-44,
+       0x1.73f9a48a58152p-1,   -0x1.0c00p-47,
+       0x1.74fbd35d7ccfcp-1,    0x1.f880p-45,
+       0x1.75feb564267f1p-1,    0x1.3e00p-47,
+       0x1.77024b1ab6d48p-1,   -0x1.7d00p-45,
+       0x1.780694fde5d38p-1,   -0x1.d000p-50,
+       0x1.790b938ac1d00p-1,    0x1.3000p-49,
+       0x1.7a11473eb0178p-1,   -0x1.d000p-49,
+       0x1.7b17b0976d060p-1,    0x1.0400p-45,
+       0x1.7c1ed0130c133p-1,    0x1.0000p-53,
+       0x1.7d26a62ff8636p-1,   -0x1.6900p-45,
+       0x1.7e2f336cf4e3bp-1,   -0x1.2e00p-47,
+       0x1.7f3878491c3e8p-1,   -0x1.4580p-45,
+       0x1.80427543e1b4ep-1,    0x1.3000p-44,
+       0x1.814d2add1071ap-1,    0x1.f000p-47,
+       0x1.82589994ccd7ep-1,   -0x1.1c00p-45,
+       0x1.8364c1eb942d0p-1,    0x1.9d00p-45,
+       0x1.8471a4623cab5p-1,    0x1.7100p-43,
+       0x1.857f4179f5bbcp-1,    0x1.2600p-45,
+       0x1.868d99b4491afp-1,   -0x1.2c40p-44,
+       0x1.879cad931a395p-1,   -0x1.3000p-45,
+       0x1.88ac7d98a65b8p-1,   -0x1.a800p-45,
+       0x1.89bd0a4785800p-1,   -0x1.d000p-49,
+       0x1.8ace5422aa223p-1,    0x1.3280p-44,
+       0x1.8be05bad619fap-1,    0x1.2b40p-43,
+       0x1.8cf3216b54383p-1,   -0x1.ed00p-45,
+       0x1.8e06a5e08664cp-1,   -0x1.0500p-45,
+       0x1.8f1ae99157807p-1,    0x1.8280p-45,
+       0x1.902fed0282c0ep-1,   -0x1.cb00p-46,
+       0x1.9145b0b91ff96p-1,   -0x1.5e00p-47,
+       0x1.925c353aa2ff9p-1,    0x1.5400p-48,
+       0x1.93737b0cdc64ap-1,    0x1.7200p-46,
+       0x1.948b82b5f98aep-1,   -0x1.9000p-47,
+       0x1.95a44cbc852cbp-1,    0x1.5680p-45,
+       0x1.96bdd9a766f21p-1,   -0x1.6d00p-44,
+       0x1.97d829fde4e2ap-1,   -0x1.1000p-47,
+       0x1.98f33e47a23a3p-1,    0x1.d000p-45,
+       0x1.9a0f170ca0604p-1,   -0x1.8a40p-44,
+       0x1.9b2bb4d53ff89p-1,    0x1.55c0p-44,
+       0x1.9c49182a3f15bp-1,    0x1.6b80p-45,
+       0x1.9d674194bb8c5p-1,   -0x1.c000p-49,
+       0x1.9e86319e3238ep-1,    0x1.7d00p-46,
+       0x1.9fa5e8d07f302p-1,    0x1.6400p-46,
+       0x1.a0c667b5de54dp-1,   -0x1.5000p-48,
+       0x1.a1e7aed8eb8f6p-1,    0x1.9e00p-47,
+       0x1.a309bec4a2e27p-1,    0x1.ad80p-45,
+       0x1.a42c980460a5dp-1,   -0x1.af00p-46,
+       0x1.a5503b23e259bp-1,    0x1.b600p-47,
+       0x1.a674a8af46213p-1,    0x1.8880p-44,
+       0x1.a799e1330b3a7p-1,    0x1.1200p-46,
+       0x1.a8bfe53c12e8dp-1,    0x1.6c00p-47,
+       0x1.a9e6b5579fcd2p-1,   -0x1.9b80p-45,
+       0x1.ab0e521356fb8p-1,    0x1.b700p-45,
+       0x1.ac36bbfd3f381p-1,    0x1.9000p-50,
+       0x1.ad5ff3a3c2780p-1,    0x1.4000p-49,
+       0x1.ae89f995ad2a3p-1,   -0x1.c900p-45,
+       0x1.afb4ce622f367p-1,    0x1.6500p-46,
+       0x1.b0e07298db790p-1,    0x1.fd40p-45,
+       0x1.b20ce6c9a89a9p-1,    0x1.2700p-46,
+       0x1.b33a2b84f1a4bp-1,    0x1.d470p-43,
+       0x1.b468415b747e7p-1,   -0x1.8380p-44,
+       0x1.b59728de5593ap-1,    0x1.8000p-54,
+       0x1.b6c6e29f1c56ap-1,    0x1.ad00p-47,
+       0x1.b7f76f2fb5e50p-1,    0x1.e800p-50,
+       0x1.b928cf22749b2p-1,   -0x1.4c00p-47,
+       0x1.ba5b030a10603p-1,   -0x1.d700p-47,
+       0x1.bb8e0b79a6f66p-1,    0x1.d900p-47,
+       0x1.bcc1e904bc1ffp-1,    0x1.2a00p-47,
+       0x1.bdf69c3f3a16fp-1,   -0x1.f780p-46,
+       0x1.bf2c25bd71db8p-1,   -0x1.0a00p-46,
+       0x1.c06286141b2e9p-1,   -0x1.1400p-46,
+       0x1.c199bdd8552e0p-1,    0x1.be00p-47,
+       0x1.c2d1cd9fa64eep-1,   -0x1.9400p-47,
+       0x1.c40ab5fffd02fp-1,   -0x1.ed00p-47,
+       0x1.c544778fafd15p-1,    0x1.9660p-44,
+       0x1.c67f12e57d0cbp-1,   -0x1.a100p-46,
+       0x1.c7ba88988c1b6p-1,   -0x1.8458p-42,
+       0x1.c8f6d9406e733p-1,   -0x1.a480p-46,
+       0x1.ca3405751c4dfp-1,    0x1.b000p-51,
+       0x1.cb720dcef9094p-1,    0x1.1400p-47,
+       0x1.ccb0f2e6d1689p-1,    0x1.0200p-48,
+       0x1.cdf0b555dc412p-1,    0x1.3600p-48,
+       0x1.cf3155b5bab3bp-1,   -0x1.6900p-47,
+       0x1.d072d4a0789bcp-1,    0x1.9a00p-47,
+       0x1.d1b532b08c8fap-1,   -0x1.5e00p-46,
+       0x1.d2f87080d8a85p-1,    0x1.d280p-46,
+       0x1.d43c8eacaa203p-1,    0x1.1a00p-47,
+       0x1.d5818dcfba491p-1,    0x1.f000p-50,
+       0x1.d6c76e862e6a1p-1,   -0x1.3a00p-47,
+       0x1.d80e316c9834ep-1,   -0x1.cd80p-47,
+       0x1.d955d71ff6090p-1,    0x1.4c00p-48,
+       0x1.da9e603db32aep-1,    0x1.f900p-48,
+       0x1.dbe7cd63a8325p-1,    0x1.9800p-49,
+       0x1.dd321f301b445p-1,   -0x1.5200p-48,
+       0x1.de7d5641c05bfp-1,   -0x1.d700p-46,
+       0x1.dfc97337b9aecp-1,   -0x1.6140p-46,
+       0x1.e11676b197d5ep-1,    0x1.b480p-47,
+       0x1.e264614f5a3e7p-1,    0x1.0ce0p-43,
+       0x1.e3b333b16ee5cp-1,    0x1.c680p-47,
+       0x1.e502ee78b3fb4p-1,   -0x1.9300p-47,
+       0x1.e653924676d68p-1,   -0x1.5000p-49,
+       0x1.e7a51fbc74c44p-1,   -0x1.7f80p-47,
+       0x1.e8f7977cdb726p-1,   -0x1.3700p-48,
+       0x1.ea4afa2a490e8p-1,    0x1.5d00p-49,
+       0x1.eb9f4867ccae4p-1,    0x1.61a0p-46,
+       0x1.ecf482d8e680dp-1,    0x1.5500p-48,
+       0x1.ee4aaa2188514p-1,    0x1.6400p-51,
+       0x1.efa1bee615a13p-1,   -0x1.e800p-49,
+       0x1.f0f9c1cb64106p-1,   -0x1.a880p-48,
+       0x1.f252b376bb963p-1,   -0x1.c900p-45,
+       0x1.f3ac948dd7275p-1,    0x1.a000p-53,
+       0x1.f50765b6e4524p-1,   -0x1.4f00p-48,
+       0x1.f6632798844fdp-1,    0x1.a800p-51,
+       0x1.f7bfdad9cbe38p-1,    0x1.abc0p-48,
+       0x1.f91d802243c82p-1,   -0x1.4600p-50,
+       0x1.fa7c1819e908ep-1,   -0x1.b0c0p-47,
+       0x1.fbdba3692d511p-1,   -0x1.0e00p-51,
+       0x1.fd3c22b8f7194p-1,   -0x1.0de8p-46,
+       0x1.fe9d96b2a23eep-1,    0x1.e430p-49,
+       0x1.0000000000000p+0,    0x0.0000p+0,
+       0x1.00b1afa5abcbep+0,   -0x1.3400p-52,
+       0x1.0163da9fb3303p+0,   -0x1.2170p-46,
+       0x1.02168143b0282p+0,    0x1.a400p-52,
+       0x1.02c9a3e77806cp+0,    0x1.f980p-49,
+       0x1.037d42e11bbcap+0,   -0x1.7400p-51,
+       0x1.04315e86e7f89p+0,    0x1.8300p-50,
+       0x1.04e5f72f65467p+0,   -0x1.a3f0p-46,
+       0x1.059b0d315855ap+0,   -0x1.2840p-47,
+       0x1.0650a0e3c1f95p+0,    0x1.1600p-48,
+       0x1.0706b29ddf71ap+0,    0x1.5240p-46,
+       0x1.07bd42b72a82dp+0,   -0x1.9a00p-49,
+       0x1.0874518759bd0p+0,    0x1.6400p-49,
+       0x1.092bdf66607c8p+0,   -0x1.0780p-47,
+       0x1.09e3ecac6f383p+0,   -0x1.8000p-54,
+       0x1.0a9c79b1f3930p+0,    0x1.fa00p-48,
+       0x1.0b5586cf988fcp+0,   -0x1.ac80p-48,
+       0x1.0c0f145e46c8ap+0,    0x1.9c00p-50,
+       0x1.0cc922b724816p+0,    0x1.5200p-47,
+       0x1.0d83b23395dd8p+0,   -0x1.ad00p-48,
+       0x1.0e3ec32d3d1f3p+0,    0x1.bac0p-46,
+       0x1.0efa55fdfa9a6p+0,   -0x1.4e80p-47,
+       0x1.0fb66affed2f0p+0,   -0x1.d300p-47,
+       0x1.1073028d7234bp+0,    0x1.1500p-48,
+       0x1.11301d0125b5bp+0,    0x1.c000p-49,
+       0x1.11edbab5e2af9p+0,    0x1.6bc0p-46,
+       0x1.12abdc06c31d5p+0,    0x1.8400p-49,
+       0x1.136a814f2047dp+0,   -0x1.ed00p-47,
+       0x1.1429aaea92de9p+0,    0x1.8e00p-49,
+       0x1.14e95934f3138p+0,    0x1.b400p-49,
+       0x1.15a98c8a58e71p+0,    0x1.5300p-47,
+       0x1.166a45471c3dfp+0,    0x1.3380p-47,
+       0x1.172b83c7d5211p+0,    0x1.8d40p-45,
+       0x1.17ed48695bb9fp+0,   -0x1.5d00p-47,
+       0x1.18af9388c8d93p+0,   -0x1.c880p-46,
+       0x1.1972658375d66p+0,    0x1.1f00p-46,
+       0x1.1a35beb6fcba7p+0,    0x1.0480p-46,
+       0x1.1af99f81387e3p+0,   -0x1.7390p-43,
+       0x1.1bbe084045d54p+0,    0x1.4e40p-45,
+       0x1.1c82f95281c43p+0,   -0x1.a200p-47,
+       0x1.1d4873168b9b2p+0,    0x1.3800p-49,
+       0x1.1e0e75eb44031p+0,    0x1.ac00p-49,
+       0x1.1ed5022fcd938p+0,    0x1.1900p-47,
+       0x1.1f9c18438cdf7p+0,   -0x1.b780p-46,
+       0x1.2063b88628d8fp+0,    0x1.d940p-45,
+       0x1.212be3578a81ep+0,    0x1.8000p-50,
+       0x1.21f49917ddd41p+0,    0x1.b340p-45,
+       0x1.22bdda2791323p+0,    0x1.9f80p-46,
+       0x1.2387a6e7561e7p+0,   -0x1.9c80p-46,
+       0x1.2451ffb821427p+0,    0x1.2300p-47,
+       0x1.251ce4fb2a602p+0,   -0x1.3480p-46,
+       0x1.25e85711eceb0p+0,    0x1.2700p-46,
+       0x1.26b4565e27d16p+0,    0x1.1d00p-46,
+       0x1.2780e341de00fp+0,    0x1.1ee0p-44,
+       0x1.284dfe1f5633ep+0,   -0x1.4c00p-46,
+       0x1.291ba7591bb30p+0,   -0x1.3d80p-46,
+       0x1.29e9df51fdf09p+0,    0x1.8b00p-47,
+       0x1.2ab8a66d10e9bp+0,   -0x1.27c0p-45,
+       0x1.2b87fd0dada3ap+0,    0x1.a340p-45,
+       0x1.2c57e39771af9p+0,   -0x1.0800p-46,
+       0x1.2d285a6e402d9p+0,   -0x1.ed00p-47,
+       0x1.2df961f641579p+0,   -0x1.4200p-48,
+       0x1.2ecafa93e2ecfp+0,   -0x1.4980p-45,
+       0x1.2f9d24abd8822p+0,   -0x1.6300p-46,
+       0x1.306fe0a31b625p+0,   -0x1.2360p-44,
+       0x1.31432edeea50bp+0,   -0x1.0df8p-40,
+       0x1.32170fc4cd7b8p+0,   -0x1.2480p-45,
+       0x1.32eb83ba8e9a2p+0,   -0x1.5980p-45,
+       0x1.33c08b2641766p+0,    0x1.ed00p-46,
+       0x1.3496266e3fa27p+0,   -0x1.c000p-50,
+       0x1.356c55f929f0fp+0,   -0x1.0d80p-44,
+       0x1.36431a2de88b9p+0,    0x1.2c80p-45,
+       0x1.371a7373aaa39p+0,    0x1.0600p-45,
+       0x1.37f26231e74fep+0,   -0x1.6600p-46,
+       0x1.38cae6d05d838p+0,   -0x1.ae00p-47,
+       0x1.39a401b713ec3p+0,   -0x1.4720p-43,
+       0x1.3a7db34e5a020p+0,    0x1.8200p-47,
+       0x1.3b57fbfec6e95p+0,    0x1.e800p-44,
+       0x1.3c32dc313a8f2p+0,    0x1.f800p-49,
+       0x1.3d0e544ede122p+0,   -0x1.7a00p-46,
+       0x1.3dea64c1234bbp+0,    0x1.6300p-45,
+       0x1.3ec70df1c4eccp+0,   -0x1.8a60p-43,
+       0x1.3fa4504ac7e8cp+0,   -0x1.cdc0p-44,
+       0x1.40822c367a0bbp+0,    0x1.5b80p-45,
+       0x1.4160a21f72e95p+0,    0x1.ec00p-46,
+       0x1.423fb27094646p+0,   -0x1.3600p-46,
+       0x1.431f5d950a920p+0,    0x1.3980p-45,
+       0x1.43ffa3f84b9ebp+0,    0x1.a000p-48,
+       0x1.44e0860618919p+0,   -0x1.6c00p-48,
+       0x1.45c2042a7d201p+0,   -0x1.bc00p-47,
+       0x1.46a41ed1d0016p+0,   -0x1.2800p-46,
+       0x1.4786d668b3326p+0,    0x1.0e00p-44,
+       0x1.486a2b5c13c00p+0,   -0x1.d400p-45,
+       0x1.494e1e192af04p+0,    0x1.c200p-47,
+       0x1.4a32af0d7d372p+0,   -0x1.e500p-46,
+       0x1.4b17dea6db801p+0,    0x1.7800p-47,
+       0x1.4bfdad53629e1p+0,   -0x1.3800p-46,
+       0x1.4ce41b817c132p+0,    0x1.0800p-47,
+       0x1.4dcb299fddddbp+0,    0x1.c700p-45,
+       0x1.4eb2d81d8ab96p+0,   -0x1.ce00p-46,
+       0x1.4f9b2769d2d02p+0,    0x1.9200p-46,
+       0x1.508417f4531c1p+0,   -0x1.8c00p-47,
+       0x1.516daa2cf662ap+0,   -0x1.a000p-48,
+       0x1.5257de83f51eap+0,    0x1.a080p-43,
+       0x1.5342b569d4edap+0,   -0x1.6d80p-45,
+       0x1.542e2f4f6ac1ap+0,   -0x1.2440p-44,
+       0x1.551a4ca5d94dbp+0,    0x1.83c0p-43,
+       0x1.56070dde9116bp+0,    0x1.4b00p-45,
+       0x1.56f4736b529dep+0,    0x1.15a0p-43,
+       0x1.57e27dbe2c40ep+0,   -0x1.9e00p-45,
+       0x1.58d12d497c76fp+0,   -0x1.3080p-45,
+       0x1.59c0827ff0b4cp+0,    0x1.dec0p-43,
+       0x1.5ab07dd485427p+0,   -0x1.4000p-51,
+       0x1.5ba11fba87af4p+0,    0x1.0080p-44,
+       0x1.5c9268a59460bp+0,   -0x1.6c80p-45,
+       0x1.5d84590998e3fp+0,    0x1.69a0p-43,
+       0x1.5e76f15ad20e1p+0,   -0x1.b400p-46,
+       0x1.5f6a320dcebcap+0,    0x1.7700p-46,
+       0x1.605e1b976dcb8p+0,    0x1.6f80p-45,
+       0x1.6152ae6cdf715p+0,    0x1.1000p-47,
+       0x1.6247eb03a5531p+0,   -0x1.5d00p-46,
+       0x1.633dd1d1929b5p+0,   -0x1.2d00p-46,
+       0x1.6434634ccc313p+0,   -0x1.a800p-49,
+       0x1.652b9febc8efap+0,   -0x1.8600p-45,
+       0x1.6623882553397p+0,    0x1.1fe0p-40,
+       0x1.671c1c708328ep+0,   -0x1.7200p-44,
+       0x1.68155d44ca97ep+0,    0x1.6800p-49,
+       0x1.690f4b19e9471p+0,   -0x1.9780p-45,
+};
+
+/*
+ * exp2(x): compute the base 2 exponential of x
+ *
+ * Accuracy: Peak error < 0.503 ulp for normalized results.
+ *
+ * Method: (accurate tables)
+ *
+ *   Reduce x:
+ *     x = 2**k + y, for integer k and |y| <= 1/2.
+ *     Thus we have exp2(x) = 2**k * exp2(y).
+ *
+ *   Reduce y:
+ *     y = i/TBLSIZE + z - eps[i] for integer i near y * TBLSIZE.
+ *     Thus we have exp2(y) = exp2(i/TBLSIZE) * exp2(z - eps[i]),
+ *     with |z - eps[i]| <= 2**-9 + 2**-39 for the table used.
+ *
+ *   We compute exp2(i/TBLSIZE) via table lookup and exp2(z - eps[i]) via
+ *   a degree-5 minimax polynomial with maximum error under 1.3 * 2**-61.
+ *   The values in exp2t[] and eps[] are chosen such that
+ *   exp2t[i] = exp2(i/TBLSIZE + eps[i]), and eps[i] is a small offset such
+ *   that exp2t[i] is accurate to 2**-64.
+ *
+ *   Note that the range of i is +-TBLSIZE/2, so we actually index the tables
+ *   by i0 = i + TBLSIZE/2.  For cache efficiency, exp2t[] and eps[] are
+ *   virtual tables, interleaved in the real table tbl[].
+ *
+ *   This method is due to Gal, with many details due to Gal and Bachelis:
+ *
+ *     Gal, S. and Bachelis, B.  An Accurate Elementary Mathematical Library
+ *     for the IEEE Floating Point Standard.  TOMS 17(1), 26-46 (1991).
+ */
+double
+exp2(double x)
+{
+       double r, t, twopk, twopkp1000, z;
+       uint32_t hx, ix, lx, i0;
+       int k;
+
+       /* Filter out exceptional cases. */
+       GET_HIGH_WORD(hx,x);
+       ix = hx & 0x7fffffff;           /* high word of |x| */
+       if(ix >= 0x40900000) {                  /* |x| >= 1024 */
+               if(ix >= 0x7ff00000) {
+                       GET_LOW_WORD(lx,x);
+                       if(((ix & 0xfffff) | lx) != 0 || (hx & 0x80000000) == 0)
+                               return (x + x); /* x is NaN or +Inf */
+                       else 
+                               return (0.0);   /* x is -Inf */
+               }
+               if(x >= 0x1.0p10)
+                       return (huge * huge); /* overflow */
+               if(x <= -0x1.0ccp10)
+                       return (twom1000 * twom1000); /* underflow */
+       } else if (ix < 0x3c900000) {           /* |x| < 0x1p-54 */
+               return (1.0 + x);
+       }
+
+       /* Reduce x, computing z, i0, and k. */
+       STRICT_ASSIGN(double, t, x + redux);
+       GET_LOW_WORD(i0, t);
+       i0 += TBLSIZE / 2;
+       k = (i0 >> TBLBITS) << 20;
+       i0 = (i0 & (TBLSIZE - 1)) << 1;
+       t -= redux;
+       z = x - t;
+
+       /* Compute r = exp2(y) = exp2t[i0] * p(z - eps[i]). */
+       t = tbl[i0];            /* exp2t[i0] */
+       z -= tbl[i0 + 1];       /* eps[i0]   */
+       if (k >= -1021 << 20)
+               INSERT_WORDS(twopk, 0x3ff00000 + k, 0);
+       else
+               INSERT_WORDS(twopkp1000, 0x3ff00000 + k + (1000 << 20), 0);
+       r = t + t * z * (P1 + z * (P2 + z * (P3 + z * (P4 + z * P5))));
+
+       /* Scale by 2**(k>>20). */
+       if(k >= -1021 << 20) {
+               if (k == 1024 << 20)
+                       return (r * 2.0 * 0x1p1023);
+               return (r * twopk);
+       } else {
+               return (r * twopkp1000 * twom1000);
+       }
+}

diff --git a/lib/libm/src/s_exp2f.c b/lib/libm/src/s_exp2f.c
new file mode 100644 (file)
index 0000000..3ed3e6c
--- /dev/null
+++ b/lib/libm/src/s_exp2f.c
@@ -0,0 +1,135 @@
+/*     $OpenBSD: s_exp2f.c,v 1.1 2008/07/24 09:40:16 martynas Exp $    */
+/*-
+ * Copyright (c) 2005 David Schultz <das@FreeBSD.ORG>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+#include <float.h>
+
+#include "math.h"
+#include "math_private.h"
+
+#define        TBLBITS 4
+#define        TBLSIZE (1 << TBLBITS)
+
+static const float
+    huge    = 0x1p100f,
+    redux   = 0x1.8p23f / TBLSIZE,
+    P1     = 0x1.62e430p-1f,
+    P2     = 0x1.ebfbe0p-3f,
+    P3     = 0x1.c6b348p-5f,
+    P4     = 0x1.3b2c9cp-7f;
+
+static volatile float twom100 = 0x1p-100f;
+
+static const double exp2ft[TBLSIZE] = {
+       0x1.6a09e667f3bcdp-1,
+       0x1.7a11473eb0187p-1,
+       0x1.8ace5422aa0dbp-1,
+       0x1.9c49182a3f090p-1,
+       0x1.ae89f995ad3adp-1,
+       0x1.c199bdd85529cp-1,
+       0x1.d5818dcfba487p-1,
+       0x1.ea4afa2a490dap-1,
+       0x1.0000000000000p+0,
+       0x1.0b5586cf9890fp+0,
+       0x1.172b83c7d517bp+0,
+       0x1.2387a6e756238p+0,
+       0x1.306fe0a31b715p+0,
+       0x1.3dea64c123422p+0,
+       0x1.4bfdad5362a27p+0,
+       0x1.5ab07dd485429p+0,
+};
+       
+/*
+ * exp2f(x): compute the base 2 exponential of x
+ *
+ * Accuracy: Peak error < 0.501 ulp; location of peak: -0.030110927.
+ *
+ * Method: (equally-spaced tables)
+ *
+ *   Reduce x:
+ *     x = 2**k + y, for integer k and |y| <= 1/2.
+ *     Thus we have exp2f(x) = 2**k * exp2(y).
+ *
+ *   Reduce y:
+ *     y = i/TBLSIZE + z for integer i near y * TBLSIZE.
+ *     Thus we have exp2(y) = exp2(i/TBLSIZE) * exp2(z),
+ *     with |z| <= 2**-(TBLSIZE+1).
+ *
+ *   We compute exp2(i/TBLSIZE) via table lookup and exp2(z) via a
+ *   degree-4 minimax polynomial with maximum error under 1.4 * 2**-33.
+ *   Using double precision for everything except the reduction makes
+ *   roundoff error insignificant and simplifies the scaling step.
+ *
+ *   This method is due to Tang, but I do not use his suggested parameters:
+ *
+ *     Tang, P.  Table-driven Implementation of the Exponential Function
+ *     in IEEE Floating-Point Arithmetic.  TOMS 15(2), 144-157 (1989).
+ */
+float
+exp2f(float x)
+{
+       double tv, twopk, u, z;
+       float t;
+       uint32_t hx, ix, i0;
+       int32_t k;
+
+       /* Filter out exceptional cases. */
+       GET_FLOAT_WORD(hx, x);
+       ix = hx & 0x7fffffff;           /* high word of |x| */
+       if(ix >= 0x43000000) {                  /* |x| >= 128 */
+               if(ix >= 0x7f800000) {
+                       if ((ix & 0x7fffff) != 0 || (hx & 0x80000000) == 0)
+                               return (x + x); /* x is NaN or +Inf */
+                       else 
+                               return (0.0);   /* x is -Inf */
+               }
+               if(x >= 0x1.0p7f)
+                       return (huge * huge);   /* overflow */
+               if(x <= -0x1.2cp7f)
+                       return (twom100 * twom100); /* underflow */
+       } else if (ix <= 0x33000000) {          /* |x| <= 0x1p-25 */
+               return (1.0f + x);
+       }
+
+       /* Reduce x, computing z, i0, and k. */
+       STRICT_ASSIGN(float, t, x + redux);
+       GET_FLOAT_WORD(i0, t);
+       i0 += TBLSIZE / 2;
+       k = (i0 >> TBLBITS) << 20;
+       i0 &= TBLSIZE - 1;
+       t -= redux;
+       z = x - t;
+       INSERT_WORDS(twopk, 0x3ff00000 + k, 0);
+
+       /* Compute r = exp2(y) = exp2ft[i0] * p(z). */
+       tv = exp2ft[i0];
+       u = tv * z;
+       tv = tv + u * (P1 + z * P2) + u * (z * z) * (P3 + z * P4);
+
+       /* Scale by 2**(k>>20). */
+       return (tv * twopk);
+}

diff --git a/lib/libm/src/s_nan.c b/lib/libm/src/s_nan.c
new file mode 100644 (file)
index 0000000..6717d6f
--- /dev/null
+++ b/lib/libm/src/s_nan.c
@@ -0,0 +1,123 @@
+/*     $OpenBSD: s_nan.c,v 1.1 2008/07/24 09:40:16 martynas Exp $      */
+/*-
+ * Copyright (c) 2007 David Schultz
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: src/lib/msun/src/s_nan.c,v 1.2 2007/12/18 23:46:32 das Exp $
+ */
+
+#include <sys/types.h>
+#include <sys/endian.h>
+#include <ctype.h>
+#include <float.h>
+#include <math.h>
+#include <stdint.h>
+#include <strings.h>
+
+#include "math_private.h"
+
+/*
+ * OpenBSD's ctype doesn't have digittoint, so we define it here.
+ */
+int
+_digittoint(int c)
+{
+       if (!isxdigit(c))
+               return 0;
+
+       if (isdigit(c))
+               return c - '0';
+       else
+               return isupper(c) ? c - 'A' + 10 : c - 'a' + 10;
+}
+
+/*
+ * Scan a string of hexadecimal digits (the format nan(3) expects) and
+ * make a bit array (using the local endianness). We stop when we
+ * encounter an invalid character, NUL, etc.  If we overflow, we do
+ * the same as gcc's __builtin_nan(), namely, discard the high order bits.
+ *
+ * The format this routine accepts needs to be compatible with what is used
+ * in contrib/gdtoa/hexnan.c (for strtod/scanf) and what is used in
+ * __builtin_nan(). In fact, we're only 100% compatible for strings we
+ * consider valid, so we might be violating the C standard. But it's
+ * impossible to use nan(3) portably anyway, so this seems good enough.
+ */
+void
+_scan_nan(uint32_t *words, int num_words, const char *s)
+{
+       int si;         /* index into s */
+       int bitpos;     /* index into words (in bits) */
+
+       bzero(words, num_words * sizeof(uint32_t));
+
+       /* Allow a leading '0x'. (It's expected, but redundant.) */
+       if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
+               s += 2;
+
+       /* Scan forwards in the string, looking for the end of the sequence. */
+       for (si = 0; isxdigit(s[si]); si++)
+               ;
+
+       /* Scan backwards, filling in the bits in words[] as we go. */
+#if _BYTE_ORDER == _LITTLE_ENDIAN
+       for (bitpos = 0; bitpos < 32 * num_words; bitpos += 4) {
+#else
+       for (bitpos = 32 * num_words - 4; bitpos >= 0; bitpos -= 4) {
+#endif
+               if (--si < 0)
+                       break;
+               words[bitpos / 32] |= _digittoint(s[si]) << (bitpos % 32);
+       }
+}
+
+double
+nan(const char *s)
+{
+       union {
+               double d;
+               uint32_t bits[2];
+       } u;
+
+       _scan_nan(u.bits, 2, s);
+#if _BYTE_ORDER == _LITTLE_ENDIAN
+       u.bits[1] |= 0x7ff80000;
+#else
+       u.bits[0] |= 0x7ff80000;
+#endif
+       return (u.d);
+}
+
+float
+nanf(const char *s)
+{
+       union {
+               float f;
+               uint32_t bits[1];
+       } u;
+
+       _scan_nan(u.bits, 1, s);
+       u.bits[0] |= 0x7fc00000;
+       return (u.f);
+}

diff --git a/lib/libm/src/s_remquo.c b/lib/libm/src/s_remquo.c
new file mode 100644 (file)
index 0000000..b033071
--- /dev/null
+++ b/lib/libm/src/s_remquo.c
@@ -0,0 +1,151 @@
+/* @(#)e_fmod.c 1.3 95/01/18 */
+/*-
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunSoft, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice 
+ * is preserved.
+ * ====================================================
+ */
+
+#include <float.h>
+
+#include "math.h"
+#include "math_private.h"
+
+static const double Zero[] = {0.0, -0.0,};
+
+/*
+ * Return the IEEE remainder and set *quo to the last n bits of the
+ * quotient, rounded to the nearest integer.  We choose n=31 because
+ * we wind up computing all the integer bits of the quotient anyway as
+ * a side-effect of computing the remainder by the shift and subtract
+ * method.  In practice, this is far more bits than are needed to use
+ * remquo in reduction algorithms.
+ */
+double
+remquo(double x, double y, int *quo)
+{
+       int32_t n,hx,hy,hz,ix,iy,sx,i;
+       u_int32_t lx,ly,lz,q,sxy;
+
+       EXTRACT_WORDS(hx,lx,x);
+       EXTRACT_WORDS(hy,ly,y);
+       sxy = (hx ^ hy) & 0x80000000;
+       sx = hx&0x80000000;             /* sign of x */
+       hx ^=sx;                /* |x| */
+       hy &= 0x7fffffff;       /* |y| */
+
+    /* purge off exception values */
+       if((hy|ly)==0||(hx>=0x7ff00000)||       /* y=0,or x not finite */
+         ((hy|((ly|-ly)>>31))>0x7ff00000))     /* or y is NaN */
+           return (x*y)/(x*y);
+       if(hx<=hy) {
+           if((hx<hy)||(lx<ly)) {
+               q = 0;
+               goto fixup;     /* |x|<|y| return x or x-y */
+           }
+           if(lx==ly) {
+               *quo = 1;
+               return Zero[(u_int32_t)sx>>31]; /* |x|=|y| return x*0*/
+           }
+       }
+
+    /* determine ix = ilogb(x) */
+       if(hx<0x00100000) {     /* subnormal x */
+           if(hx==0) {
+               for (ix = -1043, i=lx; i>0; i<<=1) ix -=1;
+           } else {
+               for (ix = -1022,i=(hx<<11); i>0; i<<=1) ix -=1;
+           }
+       } else ix = (hx>>20)-1023;
+
+    /* determine iy = ilogb(y) */
+       if(hy<0x00100000) {     /* subnormal y */
+           if(hy==0) {
+               for (iy = -1043, i=ly; i>0; i<<=1) iy -=1;
+           } else {
+               for (iy = -1022,i=(hy<<11); i>0; i<<=1) iy -=1;
+           }
+       } else iy = (hy>>20)-1023;
+
+    /* set up {hx,lx}, {hy,ly} and align y to x */
+       if(ix >= -1022) 
+           hx = 0x00100000|(0x000fffff&hx);
+       else {          /* subnormal x, shift x to normal */
+           n = -1022-ix;
+           if(n<=31) {
+               hx = (hx<<n)|(lx>>(32-n));
+               lx <<= n;
+           } else {
+               hx = lx<<(n-32);
+               lx = 0;
+           }
+       }
+       if(iy >= -1022) 
+           hy = 0x00100000|(0x000fffff&hy);
+       else {          /* subnormal y, shift y to normal */
+           n = -1022-iy;
+           if(n<=31) {
+               hy = (hy<<n)|(ly>>(32-n));
+               ly <<= n;
+           } else {
+               hy = ly<<(n-32);
+               ly = 0;
+           }
+       }
+
+    /* fix point fmod */
+       n = ix - iy;
+       q = 0;
+       while(n--) {
+           hz=hx-hy;lz=lx-ly; if(lx<ly) hz -= 1;
+           if(hz<0){hx = hx+hx+(lx>>31); lx = lx+lx;}
+           else {hx = hz+hz+(lz>>31); lx = lz+lz; q++;}
+           q <<= 1;
+       }
+       hz=hx-hy;lz=lx-ly; if(lx<ly) hz -= 1;
+       if(hz>=0) {hx=hz;lx=lz;q++;}
+
+    /* convert back to floating value and restore the sign */
+       if((hx|lx)==0) {                        /* return sign(x)*0 */
+           *quo = (sxy ? -q : q);
+           return Zero[(u_int32_t)sx>>31];
+       }
+       while(hx<0x00100000) {          /* normalize x */
+           hx = hx+hx+(lx>>31); lx = lx+lx;
+           iy -= 1;
+       }
+       if(iy>= -1022) {        /* normalize output */
+           hx = ((hx-0x00100000)|((iy+1023)<<20));
+       } else {                /* subnormal output */
+           n = -1022 - iy;
+           if(n<=20) {
+               lx = (lx>>n)|((u_int32_t)hx<<(32-n));
+               hx >>= n;
+           } else if (n<=31) {
+               lx = (hx<<(32-n))|(lx>>n); hx = sx;
+           } else {
+               lx = hx>>(n-32); hx = sx;
+           }
+       }
+fixup:
+       INSERT_WORDS(x,hx,lx);
+       y = fabs(y);
+       if (y < 0x1p-1021) {
+           if (x+x>y || (x+x==y && (q & 1))) {
+               q++;
+               x-=y;
+           }
+       } else if (x>0.5*y || (x==0.5*y && (q & 1))) {
+           q++;
+           x-=y;
+       }
+       GET_HIGH_WORD(hx,x);
+       SET_HIGH_WORD(x,hx^sx);
+       q &= 0x7fffffff;
+       *quo = (sxy ? -q : q);
+       return x;
+}

diff --git a/lib/libm/src/s_remquof.c b/lib/libm/src/s_remquof.c
new file mode 100644 (file)
index 0000000..9e85ad7
--- /dev/null
+++ b/lib/libm/src/s_remquof.c
@@ -0,0 +1,120 @@
+/* @(#)e_fmod.c 1.3 95/01/18 */
+/*-
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunSoft, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice 
+ * is preserved.
+ * ====================================================
+ */
+
+#include <sys/cdefs.h>
+
+#include "math.h"
+#include "math_private.h"
+
+static const float Zero[] = {0.0, -0.0,};
+
+/*
+ * Return the IEEE remainder and set *quo to the last n bits of the
+ * quotient, rounded to the nearest integer.  We choose n=31 because
+ * we wind up computing all the integer bits of the quotient anyway as
+ * a side-effect of computing the remainder by the shift and subtract
+ * method.  In practice, this is far more bits than are needed to use
+ * remquo in reduction algorithms.
+ */
+float
+remquof(float x, float y, int *quo)
+{
+       int32_t n,hx,hy,hz,ix,iy,sx,i;
+       u_int32_t q,sxy;
+
+       GET_FLOAT_WORD(hx,x);
+       GET_FLOAT_WORD(hy,y);
+       sxy = (hx ^ hy) & 0x80000000;
+       sx = hx&0x80000000;             /* sign of x */
+       hx ^=sx;                /* |x| */
+       hy &= 0x7fffffff;       /* |y| */
+
+    /* purge off exception values */
+       if(hy==0||hx>=0x7f800000||hy>0x7f800000) /* y=0,NaN;or x not finite */
+           return (x*y)/(x*y);
+       if(hx<hy) {
+           q = 0;
+           goto fixup; /* |x|<|y| return x or x-y */
+       } else if(hx==hy) {
+           *quo = 1;
+           return Zero[(u_int32_t)sx>>31];     /* |x|=|y| return x*0*/
+       }
+
+    /* determine ix = ilogb(x) */
+       if(hx<0x00800000) {     /* subnormal x */
+           for (ix = -126,i=(hx<<8); i>0; i<<=1) ix -=1;
+       } else ix = (hx>>23)-127;
+
+    /* determine iy = ilogb(y) */
+       if(hy<0x00800000) {     /* subnormal y */
+           for (iy = -126,i=(hy<<8); i>0; i<<=1) iy -=1;
+       } else iy = (hy>>23)-127;
+
+    /* set up {hx,lx}, {hy,ly} and align y to x */
+       if(ix >= -126)
+           hx = 0x00800000|(0x007fffff&hx);
+       else {          /* subnormal x, shift x to normal */
+           n = -126-ix;
+           hx <<= n;
+       }
+       if(iy >= -126)
+           hy = 0x00800000|(0x007fffff&hy);
+       else {          /* subnormal y, shift y to normal */
+           n = -126-iy;
+           hy <<= n;
+       }
+
+    /* fix point fmod */
+       n = ix - iy;
+       q = 0;
+       while(n--) {
+           hz=hx-hy;
+           if(hz<0) hx = hx << 1;
+           else {hx = hz << 1; q++;}
+           q <<= 1;
+       }
+       hz=hx-hy;
+       if(hz>=0) {hx=hz;q++;}
+
+    /* convert back to floating value and restore the sign */
+       if(hx==0) {                             /* return sign(x)*0 */
+           *quo = (sxy ? -q : q);
+           return Zero[(u_int32_t)sx>>31];
+       }
+       while(hx<0x00800000) {          /* normalize x */
+           hx <<= 1;
+           iy -= 1;
+       }
+       if(iy>= -126) {         /* normalize output */
+           hx = ((hx-0x00800000)|((iy+127)<<23));
+       } else {                /* subnormal output */
+           n = -126 - iy;
+           hx >>= n;
+       }
+fixup:
+       SET_FLOAT_WORD(x,hx);
+       y = fabsf(y);
+       if (y < 0x1p-125f) {
+           if (x+x>y || (x+x==y && (q & 1))) {
+               q++;
+               x-=y;
+           }
+       } else if (x>0.5f*y || (x==0.5f*y && (q & 1))) {
+           q++;
+           x-=y;
+       }
+       GET_FLOAT_WORD(hx,x);
+       SET_FLOAT_WORD(x,hx^sx);
+       q &= 0x7fffffff;
+       *quo = (sxy ? -q : q);
+       return x;
+}