about summary refs log tree commit diff
path: root/src/math/floorl.c
diff options
context:
space:
mode:
authorSzabolcs Nagy <nsz@port70.net>2013-09-03 03:27:02 +0000
committerSzabolcs Nagy <nsz@port70.net>2013-09-05 11:30:07 +0000
commitd1a2ead878c27ac4ec600740320f8b76e1f961e9 (patch)
tree4da00576cf5df93d9170bdf76a26d9c2c96d3978 /src/math/floorl.c
parent98be442ee8a2b8b7e0802b604e384d5a2c43282e (diff)
downloadmusl-d1a2ead878c27ac4ec600740320f8b76e1f961e9.tar.gz
musl-d1a2ead878c27ac4ec600740320f8b76e1f961e9.tar.xz
musl-d1a2ead878c27ac4ec600740320f8b76e1f961e9.zip
math: rewrite rounding functions (ceil, floor, trunc, round, rint)
* faster, smaller, cleaner implementation than the bit hacks of fdlibm
* use arithmetics like y=(double)(x+0x1p52)-0x1p52, which is an integer
neighbor of x in all rounding modes (0<=x<0x1p52) and only use bithacks
when that's faster and smaller (for float it usually is)
* the code assumes standard excess precision handling for casts
* long double code supports both ld80 and ld128
* nearbyint is not changed (it is a wrapper around rint)
Diffstat (limited to 'src/math/floorl.c')
-rw-r--r--src/math/floorl.c108
1 files changed, 21 insertions, 87 deletions
diff --git a/src/math/floorl.c b/src/math/floorl.c
index 3901b060..961f9e89 100644
--- a/src/math/floorl.c
+++ b/src/math/floorl.c
@@ -1,23 +1,3 @@
-/* origin: FreeBSD /usr/src/lib/msun/src/s_floorl.c */
-/*
- * ====================================================
- * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
- *
- * Developed at SunPro, a Sun Microsystems, Inc. business.
- * Permission to use, copy, modify, and distribute this
- * software is freely granted, provided that this notice
- * is preserved.
- * ====================================================
- */
-/*
- * floorl(x)
- * Return x rounded toward -inf to integral value
- * Method:
- *      Bit twiddling.
- * Exception:
- *      Inexact flag raised if x not equal to floorl(x).
- */
-
 #include "libm.h"
 
 #if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
@@ -26,77 +6,31 @@ long double floorl(long double x)
 	return floor(x);
 }
 #elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-
-#ifdef LDBL_IMPLICIT_NBIT
-#define MANH_SIZE       (LDBL_MANH_SIZE + 1)
-#define INC_MANH(u, c)  do {                                    \
-	uint64_t o = u.bits.manh;                               \
-	u.bits.manh += (c);                                     \
-	if (u.bits.manh < o)                                    \
-		u.bits.exp++;                                   \
-} while (0)
-#else
-#define MANH_SIZE       LDBL_MANH_SIZE
-#define INC_MANH(u, c)  do {                                    \
-	uint64_t o = u.bits.manh;                               \
-	u.bits.manh += (c);                                     \
-	if (u.bits.manh < o) {                                  \
-		u.bits.exp++;                                   \
-		u.bits.manh |= 1llu << (LDBL_MANH_SIZE - 1);    \
-	}                                                       \
-} while (0)
+#if LDBL_MANT_DIG == 64
+#define TOINT 0x1p63
+#elif LDBL_MANT_DIG == 113
+#define TOINT 0x1p112
 #endif
-
-static const long double huge = 1.0e300;
-
 long double floorl(long double x)
 {
-	union IEEEl2bits u = { .e = x };
-	int e = u.bits.exp - LDBL_MAX_EXP + 1;
+	union ldshape u = {x};
+	int e = u.i.se & 0x7fff;
+	long double y;
 
-	if (e < MANH_SIZE - 1) {
-		if (e < 0) {
-			/* raise inexact if x != 0 */
-			if (huge + x > 0.0)
-				if (u.bits.exp > 0 ||
-				    (u.bits.manh | u.bits.manl) != 0)
-					u.e = u.bits.sign ? -1.0 : 0.0;
-		} else {
-			uint64_t m = ((1llu << MANH_SIZE) - 1) >> (e + 1);
-			if (((u.bits.manh & m) | u.bits.manl) == 0)
-				return x;  /* x is integral */
-			if (u.bits.sign) {
-#ifdef LDBL_IMPLICIT_NBIT
-				if (e == 0)
-					u.bits.exp++;
-				else
-#endif
-				INC_MANH(u, 1llu << (MANH_SIZE - e - 1));
-			}
-			/* raise inexact flag */
-			if (huge + x > 0.0) {
-				u.bits.manh &= ~m;
-				u.bits.manl = 0;
-			}
-		}
-	} else if (e < LDBL_MANT_DIG - 1) {
-		uint64_t m = (uint64_t)-1 >> (64 - LDBL_MANT_DIG + e + 1);
-		if ((u.bits.manl & m) == 0)
-			return x;  /* x is integral */
-		if (u.bits.sign) {
-			if (e == MANH_SIZE - 1)
-				INC_MANH(u, 1);
-			else {
-				uint64_t o = u.bits.manl;
-				u.bits.manl += 1llu << (LDBL_MANT_DIG - e - 1);
-				if (u.bits.manl < o)   /* got a carry */
-					INC_MANH(u, 1);
-			}
-		}
-		/* raise inexact flag */
-		if (huge + x > 0.0)
-			u.bits.manl &= ~m;
+	if (e >= 0x3fff+LDBL_MANT_DIG-1 || x == 0)
+		return x;
+	/* y = int(x) - x, where int(x) is an integer neighbor of x */
+	if (u.i.se >> 15)
+		y = x - TOINT + TOINT - x;
+	else
+		y = x + TOINT - TOINT - x;
+	/* special case because of non-nearest rounding modes */
+	if (e <= 0x3fff-1) {
+		FORCE_EVAL(y);
+		return u.i.se >> 15 ? -1 : 0;
 	}
-	return u.e;
+	if (y > 0)
+		return x + y - 1;
+	return x + y;
 }
 #endif