Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(67)

Unified Diff: fusl/src/math/fma.c

Issue 1573973002: Add a "fork" of musl as //fusl. (Closed) Base URL: https://github.com/domokit/mojo.git@master
Patch Set: Created 4 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « fusl/src/math/floorl.c ('k') | fusl/src/math/fmaf.c » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: fusl/src/math/fma.c
diff --git a/fusl/src/math/fma.c b/fusl/src/math/fma.c
new file mode 100644
index 0000000000000000000000000000000000000000..741ccd757ab1544d5ed4d6fd2bd135d7cb0586e3
--- /dev/null
+++ b/fusl/src/math/fma.c
@@ -0,0 +1,460 @@
+#include <fenv.h>
+#include "libm.h"
+
+#if LDBL_MANT_DIG==64 && LDBL_MAX_EXP==16384
+/* exact add, assumes exponent_x >= exponent_y */
+static void add(long double *hi, long double *lo, long double x, long double y)
+{
+ long double r;
+
+ r = x + y;
+ *hi = r;
+ r -= x;
+ *lo = y - r;
+}
+
+/* exact mul, assumes no over/underflow */
+static void mul(long double *hi, long double *lo, long double x, long double y)
+{
+ static const long double c = 1.0 + 0x1p32L;
+ long double cx, xh, xl, cy, yh, yl;
+
+ cx = c*x;
+ xh = (x - cx) + cx;
+ xl = x - xh;
+ cy = c*y;
+ yh = (y - cy) + cy;
+ yl = y - yh;
+ *hi = x*y;
+ *lo = (xh*yh - *hi) + xh*yl + xl*yh + xl*yl;
+}
+
+/*
+assume (long double)(hi+lo) == hi
+return an adjusted hi so that rounding it to double (or less) precision is correct
+*/
+static long double adjust(long double hi, long double lo)
+{
+ union ldshape uhi, ulo;
+
+ if (lo == 0)
+ return hi;
+ uhi.f = hi;
+ if (uhi.i.m & 0x3ff)
+ return hi;
+ ulo.f = lo;
+ if ((uhi.i.se & 0x8000) == (ulo.i.se & 0x8000))
+ uhi.i.m++;
+ else {
+ /* handle underflow and take care of ld80 implicit msb */
+ if (uhi.i.m << 1 == 0) {
+ uhi.i.m = 0;
+ uhi.i.se--;
+ }
+ uhi.i.m--;
+ }
+ return uhi.f;
+}
+
+/* adjusted add so the result is correct when rounded to double (or less) precision */
+static long double dadd(long double x, long double y)
+{
+ add(&x, &y, x, y);
+ return adjust(x, y);
+}
+
+/* adjusted mul so the result is correct when rounded to double (or less) precision */
+static long double dmul(long double x, long double y)
+{
+ mul(&x, &y, x, y);
+ return adjust(x, y);
+}
+
+static int getexp(long double x)
+{
+ union ldshape u;
+ u.f = x;
+ return u.i.se & 0x7fff;
+}
+
+double fma(double x, double y, double z)
+{
+ #pragma STDC FENV_ACCESS ON
+ long double hi, lo1, lo2, xy;
+ int round, ez, exy;
+
+ /* handle +-inf,nan */
+ if (!isfinite(x) || !isfinite(y))
+ return x*y + z;
+ if (!isfinite(z))
+ return z;
+ /* handle +-0 */
+ if (x == 0.0 || y == 0.0)
+ return x*y + z;
+ round = fegetround();
+ if (z == 0.0) {
+ if (round == FE_TONEAREST)
+ return dmul(x, y);
+ return x*y;
+ }
+
+ /* exact mul and add require nearest rounding */
+ /* spurious inexact exceptions may be raised */
+ fesetround(FE_TONEAREST);
+ mul(&xy, &lo1, x, y);
+ exy = getexp(xy);
+ ez = getexp(z);
+ if (ez > exy) {
+ add(&hi, &lo2, z, xy);
+ } else if (ez > exy - 12) {
+ add(&hi, &lo2, xy, z);
+ if (hi == 0) {
+ /*
+ xy + z is 0, but it should be calculated with the
+ original rounding mode so the sign is correct, if the
+ compiler does not support FENV_ACCESS ON it does not
+ know about the changed rounding mode and eliminates
+ the xy + z below without the volatile memory access
+ */
+ volatile double z_;
+ fesetround(round);
+ z_ = z;
+ return (xy + z_) + lo1;
+ }
+ } else {
+ /*
+ ez <= exy - 12
+ the 12 extra bits (1guard, 11round+sticky) are needed so with
+ lo = dadd(lo1, lo2)
+ elo <= ehi - 11, and we use the last 10 bits in adjust so
+ dadd(hi, lo)
+ gives correct result when rounded to double
+ */
+ hi = xy;
+ lo2 = z;
+ }
+ /*
+ the result is stored before return for correct precision and exceptions
+
+ one corner case is when the underflow flag should be raised because
+ the precise result is an inexact subnormal double, but the calculated
+ long double result is an exact subnormal double
+ (so rounding to double does not raise exceptions)
+
+ in nearest rounding mode dadd takes care of this: the last bit of the
+ result is adjusted so rounding sees an inexact value when it should
+
+ in non-nearest rounding mode fenv is used for the workaround
+ */
+ fesetround(round);
+ if (round == FE_TONEAREST)
+ z = dadd(hi, dadd(lo1, lo2));
+ else {
+#if defined(FE_INEXACT) && defined(FE_UNDERFLOW)
+ int e = fetestexcept(FE_INEXACT);
+ feclearexcept(FE_INEXACT);
+#endif
+ z = hi + (lo1 + lo2);
+#if defined(FE_INEXACT) && defined(FE_UNDERFLOW)
+ if (getexp(z) < 0x3fff-1022 && fetestexcept(FE_INEXACT))
+ feraiseexcept(FE_UNDERFLOW);
+ else if (e)
+ feraiseexcept(FE_INEXACT);
+#endif
+ }
+ return z;
+}
+#else
+/* origin: FreeBSD /usr/src/lib/msun/src/s_fma.c */
+/*-
+ * Copyright (c) 2005-2011 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.
+ */
+
+/*
+ * A struct dd represents a floating-point number with twice the precision
+ * of a double. We maintain the invariant that "hi" stores the 53 high-order
+ * bits of the result.
+ */
+struct dd {
+ double hi;
+ double lo;
+};
+
+/*
+ * Compute a+b exactly, returning the exact result in a struct dd. We assume
+ * that both a and b are finite, but make no assumptions about their relative
+ * magnitudes.
+ */
+static inline struct dd dd_add(double a, double b)
+{
+ struct dd ret;
+ double s;
+
+ ret.hi = a + b;
+ s = ret.hi - a;
+ ret.lo = (a - (ret.hi - s)) + (b - s);
+ return (ret);
+}
+
+/*
+ * Compute a+b, with a small tweak: The least significant bit of the
+ * result is adjusted into a sticky bit summarizing all the bits that
+ * were lost to rounding. This adjustment negates the effects of double
+ * rounding when the result is added to another number with a higher
+ * exponent. For an explanation of round and sticky bits, see any reference
+ * on FPU design, e.g.,
+ *
+ * J. Coonen. An Implementation Guide to a Proposed Standard for
+ * Floating-Point Arithmetic. Computer, vol. 13, no. 1, Jan 1980.
+ */
+static inline double add_adjusted(double a, double b)
+{
+ struct dd sum;
+ union {double f; uint64_t i;} uhi, ulo;
+
+ sum = dd_add(a, b);
+ if (sum.lo != 0) {
+ uhi.f = sum.hi;
+ if ((uhi.i & 1) == 0) {
+ /* hibits += (int)copysign(1.0, sum.hi * sum.lo) */
+ ulo.f = sum.lo;
+ uhi.i += 1 - ((uhi.i ^ ulo.i) >> 62);
+ sum.hi = uhi.f;
+ }
+ }
+ return (sum.hi);
+}
+
+/*
+ * Compute ldexp(a+b, scale) with a single rounding error. It is assumed
+ * that the result will be subnormal, and care is taken to ensure that
+ * double rounding does not occur.
+ */
+static inline double add_and_denormalize(double a, double b, int scale)
+{
+ struct dd sum;
+ union {double f; uint64_t i;} uhi, ulo;
+ int bits_lost;
+
+ sum = dd_add(a, b);
+
+ /*
+ * If we are losing at least two bits of accuracy to denormalization,
+ * then the first lost bit becomes a round bit, and we adjust the
+ * lowest bit of sum.hi to make it a sticky bit summarizing all the
+ * bits in sum.lo. With the sticky bit adjusted, the hardware will
+ * break any ties in the correct direction.
+ *
+ * If we are losing only one bit to denormalization, however, we must
+ * break the ties manually.
+ */
+ if (sum.lo != 0) {
+ uhi.f = sum.hi;
+ bits_lost = -((int)(uhi.i >> 52) & 0x7ff) - scale + 1;
+ if ((bits_lost != 1) ^ (int)(uhi.i & 1)) {
+ /* hibits += (int)copysign(1.0, sum.hi * sum.lo) */
+ ulo.f = sum.lo;
+ uhi.i += 1 - (((uhi.i ^ ulo.i) >> 62) & 2);
+ sum.hi = uhi.f;
+ }
+ }
+ return scalbn(sum.hi, scale);
+}
+
+/*
+ * Compute a*b exactly, returning the exact result in a struct dd. We assume
+ * that both a and b are normalized, so no underflow or overflow will occur.
+ * The current rounding mode must be round-to-nearest.
+ */
+static inline struct dd dd_mul(double a, double b)
+{
+ static const double split = 0x1p27 + 1.0;
+ struct dd ret;
+ double ha, hb, la, lb, p, q;
+
+ p = a * split;
+ ha = a - p;
+ ha += p;
+ la = a - ha;
+
+ p = b * split;
+ hb = b - p;
+ hb += p;
+ lb = b - hb;
+
+ p = ha * hb;
+ q = ha * lb + la * hb;
+
+ ret.hi = p + q;
+ ret.lo = p - ret.hi + q + la * lb;
+ return (ret);
+}
+
+/*
+ * Fused multiply-add: Compute x * y + z with a single rounding error.
+ *
+ * We use scaling to avoid overflow/underflow, along with the
+ * canonical precision-doubling technique adapted from:
+ *
+ * Dekker, T. A Floating-Point Technique for Extending the
+ * Available Precision. Numer. Math. 18, 224-242 (1971).
+ *
+ * This algorithm is sensitive to the rounding precision. FPUs such
+ * as the i387 must be set in double-precision mode if variables are
+ * to be stored in FP registers in order to avoid incorrect results.
+ * This is the default on FreeBSD, but not on many other systems.
+ *
+ * Hardware instructions should be used on architectures that support it,
+ * since this implementation will likely be several times slower.
+ */
+double fma(double x, double y, double z)
+{
+ #pragma STDC FENV_ACCESS ON
+ double xs, ys, zs, adj;
+ struct dd xy, r;
+ int oround;
+ int ex, ey, ez;
+ int spread;
+
+ /*
+ * Handle special cases. The order of operations and the particular
+ * return values here are crucial in handling special cases involving
+ * infinities, NaNs, overflows, and signed zeroes correctly.
+ */
+ if (!isfinite(x) || !isfinite(y))
+ return (x * y + z);
+ if (!isfinite(z))
+ return (z);
+ if (x == 0.0 || y == 0.0)
+ return (x * y + z);
+ if (z == 0.0)
+ return (x * y);
+
+ xs = frexp(x, &ex);
+ ys = frexp(y, &ey);
+ zs = frexp(z, &ez);
+ oround = fegetround();
+ spread = ex + ey - ez;
+
+ /*
+ * If x * y and z are many orders of magnitude apart, the scaling
+ * will overflow, so we handle these cases specially. Rounding
+ * modes other than FE_TONEAREST are painful.
+ */
+ if (spread < -DBL_MANT_DIG) {
+#ifdef FE_INEXACT
+ feraiseexcept(FE_INEXACT);
+#endif
+#ifdef FE_UNDERFLOW
+ if (!isnormal(z))
+ feraiseexcept(FE_UNDERFLOW);
+#endif
+ switch (oround) {
+ default: /* FE_TONEAREST */
+ return (z);
+#ifdef FE_TOWARDZERO
+ case FE_TOWARDZERO:
+ if (x > 0.0 ^ y < 0.0 ^ z < 0.0)
+ return (z);
+ else
+ return (nextafter(z, 0));
+#endif
+#ifdef FE_DOWNWARD
+ case FE_DOWNWARD:
+ if (x > 0.0 ^ y < 0.0)
+ return (z);
+ else
+ return (nextafter(z, -INFINITY));
+#endif
+#ifdef FE_UPWARD
+ case FE_UPWARD:
+ if (x > 0.0 ^ y < 0.0)
+ return (nextafter(z, INFINITY));
+ else
+ return (z);
+#endif
+ }
+ }
+ if (spread <= DBL_MANT_DIG * 2)
+ zs = scalbn(zs, -spread);
+ else
+ zs = copysign(DBL_MIN, zs);
+
+ fesetround(FE_TONEAREST);
+
+ /*
+ * Basic approach for round-to-nearest:
+ *
+ * (xy.hi, xy.lo) = x * y (exact)
+ * (r.hi, r.lo) = xy.hi + z (exact)
+ * adj = xy.lo + r.lo (inexact; low bit is sticky)
+ * result = r.hi + adj (correctly rounded)
+ */
+ xy = dd_mul(xs, ys);
+ r = dd_add(xy.hi, zs);
+
+ spread = ex + ey;
+
+ if (r.hi == 0.0) {
+ /*
+ * When the addends cancel to 0, ensure that the result has
+ * the correct sign.
+ */
+ fesetround(oround);
+ volatile double vzs = zs; /* XXX gcc CSE bug workaround */
+ return xy.hi + vzs + scalbn(xy.lo, spread);
+ }
+
+ if (oround != FE_TONEAREST) {
+ /*
+ * There is no need to worry about double rounding in directed
+ * rounding modes.
+ * But underflow may not be raised properly, example in downward rounding:
+ * fma(0x1.000000001p-1000, 0x1.000000001p-30, -0x1p-1066)
+ */
+ double ret;
+#if defined(FE_INEXACT) && defined(FE_UNDERFLOW)
+ int e = fetestexcept(FE_INEXACT);
+ feclearexcept(FE_INEXACT);
+#endif
+ fesetround(oround);
+ adj = r.lo + xy.lo;
+ ret = scalbn(r.hi + adj, spread);
+#if defined(FE_INEXACT) && defined(FE_UNDERFLOW)
+ if (ilogb(ret) < -1022 && fetestexcept(FE_INEXACT))
+ feraiseexcept(FE_UNDERFLOW);
+ else if (e)
+ feraiseexcept(FE_INEXACT);
+#endif
+ return ret;
+ }
+
+ adj = add_adjusted(r.lo, xy.lo);
+ if (spread + ilogb(r.hi) > -1023)
+ return scalbn(r.hi + adj, spread);
+ else
+ return add_and_denormalize(r.hi, adj, spread);
+}
+#endif
« no previous file with comments | « fusl/src/math/floorl.c ('k') | fusl/src/math/fmaf.c » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698