[fusl] clang-format fusl
R=viettrungluu@chromium.org
Review URL: https://codereview.chromium.org/1714623002 .
diff --git a/fusl/src/math/__cos.c b/fusl/src/math/__cos.c
index 46cefb3..f7a1af3 100644
--- a/fusl/src/math/__cos.c
+++ b/fusl/src/math/__cos.c
@@ -50,22 +50,21 @@
#include "libm.h"
-static const double
-C1 = 4.16666666666666019037e-02, /* 0x3FA55555, 0x5555554C */
-C2 = -1.38888888888741095749e-03, /* 0xBF56C16C, 0x16C15177 */
-C3 = 2.48015872894767294178e-05, /* 0x3EFA01A0, 0x19CB1590 */
-C4 = -2.75573143513906633035e-07, /* 0xBE927E4F, 0x809C52AD */
-C5 = 2.08757232129817482790e-09, /* 0x3E21EE9E, 0xBDB4B1C4 */
-C6 = -1.13596475577881948265e-11; /* 0xBDA8FAE9, 0xBE8838D4 */
+static const double C1 =
+ 4.16666666666666019037e-02, /* 0x3FA55555, 0x5555554C */
+ C2 = -1.38888888888741095749e-03, /* 0xBF56C16C, 0x16C15177 */
+ C3 = 2.48015872894767294178e-05, /* 0x3EFA01A0, 0x19CB1590 */
+ C4 = -2.75573143513906633035e-07, /* 0xBE927E4F, 0x809C52AD */
+ C5 = 2.08757232129817482790e-09, /* 0x3E21EE9E, 0xBDB4B1C4 */
+ C6 = -1.13596475577881948265e-11; /* 0xBDA8FAE9, 0xBE8838D4 */
-double __cos(double x, double y)
-{
- double_t hz,z,r,w;
+double __cos(double x, double y) {
+ double_t hz, z, r, w;
- z = x*x;
- w = z*z;
- r = z*(C1+z*(C2+z*C3)) + w*w*(C4+z*(C5+z*C6));
- hz = 0.5*z;
- w = 1.0-hz;
- return w + (((1.0-w)-hz) + (z*r-x*y));
+ z = x * x;
+ w = z * z;
+ r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));
+ hz = 0.5 * z;
+ w = 1.0 - hz;
+ return w + (((1.0 - w) - hz) + (z * r - x * y));
}
diff --git a/fusl/src/math/__cosdf.c b/fusl/src/math/__cosdf.c
index 2124989..7a97e76 100644
--- a/fusl/src/math/__cosdf.c
+++ b/fusl/src/math/__cosdf.c
@@ -17,19 +17,17 @@
#include "libm.h"
/* |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]). */
-static const double
-C0 = -0x1ffffffd0c5e81.0p-54, /* -0.499999997251031003120 */
-C1 = 0x155553e1053a42.0p-57, /* 0.0416666233237390631894 */
-C2 = -0x16c087e80f1e27.0p-62, /* -0.00138867637746099294692 */
-C3 = 0x199342e0ee5069.0p-68; /* 0.0000243904487962774090654 */
+static const double C0 = -0x1ffffffd0c5e81.0p-54, /* -0.499999997251031003120 */
+ C1 = 0x155553e1053a42.0p-57, /* 0.0416666233237390631894 */
+ C2 = -0x16c087e80f1e27.0p-62, /* -0.00138867637746099294692 */
+ C3 = 0x199342e0ee5069.0p-68; /* 0.0000243904487962774090654 */
-float __cosdf(double x)
-{
- double_t r, w, z;
+float __cosdf(double x) {
+ double_t r, w, z;
- /* Try to optimize for parallel evaluation as in __tandf.c. */
- z = x*x;
- w = z*z;
- r = C2+z*C3;
- return ((1.0+z*C0) + w*C1) + (w*z)*r;
+ /* Try to optimize for parallel evaluation as in __tandf.c. */
+ z = x * x;
+ w = z * z;
+ r = C2 + z * C3;
+ return ((1.0 + z * C0) + w * C1) + (w * z) * r;
}
diff --git a/fusl/src/math/__cosl.c b/fusl/src/math/__cosl.c
index fa522dd..b9aee53 100644
--- a/fusl/src/math/__cosl.c
+++ b/fusl/src/math/__cosl.c
@@ -12,7 +12,6 @@
* ====================================================
*/
-
#include "libm.h"
#if (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
@@ -43,16 +42,16 @@
* almost for free from the complications needed to search for the best
* higher coefficients.
*/
-static const long double
-C1 = 0.0416666666666666666136L; /* 0xaaaaaaaaaaaaaa9b.0p-68 */
-static const double
-C2 = -0.0013888888888888874, /* -0x16c16c16c16c10.0p-62 */
-C3 = 0.000024801587301571716, /* 0x1a01a01a018e22.0p-68 */
-C4 = -0.00000027557319215507120, /* -0x127e4fb7602f22.0p-74 */
-C5 = 0.0000000020876754400407278, /* 0x11eed8caaeccf1.0p-81 */
-C6 = -1.1470297442401303e-11, /* -0x19393412bd1529.0p-89 */
-C7 = 4.7383039476436467e-14; /* 0x1aac9d9af5c43e.0p-97 */
-#define POLY(z) (z*(C1+z*(C2+z*(C3+z*(C4+z*(C5+z*(C6+z*C7)))))))
+static const long double C1 =
+ 0.0416666666666666666136L; /* 0xaaaaaaaaaaaaaa9b.0p-68 */
+static const double C2 = -0.0013888888888888874, /* -0x16c16c16c16c10.0p-62 */
+ C3 = 0.000024801587301571716, /* 0x1a01a01a018e22.0p-68 */
+ C4 = -0.00000027557319215507120, /* -0x127e4fb7602f22.0p-74 */
+ C5 = 0.0000000020876754400407278, /* 0x11eed8caaeccf1.0p-81 */
+ C6 = -1.1470297442401303e-11, /* -0x19393412bd1529.0p-89 */
+ C7 = 4.7383039476436467e-14; /* 0x1aac9d9af5c43e.0p-97 */
+#define POLY(z) \
+ (z * (C1 + z * (C2 + z * (C3 + z * (C4 + z * (C5 + z * (C6 + z * C7)))))))
#elif LDBL_MANT_DIG == 113
/*
* ld128 version of __cos.c. See __cos.c for most comments.
@@ -66,31 +65,37 @@
* that is 1 ulp below 0.5, but we want it to be precisely 0.5. See
* above for more details.
*/
-static const long double
-C1 = 0.04166666666666666666666666666666658424671L,
-C2 = -0.001388888888888888888888888888863490893732L,
-C3 = 0.00002480158730158730158730158600795304914210L,
-C4 = -0.2755731922398589065255474947078934284324e-6L,
-C5 = 0.2087675698786809897659225313136400793948e-8L,
-C6 = -0.1147074559772972315817149986812031204775e-10L,
-C7 = 0.4779477332386808976875457937252120293400e-13L;
-static const double
-C8 = -0.1561920696721507929516718307820958119868e-15,
-C9 = 0.4110317413744594971475941557607804508039e-18,
-C10 = -0.8896592467191938803288521958313920156409e-21,
-C11 = 0.1601061435794535138244346256065192782581e-23;
-#define POLY(z) (z*(C1+z*(C2+z*(C3+z*(C4+z*(C5+z*(C6+z*(C7+ \
- z*(C8+z*(C9+z*(C10+z*C11)))))))))))
+static const long double C1 = 0.04166666666666666666666666666666658424671L,
+ C2 = -0.001388888888888888888888888888863490893732L,
+ C3 = 0.00002480158730158730158730158600795304914210L,
+ C4 = -0.2755731922398589065255474947078934284324e-6L,
+ C5 = 0.2087675698786809897659225313136400793948e-8L,
+ C6 = -0.1147074559772972315817149986812031204775e-10L,
+ C7 = 0.4779477332386808976875457937252120293400e-13L;
+static const double C8 = -0.1561920696721507929516718307820958119868e-15,
+ C9 = 0.4110317413744594971475941557607804508039e-18,
+ C10 = -0.8896592467191938803288521958313920156409e-21,
+ C11 = 0.1601061435794535138244346256065192782581e-23;
+#define POLY(z) \
+ (z * \
+ (C1 + \
+ z * (C2 + \
+ z * (C3 + \
+ z * (C4 + \
+ z * (C5 + \
+ z * (C6 + \
+ z * (C7 + \
+ z * (C8 + \
+ z * (C9 + z * (C10 + z * C11)))))))))))
#endif
-long double __cosl(long double x, long double y)
-{
- long double hz,z,r,w;
+long double __cosl(long double x, long double y) {
+ long double hz, z, r, w;
- z = x*x;
- r = POLY(z);
- hz = 0.5*z;
- w = 1.0-hz;
- return w + (((1.0-w)-hz) + (z*r-x*y));
+ z = x * x;
+ r = POLY(z);
+ hz = 0.5 * z;
+ w = 1.0 - hz;
+ return w + (((1.0 - w) - hz) + (z * r - x * y));
}
#endif
diff --git a/fusl/src/math/__expo2.c b/fusl/src/math/__expo2.c
index 740ac68..af66724 100644
--- a/fusl/src/math/__expo2.c
+++ b/fusl/src/math/__expo2.c
@@ -1,16 +1,16 @@
#include "libm.h"
-/* k is such that k*ln2 has minimal relative error and x - kln2 > log(DBL_MIN) */
+/* k is such that k*ln2 has minimal relative error and x - kln2 > log(DBL_MIN)
+ */
static const int k = 2043;
static const double kln2 = 0x1.62066151add8bp+10;
/* exp(x)/2 for x >= log(DBL_MAX), slightly better than 0.5*exp(x/2)*exp(x/2) */
-double __expo2(double x)
-{
- double scale;
+double __expo2(double x) {
+ double scale;
- /* note that k is odd and scale*scale overflows */
- INSERT_WORDS(scale, (uint32_t)(0x3ff + k/2) << 20, 0);
- /* exp(x - k ln2) * 2**(k-1) */
- return exp(x - kln2) * scale * scale;
+ /* note that k is odd and scale*scale overflows */
+ INSERT_WORDS(scale, (uint32_t)(0x3ff + k / 2) << 20, 0);
+ /* exp(x - k ln2) * 2**(k-1) */
+ return exp(x - kln2) * scale * scale;
}
diff --git a/fusl/src/math/__expo2f.c b/fusl/src/math/__expo2f.c
index 5163e41..f71e8b5 100644
--- a/fusl/src/math/__expo2f.c
+++ b/fusl/src/math/__expo2f.c
@@ -1,16 +1,17 @@
#include "libm.h"
-/* k is such that k*ln2 has minimal relative error and x - kln2 > log(FLT_MIN) */
+/* k is such that k*ln2 has minimal relative error and x - kln2 > log(FLT_MIN)
+ */
static const int k = 235;
static const float kln2 = 0x1.45c778p+7f;
-/* expf(x)/2 for x >= log(FLT_MAX), slightly better than 0.5f*expf(x/2)*expf(x/2) */
-float __expo2f(float x)
-{
- float scale;
+/* expf(x)/2 for x >= log(FLT_MAX), slightly better than
+ * 0.5f*expf(x/2)*expf(x/2) */
+float __expo2f(float x) {
+ float scale;
- /* note that k is odd and scale*scale overflows */
- SET_FLOAT_WORD(scale, (uint32_t)(0x7f + k/2) << 23);
- /* exp(x - k ln2) * 2**(k-1) */
- return expf(x - kln2) * scale * scale;
+ /* note that k is odd and scale*scale overflows */
+ SET_FLOAT_WORD(scale, (uint32_t)(0x7f + k / 2) << 23);
+ /* exp(x - k ln2) * 2**(k-1) */
+ return expf(x - kln2) * scale * scale;
}
diff --git a/fusl/src/math/__fpclassify.c b/fusl/src/math/__fpclassify.c
index f7c0e2d..17ee9db 100644
--- a/fusl/src/math/__fpclassify.c
+++ b/fusl/src/math/__fpclassify.c
@@ -1,11 +1,15 @@
#include <math.h>
#include <stdint.h>
-int __fpclassify(double x)
-{
- union {double f; uint64_t i;} u = {x};
- int e = u.i>>52 & 0x7ff;
- if (!e) return u.i<<1 ? FP_SUBNORMAL : FP_ZERO;
- if (e==0x7ff) return u.i<<12 ? FP_NAN : FP_INFINITE;
- return FP_NORMAL;
+int __fpclassify(double x) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {x};
+ int e = u.i >> 52 & 0x7ff;
+ if (!e)
+ return u.i << 1 ? FP_SUBNORMAL : FP_ZERO;
+ if (e == 0x7ff)
+ return u.i << 12 ? FP_NAN : FP_INFINITE;
+ return FP_NORMAL;
}
diff --git a/fusl/src/math/__fpclassifyf.c b/fusl/src/math/__fpclassifyf.c
index fd00eb1..842a0f1 100644
--- a/fusl/src/math/__fpclassifyf.c
+++ b/fusl/src/math/__fpclassifyf.c
@@ -1,11 +1,15 @@
#include <math.h>
#include <stdint.h>
-int __fpclassifyf(float x)
-{
- union {float f; uint32_t i;} u = {x};
- int e = u.i>>23 & 0xff;
- if (!e) return u.i<<1 ? FP_SUBNORMAL : FP_ZERO;
- if (e==0xff) return u.i<<9 ? FP_NAN : FP_INFINITE;
- return FP_NORMAL;
+int __fpclassifyf(float x) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {x};
+ int e = u.i >> 23 & 0xff;
+ if (!e)
+ return u.i << 1 ? FP_SUBNORMAL : FP_ZERO;
+ if (e == 0xff)
+ return u.i << 9 ? FP_NAN : FP_INFINITE;
+ return FP_NORMAL;
}
diff --git a/fusl/src/math/__fpclassifyl.c b/fusl/src/math/__fpclassifyl.c
index 481c0b9..30d54ac 100644
--- a/fusl/src/math/__fpclassifyl.c
+++ b/fusl/src/math/__fpclassifyl.c
@@ -1,34 +1,31 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-int __fpclassifyl(long double x)
-{
- return __fpclassify(x);
+int __fpclassifyl(long double x) {
+ return __fpclassify(x);
}
#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
-int __fpclassifyl(long double x)
-{
- union ldshape u = {x};
- int e = u.i.se & 0x7fff;
- int msb = u.i.m>>63;
- if (!e && !msb)
- return u.i.m ? FP_SUBNORMAL : FP_ZERO;
- if (!msb)
- return FP_NAN;
- if (e == 0x7fff)
- return u.i.m << 1 ? FP_NAN : FP_INFINITE;
- return FP_NORMAL;
+int __fpclassifyl(long double x) {
+ union ldshape u = {x};
+ int e = u.i.se & 0x7fff;
+ int msb = u.i.m >> 63;
+ if (!e && !msb)
+ return u.i.m ? FP_SUBNORMAL : FP_ZERO;
+ if (!msb)
+ return FP_NAN;
+ if (e == 0x7fff)
+ return u.i.m << 1 ? FP_NAN : FP_INFINITE;
+ return FP_NORMAL;
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
-int __fpclassifyl(long double x)
-{
- union ldshape u = {x};
- int e = u.i.se & 0x7fff;
- u.i.se = 0;
- if (!e)
- return u.i2.lo | u.i2.hi ? FP_SUBNORMAL : FP_ZERO;
- if (e == 0x7fff)
- return u.i2.lo | u.i2.hi ? FP_NAN : FP_INFINITE;
- return FP_NORMAL;
+int __fpclassifyl(long double x) {
+ union ldshape u = {x};
+ int e = u.i.se & 0x7fff;
+ u.i.se = 0;
+ if (!e)
+ return u.i2.lo | u.i2.hi ? FP_SUBNORMAL : FP_ZERO;
+ if (e == 0x7fff)
+ return u.i2.lo | u.i2.hi ? FP_NAN : FP_INFINITE;
+ return FP_NORMAL;
}
#endif
diff --git a/fusl/src/math/__invtrigl.c b/fusl/src/math/__invtrigl.c
index ef7f4e1..f9e05cf 100644
--- a/fusl/src/math/__invtrigl.c
+++ b/fusl/src/math/__invtrigl.c
@@ -2,62 +2,72 @@
#include "__invtrigl.h"
#if LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
-static const long double
-pS0 = 1.66666666666666666631e-01L,
-pS1 = -4.16313987993683104320e-01L,
-pS2 = 3.69068046323246813704e-01L,
-pS3 = -1.36213932016738603108e-01L,
-pS4 = 1.78324189708471965733e-02L,
-pS5 = -2.19216428382605211588e-04L,
-pS6 = -7.10526623669075243183e-06L,
-qS1 = -2.94788392796209867269e+00L,
-qS2 = 3.27309890266528636716e+00L,
-qS3 = -1.68285799854822427013e+00L,
-qS4 = 3.90699412641738801874e-01L,
-qS5 = -3.14365703596053263322e-02L;
+static const long double pS0 = 1.66666666666666666631e-01L,
+ pS1 = -4.16313987993683104320e-01L,
+ pS2 = 3.69068046323246813704e-01L,
+ pS3 = -1.36213932016738603108e-01L,
+ pS4 = 1.78324189708471965733e-02L,
+ pS5 = -2.19216428382605211588e-04L,
+ pS6 = -7.10526623669075243183e-06L,
+ qS1 = -2.94788392796209867269e+00L,
+ qS2 = 3.27309890266528636716e+00L,
+ qS3 = -1.68285799854822427013e+00L,
+ qS4 = 3.90699412641738801874e-01L,
+ qS5 = -3.14365703596053263322e-02L;
const long double pio2_hi = 1.57079632679489661926L;
const long double pio2_lo = -2.50827880633416601173e-20L;
/* used in asinl() and acosl() */
/* R(x^2) is a rational approximation of (asin(x)-x)/x^3 with Remez algorithm */
-long double __invtrigl_R(long double z)
-{
- long double p, q;
- p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*(pS5+z*pS6))))));
- q = 1.0+z*(qS1+z*(qS2+z*(qS3+z*(qS4+z*qS5))));
- return p/q;
+long double __invtrigl_R(long double z) {
+ long double p, q;
+ p = z * (pS0 +
+ z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * (pS5 + z * pS6))))));
+ q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * (qS4 + z * qS5))));
+ return p / q;
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
-static const long double
-pS0 = 1.66666666666666666666666666666700314e-01L,
-pS1 = -7.32816946414566252574527475428622708e-01L,
-pS2 = 1.34215708714992334609030036562143589e+00L,
-pS3 = -1.32483151677116409805070261790752040e+00L,
-pS4 = 7.61206183613632558824485341162121989e-01L,
-pS5 = -2.56165783329023486777386833928147375e-01L,
-pS6 = 4.80718586374448793411019434585413855e-02L,
-pS7 = -4.42523267167024279410230886239774718e-03L,
-pS8 = 1.44551535183911458253205638280410064e-04L,
-pS9 = -2.10558957916600254061591040482706179e-07L,
-qS1 = -4.84690167848739751544716485245697428e+00L,
-qS2 = 9.96619113536172610135016921140206980e+00L,
-qS3 = -1.13177895428973036660836798461641458e+01L,
-qS4 = 7.74004374389488266169304117714658761e+00L,
-qS5 = -3.25871986053534084709023539900339905e+00L,
-qS6 = 8.27830318881232209752469022352928864e-01L,
-qS7 = -1.18768052702942805423330715206348004e-01L,
-qS8 = 8.32600764660522313269101537926539470e-03L,
-qS9 = -1.99407384882605586705979504567947007e-04L;
+static const long double pS0 = 1.66666666666666666666666666666700314e-01L,
+ pS1 = -7.32816946414566252574527475428622708e-01L,
+ pS2 = 1.34215708714992334609030036562143589e+00L,
+ pS3 = -1.32483151677116409805070261790752040e+00L,
+ pS4 = 7.61206183613632558824485341162121989e-01L,
+ pS5 = -2.56165783329023486777386833928147375e-01L,
+ pS6 = 4.80718586374448793411019434585413855e-02L,
+ pS7 = -4.42523267167024279410230886239774718e-03L,
+ pS8 = 1.44551535183911458253205638280410064e-04L,
+ pS9 = -2.10558957916600254061591040482706179e-07L,
+ qS1 = -4.84690167848739751544716485245697428e+00L,
+ qS2 = 9.96619113536172610135016921140206980e+00L,
+ qS3 = -1.13177895428973036660836798461641458e+01L,
+ qS4 = 7.74004374389488266169304117714658761e+00L,
+ qS5 = -3.25871986053534084709023539900339905e+00L,
+ qS6 = 8.27830318881232209752469022352928864e-01L,
+ qS7 = -1.18768052702942805423330715206348004e-01L,
+ qS8 = 8.32600764660522313269101537926539470e-03L,
+ qS9 = -1.99407384882605586705979504567947007e-04L;
const long double pio2_hi = 1.57079632679489661923132169163975140L;
const long double pio2_lo = 4.33590506506189051239852201302167613e-35L;
-long double __invtrigl_R(long double z)
-{
- long double p, q;
- p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*(pS5+z*(pS6+z*(pS7+z*(pS8+z*pS9)))))))));
- q = 1.0+z*(qS1+z*(qS2+z*(qS3+z*(qS4+z*(qS5+z*(pS6+z*(pS7+z*(pS8+z*pS9))))))));
- return p/q;
+long double __invtrigl_R(long double z) {
+ long double p, q;
+ p = z * (pS0 +
+ z * (pS1 +
+ z * (pS2 +
+ z * (pS3 +
+ z * (pS4 +
+ z * (pS5 +
+ z * (pS6 +
+ z * (pS7 + z * (pS8 + z * pS9)))))))));
+ q = 1.0 +
+ z * (qS1 +
+ z * (qS2 +
+ z * (qS3 +
+ z * (qS4 +
+ z * (qS5 +
+ z * (pS6 + z * (pS7 + z * (pS8 + z * pS9))))))));
+ return p / q;
}
#endif
diff --git a/fusl/src/math/__polevll.c b/fusl/src/math/__polevll.c
index ce1a840..093b4bc 100644
--- a/fusl/src/math/__polevll.c
+++ b/fusl/src/math/__polevll.c
@@ -62,32 +62,30 @@
* Polynomial evaluator:
* P[0] x^n + P[1] x^(n-1) + ... + P[n]
*/
-long double __polevll(long double x, const long double *P, int n)
-{
- long double y;
+long double __polevll(long double x, const long double* P, int n) {
+ long double y;
- y = *P++;
- do {
- y = y * x + *P++;
- } while (--n);
+ y = *P++;
+ do {
+ y = y * x + *P++;
+ } while (--n);
- return y;
+ return y;
}
/*
* Polynomial evaluator:
* x^n + P[0] x^(n-1) + P[1] x^(n-2) + ... + P[n]
*/
-long double __p1evll(long double x, const long double *P, int n)
-{
- long double y;
+long double __p1evll(long double x, const long double* P, int n) {
+ long double y;
- n -= 1;
- y = x + *P++;
- do {
- y = y * x + *P++;
- } while (--n);
+ n -= 1;
+ y = x + *P++;
+ do {
+ y = y * x + *P++;
+ } while (--n);
- return y;
+ return y;
}
#endif
diff --git a/fusl/src/math/__rem_pio2.c b/fusl/src/math/__rem_pio2.c
index d403f81..025ce4e 100644
--- a/fusl/src/math/__rem_pio2.c
+++ b/fusl/src/math/__rem_pio2.c
@@ -19,9 +19,9 @@
#include "libm.h"
-#if FLT_EVAL_METHOD==0 || FLT_EVAL_METHOD==1
+#if FLT_EVAL_METHOD == 0 || FLT_EVAL_METHOD == 1
#define EPS DBL_EPSILON
-#elif FLT_EVAL_METHOD==2
+#elif FLT_EVAL_METHOD == 2
#define EPS LDBL_EPSILON
#endif
@@ -34,144 +34,146 @@
* pio2_3: third 33 bit of pi/2
* pio2_3t: pi/2 - (pio2_1+pio2_2+pio2_3)
*/
-static const double
-toint = 1.5/EPS,
-invpio2 = 6.36619772367581382433e-01, /* 0x3FE45F30, 0x6DC9C883 */
-pio2_1 = 1.57079632673412561417e+00, /* 0x3FF921FB, 0x54400000 */
-pio2_1t = 6.07710050650619224932e-11, /* 0x3DD0B461, 0x1A626331 */
-pio2_2 = 6.07710050630396597660e-11, /* 0x3DD0B461, 0x1A600000 */
-pio2_2t = 2.02226624879595063154e-21, /* 0x3BA3198A, 0x2E037073 */
-pio2_3 = 2.02226624871116645580e-21, /* 0x3BA3198A, 0x2E000000 */
-pio2_3t = 8.47842766036889956997e-32; /* 0x397B839A, 0x252049C1 */
+static const double toint = 1.5 / EPS,
+ invpio2 =
+ 6.36619772367581382433e-01, /* 0x3FE45F30, 0x6DC9C883 */
+ pio2_1 = 1.57079632673412561417e+00, /* 0x3FF921FB, 0x54400000 */
+ pio2_1t = 6.07710050650619224932e-11, /* 0x3DD0B461, 0x1A626331 */
+ pio2_2 = 6.07710050630396597660e-11, /* 0x3DD0B461, 0x1A600000 */
+ pio2_2t = 2.02226624879595063154e-21, /* 0x3BA3198A, 0x2E037073 */
+ pio2_3 = 2.02226624871116645580e-21, /* 0x3BA3198A, 0x2E000000 */
+ pio2_3t = 8.47842766036889956997e-32; /* 0x397B839A, 0x252049C1 */
/* caller must handle the case when reduction is not needed: |x| ~<= pi/4 */
-int __rem_pio2(double x, double *y)
-{
- union {double f; uint64_t i;} u = {x};
- double_t z,w,t,r,fn;
- double tx[3],ty[2];
- uint32_t ix;
- int sign, n, ex, ey, i;
+int __rem_pio2(double x, double* y) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {x};
+ double_t z, w, t, r, fn;
+ double tx[3], ty[2];
+ uint32_t ix;
+ int sign, n, ex, ey, i;
- sign = u.i>>63;
- ix = u.i>>32 & 0x7fffffff;
- if (ix <= 0x400f6a7a) { /* |x| ~<= 5pi/4 */
- if ((ix & 0xfffff) == 0x921fb) /* |x| ~= pi/2 or 2pi/2 */
- goto medium; /* cancellation -- use medium case */
- if (ix <= 0x4002d97c) { /* |x| ~<= 3pi/4 */
- if (!sign) {
- z = x - pio2_1; /* one round good to 85 bits */
- y[0] = z - pio2_1t;
- y[1] = (z-y[0]) - pio2_1t;
- return 1;
- } else {
- z = x + pio2_1;
- y[0] = z + pio2_1t;
- y[1] = (z-y[0]) + pio2_1t;
- return -1;
- }
- } else {
- if (!sign) {
- z = x - 2*pio2_1;
- y[0] = z - 2*pio2_1t;
- y[1] = (z-y[0]) - 2*pio2_1t;
- return 2;
- } else {
- z = x + 2*pio2_1;
- y[0] = z + 2*pio2_1t;
- y[1] = (z-y[0]) + 2*pio2_1t;
- return -2;
- }
- }
- }
- if (ix <= 0x401c463b) { /* |x| ~<= 9pi/4 */
- if (ix <= 0x4015fdbc) { /* |x| ~<= 7pi/4 */
- if (ix == 0x4012d97c) /* |x| ~= 3pi/2 */
- goto medium;
- if (!sign) {
- z = x - 3*pio2_1;
- y[0] = z - 3*pio2_1t;
- y[1] = (z-y[0]) - 3*pio2_1t;
- return 3;
- } else {
- z = x + 3*pio2_1;
- y[0] = z + 3*pio2_1t;
- y[1] = (z-y[0]) + 3*pio2_1t;
- return -3;
- }
- } else {
- if (ix == 0x401921fb) /* |x| ~= 4pi/2 */
- goto medium;
- if (!sign) {
- z = x - 4*pio2_1;
- y[0] = z - 4*pio2_1t;
- y[1] = (z-y[0]) - 4*pio2_1t;
- return 4;
- } else {
- z = x + 4*pio2_1;
- y[0] = z + 4*pio2_1t;
- y[1] = (z-y[0]) + 4*pio2_1t;
- return -4;
- }
- }
- }
- if (ix < 0x413921fb) { /* |x| ~< 2^20*(pi/2), medium size */
-medium:
- /* rint(x/(pi/2)), Assume round-to-nearest. */
- fn = (double_t)x*invpio2 + toint - toint;
- n = (int32_t)fn;
- r = x - fn*pio2_1;
- w = fn*pio2_1t; /* 1st round, good to 85 bits */
- y[0] = r - w;
- u.f = y[0];
- ey = u.i>>52 & 0x7ff;
- ex = ix>>20;
- if (ex - ey > 16) { /* 2nd round, good to 118 bits */
- t = r;
- w = fn*pio2_2;
- r = t - w;
- w = fn*pio2_2t - ((t-r)-w);
- y[0] = r - w;
- u.f = y[0];
- ey = u.i>>52 & 0x7ff;
- if (ex - ey > 49) { /* 3rd round, good to 151 bits, covers all cases */
- t = r;
- w = fn*pio2_3;
- r = t - w;
- w = fn*pio2_3t - ((t-r)-w);
- y[0] = r - w;
- }
- }
- y[1] = (r - y[0]) - w;
- return n;
- }
- /*
- * all other (large) arguments
- */
- if (ix >= 0x7ff00000) { /* x is inf or NaN */
- y[0] = y[1] = x - x;
- return 0;
- }
- /* set z = scalbn(|x|,-ilogb(x)+23) */
- u.f = x;
- u.i &= (uint64_t)-1>>12;
- u.i |= (uint64_t)(0x3ff + 23)<<52;
- z = u.f;
- for (i=0; i < 2; i++) {
- tx[i] = (double)(int32_t)z;
- z = (z-tx[i])*0x1p24;
- }
- tx[i] = z;
- /* skip zero terms, first term is non-zero */
- while (tx[i] == 0.0)
- i--;
- n = __rem_pio2_large(tx,ty,(int)(ix>>20)-(0x3ff+23),i+1,1);
- if (sign) {
- y[0] = -ty[0];
- y[1] = -ty[1];
- return -n;
- }
- y[0] = ty[0];
- y[1] = ty[1];
- return n;
+ sign = u.i >> 63;
+ ix = u.i >> 32 & 0x7fffffff;
+ if (ix <= 0x400f6a7a) { /* |x| ~<= 5pi/4 */
+ if ((ix & 0xfffff) == 0x921fb) /* |x| ~= pi/2 or 2pi/2 */
+ goto medium; /* cancellation -- use medium case */
+ if (ix <= 0x4002d97c) { /* |x| ~<= 3pi/4 */
+ if (!sign) {
+ z = x - pio2_1; /* one round good to 85 bits */
+ y[0] = z - pio2_1t;
+ y[1] = (z - y[0]) - pio2_1t;
+ return 1;
+ } else {
+ z = x + pio2_1;
+ y[0] = z + pio2_1t;
+ y[1] = (z - y[0]) + pio2_1t;
+ return -1;
+ }
+ } else {
+ if (!sign) {
+ z = x - 2 * pio2_1;
+ y[0] = z - 2 * pio2_1t;
+ y[1] = (z - y[0]) - 2 * pio2_1t;
+ return 2;
+ } else {
+ z = x + 2 * pio2_1;
+ y[0] = z + 2 * pio2_1t;
+ y[1] = (z - y[0]) + 2 * pio2_1t;
+ return -2;
+ }
+ }
+ }
+ if (ix <= 0x401c463b) { /* |x| ~<= 9pi/4 */
+ if (ix <= 0x4015fdbc) { /* |x| ~<= 7pi/4 */
+ if (ix == 0x4012d97c) /* |x| ~= 3pi/2 */
+ goto medium;
+ if (!sign) {
+ z = x - 3 * pio2_1;
+ y[0] = z - 3 * pio2_1t;
+ y[1] = (z - y[0]) - 3 * pio2_1t;
+ return 3;
+ } else {
+ z = x + 3 * pio2_1;
+ y[0] = z + 3 * pio2_1t;
+ y[1] = (z - y[0]) + 3 * pio2_1t;
+ return -3;
+ }
+ } else {
+ if (ix == 0x401921fb) /* |x| ~= 4pi/2 */
+ goto medium;
+ if (!sign) {
+ z = x - 4 * pio2_1;
+ y[0] = z - 4 * pio2_1t;
+ y[1] = (z - y[0]) - 4 * pio2_1t;
+ return 4;
+ } else {
+ z = x + 4 * pio2_1;
+ y[0] = z + 4 * pio2_1t;
+ y[1] = (z - y[0]) + 4 * pio2_1t;
+ return -4;
+ }
+ }
+ }
+ if (ix < 0x413921fb) { /* |x| ~< 2^20*(pi/2), medium size */
+ medium:
+ /* rint(x/(pi/2)), Assume round-to-nearest. */
+ fn = (double_t)x * invpio2 + toint - toint;
+ n = (int32_t)fn;
+ r = x - fn * pio2_1;
+ w = fn * pio2_1t; /* 1st round, good to 85 bits */
+ y[0] = r - w;
+ u.f = y[0];
+ ey = u.i >> 52 & 0x7ff;
+ ex = ix >> 20;
+ if (ex - ey > 16) { /* 2nd round, good to 118 bits */
+ t = r;
+ w = fn * pio2_2;
+ r = t - w;
+ w = fn * pio2_2t - ((t - r) - w);
+ y[0] = r - w;
+ u.f = y[0];
+ ey = u.i >> 52 & 0x7ff;
+ if (ex - ey > 49) { /* 3rd round, good to 151 bits, covers all cases */
+ t = r;
+ w = fn * pio2_3;
+ r = t - w;
+ w = fn * pio2_3t - ((t - r) - w);
+ y[0] = r - w;
+ }
+ }
+ y[1] = (r - y[0]) - w;
+ return n;
+ }
+ /*
+ * all other (large) arguments
+ */
+ if (ix >= 0x7ff00000) { /* x is inf or NaN */
+ y[0] = y[1] = x - x;
+ return 0;
+ }
+ /* set z = scalbn(|x|,-ilogb(x)+23) */
+ u.f = x;
+ u.i &= (uint64_t)-1 >> 12;
+ u.i |= (uint64_t)(0x3ff + 23) << 52;
+ z = u.f;
+ for (i = 0; i < 2; i++) {
+ tx[i] = (double)(int32_t)z;
+ z = (z - tx[i]) * 0x1p24;
+ }
+ tx[i] = z;
+ /* skip zero terms, first term is non-zero */
+ while (tx[i] == 0.0)
+ i--;
+ n = __rem_pio2_large(tx, ty, (int)(ix >> 20) - (0x3ff + 23), i + 1, 1);
+ if (sign) {
+ y[0] = -ty[0];
+ y[1] = -ty[1];
+ return -n;
+ }
+ y[0] = ty[0];
+ y[1] = ty[1];
+ return n;
}
diff --git a/fusl/src/math/__rem_pio2_large.c b/fusl/src/math/__rem_pio2_large.c
index 958f28c..9381d0e 100644
--- a/fusl/src/math/__rem_pio2_large.c
+++ b/fusl/src/math/__rem_pio2_large.c
@@ -124,7 +124,7 @@
#include "libm.h"
-static const int init_jk[] = {3,4,4,6}; /* initial value for jk */
+static const int init_jk[] = {3, 4, 4, 6}; /* initial value for jk */
/*
* Table of constants for 2/pi, 396 Hex digits (476 decimal) of 2/pi
@@ -139,304 +139,302 @@
* For quad precision (e0 <= 16360, jk = 6), this is 686.
*/
static const int32_t ipio2[] = {
-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,
+ 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,
#if LDBL_MAX_EXP > 1024
-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,
+ 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,
#endif
};
static const double PIo2[] = {
- 1.57079625129699707031e+00, /* 0x3FF921FB, 0x40000000 */
- 7.54978941586159635335e-08, /* 0x3E74442D, 0x00000000 */
- 5.39030252995776476554e-15, /* 0x3CF84698, 0x80000000 */
- 3.28200341580791294123e-22, /* 0x3B78CC51, 0x60000000 */
- 1.27065575308067607349e-29, /* 0x39F01B83, 0x80000000 */
- 1.22933308981111328932e-36, /* 0x387A2520, 0x40000000 */
- 2.73370053816464559624e-44, /* 0x36E38222, 0x80000000 */
- 2.16741683877804819444e-51, /* 0x3569F31D, 0x00000000 */
+ 1.57079625129699707031e+00, /* 0x3FF921FB, 0x40000000 */
+ 7.54978941586159635335e-08, /* 0x3E74442D, 0x00000000 */
+ 5.39030252995776476554e-15, /* 0x3CF84698, 0x80000000 */
+ 3.28200341580791294123e-22, /* 0x3B78CC51, 0x60000000 */
+ 1.27065575308067607349e-29, /* 0x39F01B83, 0x80000000 */
+ 1.22933308981111328932e-36, /* 0x387A2520, 0x40000000 */
+ 2.73370053816464559624e-44, /* 0x36E38222, 0x80000000 */
+ 2.16741683877804819444e-51, /* 0x3569F31D, 0x00000000 */
};
-int __rem_pio2_large(double *x, double *y, int e0, int nx, int prec)
-{
- int32_t jz,jx,jv,jp,jk,carry,n,iq[20],i,j,k,m,q0,ih;
- double z,fw,f[20],fq[20],q[20];
+int __rem_pio2_large(double* x, double* y, int e0, int nx, int prec) {
+ int32_t jz, jx, jv, jp, jk, carry, n, iq[20], i, j, k, m, q0, ih;
+ double z, fw, f[20], fq[20], q[20];
- /* initialize jk*/
- jk = init_jk[prec];
- jp = jk;
+ /* initialize jk*/
+ jk = init_jk[prec];
+ jp = jk;
- /* determine jx,jv,q0, note that 3>q0 */
- jx = nx-1;
- jv = (e0-3)/24; if(jv<0) jv=0;
- q0 = e0-24*(jv+1);
+ /* determine jx,jv,q0, note that 3>q0 */
+ jx = nx - 1;
+ jv = (e0 - 3) / 24;
+ if (jv < 0)
+ jv = 0;
+ q0 = e0 - 24 * (jv + 1);
- /* set up f[0] to f[jx+jk] where f[jx+jk] = ipio2[jv+jk] */
- j = jv-jx; m = jx+jk;
- for (i=0; i<=m; i++,j++)
- f[i] = j<0 ? 0.0 : (double)ipio2[j];
+ /* set up f[0] to f[jx+jk] where f[jx+jk] = ipio2[jv+jk] */
+ j = jv - jx;
+ m = jx + jk;
+ for (i = 0; i <= m; i++, j++)
+ f[i] = j < 0 ? 0.0 : (double)ipio2[j];
- /* compute q[0],q[1],...q[jk] */
- for (i=0; i<=jk; i++) {
- for (j=0,fw=0.0; j<=jx; j++)
- fw += x[j]*f[jx+i-j];
- q[i] = fw;
- }
+ /* compute q[0],q[1],...q[jk] */
+ for (i = 0; i <= jk; i++) {
+ for (j = 0, fw = 0.0; j <= jx; j++)
+ fw += x[j] * f[jx + i - j];
+ q[i] = fw;
+ }
- jz = jk;
+ jz = jk;
recompute:
- /* distill q[] into iq[] reversingly */
- for (i=0,j=jz,z=q[jz]; j>0; i++,j--) {
- fw = (double)(int32_t)(0x1p-24*z);
- iq[i] = (int32_t)(z - 0x1p24*fw);
- z = q[j-1]+fw;
- }
+ /* distill q[] into iq[] reversingly */
+ for (i = 0, j = jz, z = q[jz]; j > 0; i++, j--) {
+ fw = (double)(int32_t)(0x1p-24 * z);
+ iq[i] = (int32_t)(z - 0x1p24 * fw);
+ z = q[j - 1] + fw;
+ }
- /* compute n */
- z = scalbn(z,q0); /* actual value of z */
- z -= 8.0*floor(z*0.125); /* trim off integer >= 8 */
- n = (int32_t)z;
- z -= (double)n;
- ih = 0;
- if (q0 > 0) { /* need iq[jz-1] to determine n */
- i = iq[jz-1]>>(24-q0); n += i;
- iq[jz-1] -= i<<(24-q0);
- ih = iq[jz-1]>>(23-q0);
- }
- else if (q0 == 0) ih = iq[jz-1]>>23;
- else if (z >= 0.5) ih = 2;
+ /* compute n */
+ z = scalbn(z, q0); /* actual value of z */
+ z -= 8.0 * floor(z * 0.125); /* trim off integer >= 8 */
+ n = (int32_t)z;
+ z -= (double)n;
+ ih = 0;
+ if (q0 > 0) { /* need iq[jz-1] to determine n */
+ i = iq[jz - 1] >> (24 - q0);
+ n += i;
+ iq[jz - 1] -= i << (24 - q0);
+ ih = iq[jz - 1] >> (23 - q0);
+ } else if (q0 == 0)
+ ih = iq[jz - 1] >> 23;
+ else if (z >= 0.5)
+ ih = 2;
- if (ih > 0) { /* q > 0.5 */
- n += 1; carry = 0;
- for (i=0; i<jz; i++) { /* compute 1-q */
- j = iq[i];
- if (carry == 0) {
- if (j != 0) {
- carry = 1;
- iq[i] = 0x1000000 - j;
- }
- } else
- iq[i] = 0xffffff - j;
- }
- if (q0 > 0) { /* rare case: chance is 1 in 12 */
- switch(q0) {
- case 1:
- iq[jz-1] &= 0x7fffff; break;
- case 2:
- iq[jz-1] &= 0x3fffff; break;
- }
- }
- if (ih == 2) {
- z = 1.0 - z;
- if (carry != 0)
- z -= scalbn(1.0,q0);
- }
- }
+ if (ih > 0) { /* q > 0.5 */
+ n += 1;
+ carry = 0;
+ for (i = 0; i < jz; i++) { /* compute 1-q */
+ j = iq[i];
+ if (carry == 0) {
+ if (j != 0) {
+ carry = 1;
+ iq[i] = 0x1000000 - j;
+ }
+ } else
+ iq[i] = 0xffffff - j;
+ }
+ if (q0 > 0) { /* rare case: chance is 1 in 12 */
+ switch (q0) {
+ case 1:
+ iq[jz - 1] &= 0x7fffff;
+ break;
+ case 2:
+ iq[jz - 1] &= 0x3fffff;
+ break;
+ }
+ }
+ if (ih == 2) {
+ z = 1.0 - z;
+ if (carry != 0)
+ z -= scalbn(1.0, q0);
+ }
+ }
- /* check if recomputation is needed */
- if (z == 0.0) {
- j = 0;
- for (i=jz-1; i>=jk; i--) j |= iq[i];
- if (j == 0) { /* need recomputation */
- for (k=1; iq[jk-k]==0; k++); /* k = no. of terms needed */
+ /* check if recomputation is needed */
+ if (z == 0.0) {
+ j = 0;
+ for (i = jz - 1; i >= jk; i--)
+ j |= iq[i];
+ if (j == 0) { /* need recomputation */
+ for (k = 1; iq[jk - k] == 0; k++)
+ ; /* k = no. of terms needed */
- for (i=jz+1; i<=jz+k; i++) { /* add q[jz+1] to q[jz+k] */
- f[jx+i] = (double)ipio2[jv+i];
- for (j=0,fw=0.0; j<=jx; j++)
- fw += x[j]*f[jx+i-j];
- q[i] = fw;
- }
- jz += k;
- goto recompute;
- }
- }
+ for (i = jz + 1; i <= jz + k; i++) { /* add q[jz+1] to q[jz+k] */
+ f[jx + i] = (double)ipio2[jv + i];
+ for (j = 0, fw = 0.0; j <= jx; j++)
+ fw += x[j] * f[jx + i - j];
+ q[i] = fw;
+ }
+ jz += k;
+ goto recompute;
+ }
+ }
- /* chop off zero terms */
- if (z == 0.0) {
- jz -= 1;
- q0 -= 24;
- while (iq[jz] == 0) {
- jz--;
- q0 -= 24;
- }
- } else { /* break z into 24-bit if necessary */
- z = scalbn(z,-q0);
- if (z >= 0x1p24) {
- fw = (double)(int32_t)(0x1p-24*z);
- iq[jz] = (int32_t)(z - 0x1p24*fw);
- jz += 1;
- q0 += 24;
- iq[jz] = (int32_t)fw;
- } else
- iq[jz] = (int32_t)z;
- }
+ /* chop off zero terms */
+ if (z == 0.0) {
+ jz -= 1;
+ q0 -= 24;
+ while (iq[jz] == 0) {
+ jz--;
+ q0 -= 24;
+ }
+ } else { /* break z into 24-bit if necessary */
+ z = scalbn(z, -q0);
+ if (z >= 0x1p24) {
+ fw = (double)(int32_t)(0x1p-24 * z);
+ iq[jz] = (int32_t)(z - 0x1p24 * fw);
+ jz += 1;
+ q0 += 24;
+ iq[jz] = (int32_t)fw;
+ } else
+ iq[jz] = (int32_t)z;
+ }
- /* convert integer "bit" chunk to floating-point value */
- fw = scalbn(1.0,q0);
- for (i=jz; i>=0; i--) {
- q[i] = fw*(double)iq[i];
- fw *= 0x1p-24;
- }
+ /* convert integer "bit" chunk to floating-point value */
+ fw = scalbn(1.0, q0);
+ for (i = jz; i >= 0; i--) {
+ q[i] = fw * (double)iq[i];
+ fw *= 0x1p-24;
+ }
- /* compute PIo2[0,...,jp]*q[jz,...,0] */
- for(i=jz; i>=0; i--) {
- for (fw=0.0,k=0; k<=jp && k<=jz-i; k++)
- fw += PIo2[k]*q[i+k];
- fq[jz-i] = fw;
- }
+ /* compute PIo2[0,...,jp]*q[jz,...,0] */
+ for (i = jz; i >= 0; i--) {
+ for (fw = 0.0, k = 0; k <= jp && k <= jz - i; k++)
+ fw += PIo2[k] * q[i + k];
+ fq[jz - i] = fw;
+ }
- /* compress fq[] into y[] */
- switch(prec) {
- case 0:
- fw = 0.0;
- for (i=jz; i>=0; i--)
- fw += fq[i];
- y[0] = ih==0 ? fw : -fw;
- break;
- case 1:
- case 2:
- fw = 0.0;
- for (i=jz; i>=0; i--)
- fw += fq[i];
- // TODO: drop excess precision here once double_t is used
- fw = (double)fw;
- y[0] = ih==0 ? fw : -fw;
- fw = fq[0]-fw;
- for (i=1; i<=jz; i++)
- fw += fq[i];
- y[1] = ih==0 ? fw : -fw;
- break;
- case 3: /* painful */
- for (i=jz; i>0; i--) {
- fw = fq[i-1]+fq[i];
- fq[i] += fq[i-1]-fw;
- fq[i-1] = fw;
- }
- for (i=jz; i>1; i--) {
- fw = fq[i-1]+fq[i];
- fq[i] += fq[i-1]-fw;
- fq[i-1] = fw;
- }
- for (fw=0.0,i=jz; i>=2; i--)
- fw += fq[i];
- if (ih==0) {
- y[0] = fq[0]; y[1] = fq[1]; y[2] = fw;
- } else {
- y[0] = -fq[0]; y[1] = -fq[1]; y[2] = -fw;
- }
- }
- return n&7;
+ /* compress fq[] into y[] */
+ switch (prec) {
+ case 0:
+ fw = 0.0;
+ for (i = jz; i >= 0; i--)
+ fw += fq[i];
+ y[0] = ih == 0 ? fw : -fw;
+ break;
+ case 1:
+ case 2:
+ fw = 0.0;
+ for (i = jz; i >= 0; i--)
+ fw += fq[i];
+ // TODO: drop excess precision here once double_t is used
+ fw = (double)fw;
+ y[0] = ih == 0 ? fw : -fw;
+ fw = fq[0] - fw;
+ for (i = 1; i <= jz; i++)
+ fw += fq[i];
+ y[1] = ih == 0 ? fw : -fw;
+ break;
+ case 3: /* painful */
+ for (i = jz; i > 0; i--) {
+ fw = fq[i - 1] + fq[i];
+ fq[i] += fq[i - 1] - fw;
+ fq[i - 1] = fw;
+ }
+ for (i = jz; i > 1; i--) {
+ fw = fq[i - 1] + fq[i];
+ fq[i] += fq[i - 1] - fw;
+ fq[i - 1] = fw;
+ }
+ for (fw = 0.0, i = jz; i >= 2; i--)
+ fw += fq[i];
+ if (ih == 0) {
+ y[0] = fq[0];
+ y[1] = fq[1];
+ y[2] = fw;
+ } else {
+ y[0] = -fq[0];
+ y[1] = -fq[1];
+ y[2] = -fw;
+ }
+ }
+ return n & 7;
}
diff --git a/fusl/src/math/__rem_pio2f.c b/fusl/src/math/__rem_pio2f.c
index 4473c1c..e1d6a0d 100644
--- a/fusl/src/math/__rem_pio2f.c
+++ b/fusl/src/math/__rem_pio2f.c
@@ -22,9 +22,9 @@
#include "libm.h"
-#if FLT_EVAL_METHOD==0 || FLT_EVAL_METHOD==1
+#if FLT_EVAL_METHOD == 0 || FLT_EVAL_METHOD == 1
#define EPS DBL_EPSILON
-#elif FLT_EVAL_METHOD==2
+#elif FLT_EVAL_METHOD == 2
#define EPS LDBL_EPSILON
#endif
@@ -33,43 +33,45 @@
* pio2_1: first 25 bits of pi/2
* pio2_1t: pi/2 - pio2_1
*/
-static const double
-toint = 1.5/EPS,
-invpio2 = 6.36619772367581382433e-01, /* 0x3FE45F30, 0x6DC9C883 */
-pio2_1 = 1.57079631090164184570e+00, /* 0x3FF921FB, 0x50000000 */
-pio2_1t = 1.58932547735281966916e-08; /* 0x3E5110b4, 0x611A6263 */
+static const double toint = 1.5 / EPS,
+ invpio2 =
+ 6.36619772367581382433e-01, /* 0x3FE45F30, 0x6DC9C883 */
+ pio2_1 = 1.57079631090164184570e+00, /* 0x3FF921FB, 0x50000000 */
+ pio2_1t = 1.58932547735281966916e-08; /* 0x3E5110b4, 0x611A6263 */
-int __rem_pio2f(float x, double *y)
-{
- union {float f; uint32_t i;} u = {x};
- double tx[1],ty[1];
- double_t fn;
- uint32_t ix;
- int n, sign, e0;
+int __rem_pio2f(float x, double* y) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {x};
+ double tx[1], ty[1];
+ double_t fn;
+ uint32_t ix;
+ int n, sign, e0;
- ix = u.i & 0x7fffffff;
- /* 25+53 bit pi is good enough for medium size */
- if (ix < 0x4dc90fdb) { /* |x| ~< 2^28*(pi/2), medium size */
- /* Use a specialized rint() to get fn. Assume round-to-nearest. */
- fn = (double_t)x*invpio2 + toint - toint;
- n = (int32_t)fn;
- *y = x - fn*pio2_1 - fn*pio2_1t;
- return n;
- }
- if(ix>=0x7f800000) { /* x is inf or NaN */
- *y = x-x;
- return 0;
- }
- /* scale x into [2^23, 2^24-1] */
- sign = u.i>>31;
- e0 = (ix>>23) - (0x7f+23); /* e0 = ilogb(|x|)-23, positive */
- u.i = ix - (e0<<23);
- tx[0] = u.f;
- n = __rem_pio2_large(tx,ty,e0,1,0);
- if (sign) {
- *y = -ty[0];
- return -n;
- }
- *y = ty[0];
- return n;
+ ix = u.i & 0x7fffffff;
+ /* 25+53 bit pi is good enough for medium size */
+ if (ix < 0x4dc90fdb) { /* |x| ~< 2^28*(pi/2), medium size */
+ /* Use a specialized rint() to get fn. Assume round-to-nearest. */
+ fn = (double_t)x * invpio2 + toint - toint;
+ n = (int32_t)fn;
+ *y = x - fn * pio2_1 - fn * pio2_1t;
+ return n;
+ }
+ if (ix >= 0x7f800000) { /* x is inf or NaN */
+ *y = x - x;
+ return 0;
+ }
+ /* scale x into [2^23, 2^24-1] */
+ sign = u.i >> 31;
+ e0 = (ix >> 23) - (0x7f + 23); /* e0 = ilogb(|x|)-23, positive */
+ u.i = ix - (e0 << 23);
+ tx[0] = u.f;
+ n = __rem_pio2_large(tx, ty, e0, 1, 0);
+ if (sign) {
+ *y = -ty[0];
+ return -n;
+ }
+ *y = ty[0];
+ return n;
}
diff --git a/fusl/src/math/__rem_pio2l.c b/fusl/src/math/__rem_pio2l.c
index 77255bd..4b8693d 100644
--- a/fusl/src/math/__rem_pio2l.c
+++ b/fusl/src/math/__rem_pio2l.c
@@ -20,11 +20,13 @@
* use __rem_pio2_large() for large x
*/
-static const long double toint = 1.5/LDBL_EPSILON;
+static const long double toint = 1.5 / LDBL_EPSILON;
#if LDBL_MANT_DIG == 64
/* u ~< 0x1p25*pi/2 */
-#define SMALL(u) (((u.i.se & 0x7fffU)<<16 | u.i.m>>48) < ((0x3fff + 25)<<16 | 0x921f>>1 | 0x8000))
+#define SMALL(u) \
+ (((u.i.se & 0x7fffU) << 16 | u.i.m >> 48) < \
+ ((0x3fff + 25) << 16 | 0x921f >> 1 | 0x8000))
#define QUOBITS(x) ((uint32_t)(int32_t)x & 0x7fffffff)
#define ROUND1 22
#define ROUND2 61
@@ -39,103 +41,118 @@
* pio2_3: third 39 bits of pi/2
* pio2_3t: pi/2 - (pio2_1+pio2_2+pio2_3)
*/
-static const double
-pio2_1 = 1.57079632679597125389e+00, /* 0x3FF921FB, 0x54444000 */
-pio2_2 = -1.07463465549783099519e-12, /* -0x12e7b967674000.0p-92 */
-pio2_3 = 6.36831716351370313614e-25; /* 0x18a2e037074000.0p-133 */
+static const double pio2_1 =
+ 1.57079632679597125389e+00, /* 0x3FF921FB, 0x54444000 */
+ pio2_2 = -1.07463465549783099519e-12, /* -0x12e7b967674000.0p-92 */
+ pio2_3 = 6.36831716351370313614e-25; /* 0x18a2e037074000.0p-133 */
static const long double
-invpio2 = 6.36619772367581343076e-01L, /* 0xa2f9836e4e44152a.0p-64 */
-pio2_1t = -1.07463465549719416346e-12L, /* -0x973dcb3b399d747f.0p-103 */
-pio2_2t = 6.36831716351095013979e-25L, /* 0xc51701b839a25205.0p-144 */
-pio2_3t = -2.75299651904407171810e-37L; /* -0xbb5bf6c7ddd660ce.0p-185 */
+ invpio2 = 6.36619772367581343076e-01L, /* 0xa2f9836e4e44152a.0p-64 */
+ pio2_1t = -1.07463465549719416346e-12L, /* -0x973dcb3b399d747f.0p-103 */
+ pio2_2t = 6.36831716351095013979e-25L, /* 0xc51701b839a25205.0p-144 */
+ pio2_3t = -2.75299651904407171810e-37L; /* -0xbb5bf6c7ddd660ce.0p-185 */
#elif LDBL_MANT_DIG == 113
/* u ~< 0x1p45*pi/2 */
-#define SMALL(u) (((u.i.se & 0x7fffU)<<16 | u.i.top) < ((0x3fff + 45)<<16 | 0x921f))
+#define SMALL(u) \
+ (((u.i.se & 0x7fffU) << 16 | u.i.top) < ((0x3fff + 45) << 16 | 0x921f))
#define QUOBITS(x) ((uint32_t)(int64_t)x & 0x7fffffff)
#define ROUND1 51
#define ROUND2 119
#define NX 5
#define NY 3
static const long double
-invpio2 = 6.3661977236758134307553505349005747e-01L, /* 0x145f306dc9c882a53f84eafa3ea6a.0p-113 */
-pio2_1 = 1.5707963267948966192292994253909555e+00L, /* 0x1921fb54442d18469800000000000.0p-112 */
-pio2_1t = 2.0222662487959507323996846200947577e-21L, /* 0x13198a2e03707344a4093822299f3.0p-181 */
-pio2_2 = 2.0222662487959507323994779168837751e-21L, /* 0x13198a2e03707344a400000000000.0p-181 */
-pio2_2t = 2.0670321098263988236496903051604844e-43L, /* 0x127044533e63a0105df531d89cd91.0p-254 */
-pio2_3 = 2.0670321098263988236499468110329591e-43L, /* 0x127044533e63a0105e00000000000.0p-254 */
-pio2_3t = -2.5650587247459238361625433492959285e-65L; /* -0x159c4ec64ddaeb5f78671cbfb2210.0p-327 */
+ invpio2 =
+ 6.3661977236758134307553505349005747e-01L, /* 0x145f306dc9c882a53f84eafa3ea6a.0p-113
+ */
+ pio2_1 =
+ 1.5707963267948966192292994253909555e+00L, /* 0x1921fb54442d18469800000000000.0p-112
+ */
+ pio2_1t =
+ 2.0222662487959507323996846200947577e-21L, /* 0x13198a2e03707344a4093822299f3.0p-181
+ */
+ pio2_2 =
+ 2.0222662487959507323994779168837751e-21L, /* 0x13198a2e03707344a400000000000.0p-181
+ */
+ pio2_2t =
+ 2.0670321098263988236496903051604844e-43L, /* 0x127044533e63a0105df531d89cd91.0p-254
+ */
+ pio2_3 =
+ 2.0670321098263988236499468110329591e-43L, /* 0x127044533e63a0105e00000000000.0p-254
+ */
+ pio2_3t =
+ -2.5650587247459238361625433492959285e-65L; /* -0x159c4ec64ddaeb5f78671cbfb2210.0p-327
+ */
#endif
-int __rem_pio2l(long double x, long double *y)
-{
- union ldshape u,uz;
- long double z,w,t,r,fn;
- double tx[NX],ty[NY];
- int ex,ey,n,i;
+int __rem_pio2l(long double x, long double* y) {
+ union ldshape u, uz;
+ long double z, w, t, r, fn;
+ double tx[NX], ty[NY];
+ int ex, ey, n, i;
- u.f = x;
- ex = u.i.se & 0x7fff;
- if (SMALL(u)) {
- /* rint(x/(pi/2)), Assume round-to-nearest. */
- fn = x*invpio2 + toint - toint;
- n = QUOBITS(fn);
- r = x-fn*pio2_1;
- w = fn*pio2_1t; /* 1st round good to 102/180 bits (ld80/ld128) */
- y[0] = r-w;
- u.f = y[0];
- ey = u.i.se & 0x7fff;
- if (ex - ey > ROUND1) { /* 2nd iteration needed, good to 141/248 (ld80/ld128) */
- t = r;
- w = fn*pio2_2;
- r = t-w;
- w = fn*pio2_2t-((t-r)-w);
- y[0] = r-w;
- u.f = y[0];
- ey = u.i.se & 0x7fff;
- if (ex - ey > ROUND2) { /* 3rd iteration, good to 180/316 bits */
- t = r; /* will cover all possible cases (not verified for ld128) */
- w = fn*pio2_3;
- r = t-w;
- w = fn*pio2_3t-((t-r)-w);
- y[0] = r-w;
- }
- }
- y[1] = (r - y[0]) - w;
- return n;
- }
- /*
- * all other (large) arguments
- */
- if (ex == 0x7fff) { /* x is inf or NaN */
- y[0] = y[1] = x - x;
- return 0;
- }
- /* set z = scalbn(|x|,-ilogb(x)+23) */
- uz.f = x;
- uz.i.se = 0x3fff + 23;
- z = uz.f;
- for (i=0; i < NX - 1; i++) {
- tx[i] = (double)(int32_t)z;
- z = (z-tx[i])*0x1p24;
- }
- tx[i] = z;
- while (tx[i] == 0)
- i--;
- n = __rem_pio2_large(tx, ty, ex-0x3fff-23, i+1, NY);
- w = ty[1];
- if (NY == 3)
- w += ty[2];
- r = ty[0] + w;
- /* TODO: for ld128 this does not follow the recommendation of the
- comments of __rem_pio2_large which seem wrong if |ty[0]| > |ty[1]+ty[2]| */
- w -= r - ty[0];
- if (u.i.se >> 15) {
- y[0] = -r;
- y[1] = -w;
- return -n;
- }
- y[0] = r;
- y[1] = w;
- return n;
+ u.f = x;
+ ex = u.i.se & 0x7fff;
+ if (SMALL(u)) {
+ /* rint(x/(pi/2)), Assume round-to-nearest. */
+ fn = x * invpio2 + toint - toint;
+ n = QUOBITS(fn);
+ r = x - fn * pio2_1;
+ w = fn * pio2_1t; /* 1st round good to 102/180 bits (ld80/ld128) */
+ y[0] = r - w;
+ u.f = y[0];
+ ey = u.i.se & 0x7fff;
+ if (ex - ey >
+ ROUND1) { /* 2nd iteration needed, good to 141/248 (ld80/ld128) */
+ t = r;
+ w = fn * pio2_2;
+ r = t - w;
+ w = fn * pio2_2t - ((t - r) - w);
+ y[0] = r - w;
+ u.f = y[0];
+ ey = u.i.se & 0x7fff;
+ if (ex - ey > ROUND2) { /* 3rd iteration, good to 180/316 bits */
+ t = r; /* will cover all possible cases (not verified for ld128) */
+ w = fn * pio2_3;
+ r = t - w;
+ w = fn * pio2_3t - ((t - r) - w);
+ y[0] = r - w;
+ }
+ }
+ y[1] = (r - y[0]) - w;
+ return n;
+ }
+ /*
+ * all other (large) arguments
+ */
+ if (ex == 0x7fff) { /* x is inf or NaN */
+ y[0] = y[1] = x - x;
+ return 0;
+ }
+ /* set z = scalbn(|x|,-ilogb(x)+23) */
+ uz.f = x;
+ uz.i.se = 0x3fff + 23;
+ z = uz.f;
+ for (i = 0; i < NX - 1; i++) {
+ tx[i] = (double)(int32_t)z;
+ z = (z - tx[i]) * 0x1p24;
+ }
+ tx[i] = z;
+ while (tx[i] == 0)
+ i--;
+ n = __rem_pio2_large(tx, ty, ex - 0x3fff - 23, i + 1, NY);
+ w = ty[1];
+ if (NY == 3)
+ w += ty[2];
+ r = ty[0] + w;
+ /* TODO: for ld128 this does not follow the recommendation of the
+ comments of __rem_pio2_large which seem wrong if |ty[0]| > |ty[1]+ty[2]| */
+ w -= r - ty[0];
+ if (u.i.se >> 15) {
+ y[0] = -r;
+ y[1] = -w;
+ return -n;
+ }
+ y[0] = r;
+ y[1] = w;
+ return n;
}
#endif
diff --git a/fusl/src/math/__signbit.c b/fusl/src/math/__signbit.c
index e700b6b..7368479 100644
--- a/fusl/src/math/__signbit.c
+++ b/fusl/src/math/__signbit.c
@@ -1,13 +1,10 @@
#include "libm.h"
// FIXME: macro in math.h
-int __signbit(double x)
-{
- union {
- double d;
- uint64_t i;
- } y = { x };
- return y.i>>63;
+int __signbit(double x) {
+ union {
+ double d;
+ uint64_t i;
+ } y = {x};
+ return y.i >> 63;
}
-
-
diff --git a/fusl/src/math/__signbitf.c b/fusl/src/math/__signbitf.c
index 40ad3cf..a4a8fb5 100644
--- a/fusl/src/math/__signbitf.c
+++ b/fusl/src/math/__signbitf.c
@@ -1,11 +1,10 @@
#include "libm.h"
// FIXME: macro in math.h
-int __signbitf(float x)
-{
- union {
- float f;
- uint32_t i;
- } y = { x };
- return y.i>>31;
+int __signbitf(float x) {
+ union {
+ float f;
+ uint32_t i;
+ } y = {x};
+ return y.i >> 31;
}
diff --git a/fusl/src/math/__signbitl.c b/fusl/src/math/__signbitl.c
index 63b3dc5..1660ac0 100644
--- a/fusl/src/math/__signbitl.c
+++ b/fusl/src/math/__signbitl.c
@@ -1,14 +1,12 @@
#include "libm.h"
#if (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-int __signbitl(long double x)
-{
- union ldshape u = {x};
- return u.i.se >> 15;
+int __signbitl(long double x) {
+ union ldshape u = {x};
+ return u.i.se >> 15;
}
#elif LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-int __signbitl(long double x)
-{
- return __signbit(x);
+int __signbitl(long double x) {
+ return __signbit(x);
}
#endif
diff --git a/fusl/src/math/__sin.c b/fusl/src/math/__sin.c
index 4030949..94fecb8 100644
--- a/fusl/src/math/__sin.c
+++ b/fusl/src/math/__sin.c
@@ -42,23 +42,22 @@
#include "libm.h"
static const double
-S1 = -1.66666666666666324348e-01, /* 0xBFC55555, 0x55555549 */
-S2 = 8.33333333332248946124e-03, /* 0x3F811111, 0x1110F8A6 */
-S3 = -1.98412698298579493134e-04, /* 0xBF2A01A0, 0x19C161D5 */
-S4 = 2.75573137070700676789e-06, /* 0x3EC71DE3, 0x57B1FE7D */
-S5 = -2.50507602534068634195e-08, /* 0xBE5AE5E6, 0x8A2B9CEB */
-S6 = 1.58969099521155010221e-10; /* 0x3DE5D93A, 0x5ACFD57C */
+ S1 = -1.66666666666666324348e-01, /* 0xBFC55555, 0x55555549 */
+ S2 = 8.33333333332248946124e-03, /* 0x3F811111, 0x1110F8A6 */
+ S3 = -1.98412698298579493134e-04, /* 0xBF2A01A0, 0x19C161D5 */
+ S4 = 2.75573137070700676789e-06, /* 0x3EC71DE3, 0x57B1FE7D */
+ S5 = -2.50507602534068634195e-08, /* 0xBE5AE5E6, 0x8A2B9CEB */
+ S6 = 1.58969099521155010221e-10; /* 0x3DE5D93A, 0x5ACFD57C */
-double __sin(double x, double y, int iy)
-{
- double_t z,r,v,w;
+double __sin(double x, double y, int iy) {
+ double_t z, r, v, w;
- z = x*x;
- w = z*z;
- r = S2 + z*(S3 + z*S4) + z*w*(S5 + z*S6);
- v = z*x;
- if (iy == 0)
- return x + v*(S1 + z*r);
- else
- return x - ((z*(0.5*y - v*r) - y) - v*S1);
+ z = x * x;
+ w = z * z;
+ r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);
+ v = z * x;
+ if (iy == 0)
+ return x + v * (S1 + z * r);
+ else
+ return x - ((z * (0.5 * y - v * r) - y) - v * S1);
}
diff --git a/fusl/src/math/__sindf.c b/fusl/src/math/__sindf.c
index 8fec2a3..82e540f 100644
--- a/fusl/src/math/__sindf.c
+++ b/fusl/src/math/__sindf.c
@@ -17,20 +17,18 @@
#include "libm.h"
/* |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]). */
-static const double
-S1 = -0x15555554cbac77.0p-55, /* -0.166666666416265235595 */
-S2 = 0x111110896efbb2.0p-59, /* 0.0083333293858894631756 */
-S3 = -0x1a00f9e2cae774.0p-65, /* -0.000198393348360966317347 */
-S4 = 0x16cd878c3b46a7.0p-71; /* 0.0000027183114939898219064 */
+static const double S1 = -0x15555554cbac77.0p-55, /* -0.166666666416265235595 */
+ S2 = 0x111110896efbb2.0p-59, /* 0.0083333293858894631756 */
+ S3 = -0x1a00f9e2cae774.0p-65, /* -0.000198393348360966317347 */
+ S4 = 0x16cd878c3b46a7.0p-71; /* 0.0000027183114939898219064 */
-float __sindf(double x)
-{
- double_t r, s, w, z;
+float __sindf(double x) {
+ double_t r, s, w, z;
- /* Try to optimize for parallel evaluation as in __tandf.c. */
- z = x*x;
- w = z*z;
- r = S3 + z*S4;
- s = z*x;
- return (x + s*(S1 + z*S2)) + s*w*r;
+ /* Try to optimize for parallel evaluation as in __tandf.c. */
+ z = x * x;
+ w = z * z;
+ r = S3 + z * S4;
+ s = z * x;
+ return (x + s * (S1 + z * S2)) + s * w * r;
}
diff --git a/fusl/src/math/__sinl.c b/fusl/src/math/__sinl.c
index 2525bbe..ee3e9d0 100644
--- a/fusl/src/math/__sinl.c
+++ b/fusl/src/math/__sinl.c
@@ -25,17 +25,17 @@
*
* See __cosl.c for more details about the polynomial.
*/
-static const long double
-S1 = -0.166666666666666666671L; /* -0xaaaaaaaaaaaaaaab.0p-66 */
-static const double
-S2 = 0.0083333333333333332, /* 0x11111111111111.0p-59 */
-S3 = -0.00019841269841269427, /* -0x1a01a01a019f81.0p-65 */
-S4 = 0.0000027557319223597490, /* 0x171de3a55560f7.0p-71 */
-S5 = -0.000000025052108218074604, /* -0x1ae64564f16cad.0p-78 */
-S6 = 1.6059006598854211e-10, /* 0x161242b90243b5.0p-85 */
-S7 = -7.6429779983024564e-13, /* -0x1ae42ebd1b2e00.0p-93 */
-S8 = 2.6174587166648325e-15; /* 0x179372ea0b3f64.0p-101 */
-#define POLY(z) (S2+z*(S3+z*(S4+z*(S5+z*(S6+z*(S7+z*S8))))))
+static const long double S1 =
+ -0.166666666666666666671L; /* -0xaaaaaaaaaaaaaaab.0p-66 */
+static const double S2 = 0.0083333333333333332, /* 0x11111111111111.0p-59 */
+ S3 = -0.00019841269841269427, /* -0x1a01a01a019f81.0p-65 */
+ S4 = 0.0000027557319223597490, /* 0x171de3a55560f7.0p-71 */
+ S5 = -0.000000025052108218074604, /* -0x1ae64564f16cad.0p-78 */
+ S6 = 1.6059006598854211e-10, /* 0x161242b90243b5.0p-85 */
+ S7 = -7.6429779983024564e-13, /* -0x1ae42ebd1b2e00.0p-93 */
+ S8 = 2.6174587166648325e-15; /* 0x179372ea0b3f64.0p-101 */
+#define POLY(z) \
+ (S2 + z * (S3 + z * (S4 + z * (S5 + z * (S6 + z * (S7 + z * S8))))))
#elif LDBL_MANT_DIG == 113
/*
* ld128 version of __sin.c. See __sin.c for most comments.
@@ -47,32 +47,39 @@
* See __cosl.c for more details about the polynomial.
*/
static const long double
-S1 = -0.16666666666666666666666666666666666606732416116558L,
-S2 = 0.0083333333333333333333333333333331135404851288270047L,
-S3 = -0.00019841269841269841269841269839935785325638310428717L,
-S4 = 0.27557319223985890652557316053039946268333231205686e-5L,
-S5 = -0.25052108385441718775048214826384312253862930064745e-7L,
-S6 = 0.16059043836821614596571832194524392581082444805729e-9L,
-S7 = -0.76471637318198151807063387954939213287488216303768e-12L,
-S8 = 0.28114572543451292625024967174638477283187397621303e-14L;
+ S1 = -0.16666666666666666666666666666666666606732416116558L,
+ S2 = 0.0083333333333333333333333333333331135404851288270047L,
+ S3 = -0.00019841269841269841269841269839935785325638310428717L,
+ S4 = 0.27557319223985890652557316053039946268333231205686e-5L,
+ S5 = -0.25052108385441718775048214826384312253862930064745e-7L,
+ S6 = 0.16059043836821614596571832194524392581082444805729e-9L,
+ S7 = -0.76471637318198151807063387954939213287488216303768e-12L,
+ S8 = 0.28114572543451292625024967174638477283187397621303e-14L;
static const double
-S9 = -0.82206352458348947812512122163446202498005154296863e-17,
-S10 = 0.19572940011906109418080609928334380560135358385256e-19,
-S11 = -0.38680813379701966970673724299207480965452616911420e-22,
-S12 = 0.64038150078671872796678569586315881020659912139412e-25;
-#define POLY(z) (S2+z*(S3+z*(S4+z*(S5+z*(S6+z*(S7+z*(S8+ \
- z*(S9+z*(S10+z*(S11+z*S12))))))))))
+ S9 = -0.82206352458348947812512122163446202498005154296863e-17,
+ S10 = 0.19572940011906109418080609928334380560135358385256e-19,
+ S11 = -0.38680813379701966970673724299207480965452616911420e-22,
+ S12 = 0.64038150078671872796678569586315881020659912139412e-25;
+#define POLY(z) \
+ (S2 + \
+ z * (S3 + \
+ z * (S4 + \
+ z * (S5 + \
+ z * (S6 + \
+ z * (S7 + \
+ z * (S8 + \
+ z * (S9 + \
+ z * (S10 + z * (S11 + z * S12))))))))))
#endif
-long double __sinl(long double x, long double y, int iy)
-{
- long double z,r,v;
+long double __sinl(long double x, long double y, int iy) {
+ long double z, r, v;
- z = x*x;
- v = z*x;
- r = POLY(z);
- if (iy == 0)
- return x+v*(S1+z*r);
- return x-((z*(0.5*y-v*r)-y)-v*S1);
+ z = x * x;
+ v = z * x;
+ r = POLY(z);
+ if (iy == 0)
+ return x + v * (S1 + z * r);
+ return x - ((z * (0.5 * y - v * r) - y) - v * S1);
}
#endif
diff --git a/fusl/src/math/__tan.c b/fusl/src/math/__tan.c
index 8019844..543ac87 100644
--- a/fusl/src/math/__tan.c
+++ b/fusl/src/math/__tan.c
@@ -12,7 +12,8 @@
* kernel tan function on ~[-pi/4, pi/4] (except on -0), pi/4 ~ 0.7854
* Input x is assumed to be bounded by ~pi/4 in magnitude.
* Input y is the tail of x.
- * Input odd indicates whether tan (if odd = 0) or -1/tan (if odd = 1) is returned.
+ * Input odd indicates whether tan (if odd = 0) or -1/tan (if odd = 1) is
+ * returned.
*
* Algorithm
* 1. Since tan(-x) = -tan(x), we need only to consider positive x.
@@ -45,66 +46,67 @@
#include "libm.h"
-static const double T[] = {
- 3.33333333333334091986e-01, /* 3FD55555, 55555563 */
- 1.33333333333201242699e-01, /* 3FC11111, 1110FE7A */
- 5.39682539762260521377e-02, /* 3FABA1BA, 1BB341FE */
- 2.18694882948595424599e-02, /* 3F9664F4, 8406D637 */
- 8.86323982359930005737e-03, /* 3F8226E3, E96E8493 */
- 3.59207910759131235356e-03, /* 3F6D6D22, C9560328 */
- 1.45620945432529025516e-03, /* 3F57DBC8, FEE08315 */
- 5.88041240820264096874e-04, /* 3F4344D8, F2F26501 */
- 2.46463134818469906812e-04, /* 3F3026F7, 1A8D1068 */
- 7.81794442939557092300e-05, /* 3F147E88, A03792A6 */
- 7.14072491382608190305e-05, /* 3F12B80F, 32F0A7E9 */
- -1.85586374855275456654e-05, /* BEF375CB, DB605373 */
- 2.59073051863633712884e-05, /* 3EFB2A70, 74BF7AD4 */
+static const double T[] =
+ {
+ 3.33333333333334091986e-01, /* 3FD55555, 55555563 */
+ 1.33333333333201242699e-01, /* 3FC11111, 1110FE7A */
+ 5.39682539762260521377e-02, /* 3FABA1BA, 1BB341FE */
+ 2.18694882948595424599e-02, /* 3F9664F4, 8406D637 */
+ 8.86323982359930005737e-03, /* 3F8226E3, E96E8493 */
+ 3.59207910759131235356e-03, /* 3F6D6D22, C9560328 */
+ 1.45620945432529025516e-03, /* 3F57DBC8, FEE08315 */
+ 5.88041240820264096874e-04, /* 3F4344D8, F2F26501 */
+ 2.46463134818469906812e-04, /* 3F3026F7, 1A8D1068 */
+ 7.81794442939557092300e-05, /* 3F147E88, A03792A6 */
+ 7.14072491382608190305e-05, /* 3F12B80F, 32F0A7E9 */
+ -1.85586374855275456654e-05, /* BEF375CB, DB605373 */
+ 2.59073051863633712884e-05, /* 3EFB2A70, 74BF7AD4 */
},
-pio4 = 7.85398163397448278999e-01, /* 3FE921FB, 54442D18 */
-pio4lo = 3.06161699786838301793e-17; /* 3C81A626, 33145C07 */
+ pio4 = 7.85398163397448278999e-01, /* 3FE921FB, 54442D18 */
+ pio4lo = 3.06161699786838301793e-17; /* 3C81A626, 33145C07 */
-double __tan(double x, double y, int odd)
-{
- double_t z, r, v, w, s, a;
- double w0, a0;
- uint32_t hx;
- int big, sign;
+double __tan(double x, double y, int odd) {
+ double_t z, r, v, w, s, a;
+ double w0, a0;
+ uint32_t hx;
+ int big, sign;
- GET_HIGH_WORD(hx,x);
- big = (hx&0x7fffffff) >= 0x3FE59428; /* |x| >= 0.6744 */
- if (big) {
- sign = hx>>31;
- if (sign) {
- x = -x;
- y = -y;
- }
- x = (pio4 - x) + (pio4lo - y);
- y = 0.0;
- }
- z = x * x;
- w = z * z;
- /*
- * Break x^5*(T[1]+x^2*T[2]+...) into
- * x^5(T[1]+x^4*T[3]+...+x^20*T[11]) +
- * x^5(x^2*(T[2]+x^4*T[4]+...+x^22*[T12]))
- */
- r = T[1] + w*(T[3] + w*(T[5] + w*(T[7] + w*(T[9] + w*T[11]))));
- v = z*(T[2] + w*(T[4] + w*(T[6] + w*(T[8] + w*(T[10] + w*T[12])))));
- s = z * x;
- r = y + z*(s*(r + v) + y) + s*T[0];
- w = x + r;
- if (big) {
- s = 1 - 2*odd;
- v = s - 2.0 * (x + (r - w*w/(w + s)));
- return sign ? -v : v;
- }
- if (!odd)
- return w;
- /* -1.0/(x+r) has up to 2ulp error, so compute it accurately */
- w0 = w;
- SET_LOW_WORD(w0, 0);
- v = r - (w0 - x); /* w0+v = r+x */
- a0 = a = -1.0 / w;
- SET_LOW_WORD(a0, 0);
- return a0 + a*(1.0 + a0*w0 + a0*v);
+ GET_HIGH_WORD(hx, x);
+ big = (hx & 0x7fffffff) >= 0x3FE59428; /* |x| >= 0.6744 */
+ if (big) {
+ sign = hx >> 31;
+ if (sign) {
+ x = -x;
+ y = -y;
+ }
+ x = (pio4 - x) + (pio4lo - y);
+ y = 0.0;
+ }
+ z = x * x;
+ w = z * z;
+ /*
+ * Break x^5*(T[1]+x^2*T[2]+...) into
+ * x^5(T[1]+x^4*T[3]+...+x^20*T[11]) +
+ * x^5(x^2*(T[2]+x^4*T[4]+...+x^22*[T12]))
+ */
+ r = T[1] + w * (T[3] + w * (T[5] + w * (T[7] + w * (T[9] + w * T[11]))));
+ v = z *
+ (T[2] + w * (T[4] + w * (T[6] + w * (T[8] + w * (T[10] + w * T[12])))));
+ s = z * x;
+ r = y + z * (s * (r + v) + y) + s * T[0];
+ w = x + r;
+ if (big) {
+ s = 1 - 2 * odd;
+ v = s - 2.0 * (x + (r - w * w / (w + s)));
+ return sign ? -v : v;
+ }
+ if (!odd)
+ return w;
+ /* -1.0/(x+r) has up to 2ulp error, so compute it accurately */
+ w0 = w;
+ SET_LOW_WORD(w0, 0);
+ v = r - (w0 - x); /* w0+v = r+x */
+ a0 = a = -1.0 / w;
+ SET_LOW_WORD(a0, 0);
+ return a0 + a * (1.0 + a0 * w0 + a0 * v);
}
diff --git a/fusl/src/math/__tandf.c b/fusl/src/math/__tandf.c
index 25047ee..ccad354 100644
--- a/fusl/src/math/__tandf.c
+++ b/fusl/src/math/__tandf.c
@@ -17,38 +17,37 @@
/* |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]). */
static const double T[] = {
- 0x15554d3418c99f.0p-54, /* 0.333331395030791399758 */
- 0x1112fd38999f72.0p-55, /* 0.133392002712976742718 */
- 0x1b54c91d865afe.0p-57, /* 0.0533812378445670393523 */
- 0x191df3908c33ce.0p-58, /* 0.0245283181166547278873 */
- 0x185dadfcecf44e.0p-61, /* 0.00297435743359967304927 */
- 0x1362b9bf971bcd.0p-59, /* 0.00946564784943673166728 */
+ 0x15554d3418c99f.0p-54, /* 0.333331395030791399758 */
+ 0x1112fd38999f72.0p-55, /* 0.133392002712976742718 */
+ 0x1b54c91d865afe.0p-57, /* 0.0533812378445670393523 */
+ 0x191df3908c33ce.0p-58, /* 0.0245283181166547278873 */
+ 0x185dadfcecf44e.0p-61, /* 0.00297435743359967304927 */
+ 0x1362b9bf971bcd.0p-59, /* 0.00946564784943673166728 */
};
-float __tandf(double x, int odd)
-{
- double_t z,r,w,s,t,u;
+float __tandf(double x, int odd) {
+ double_t z, r, w, s, t, u;
- z = x*x;
- /*
- * Split up the polynomial into small independent terms to give
- * opportunities for parallel evaluation. The chosen splitting is
- * micro-optimized for Athlons (XP, X64). It costs 2 multiplications
- * relative to Horner's method on sequential machines.
- *
- * We add the small terms from lowest degree up for efficiency on
- * non-sequential machines (the lowest degree terms tend to be ready
- * earlier). Apart from this, we don't care about order of
- * operations, and don't need to to care since we have precision to
- * spare. However, the chosen splitting is good for accuracy too,
- * and would give results as accurate as Horner's method if the
- * small terms were added from highest degree down.
- */
- r = T[4] + z*T[5];
- t = T[2] + z*T[3];
- w = z*z;
- s = z*x;
- u = T[0] + z*T[1];
- r = (x + s*u) + (s*w)*(t + w*r);
- return odd ? -1.0/r : r;
+ z = x * x;
+ /*
+ * Split up the polynomial into small independent terms to give
+ * opportunities for parallel evaluation. The chosen splitting is
+ * micro-optimized for Athlons (XP, X64). It costs 2 multiplications
+ * relative to Horner's method on sequential machines.
+ *
+ * We add the small terms from lowest degree up for efficiency on
+ * non-sequential machines (the lowest degree terms tend to be ready
+ * earlier). Apart from this, we don't care about order of
+ * operations, and don't need to to care since we have precision to
+ * spare. However, the chosen splitting is good for accuracy too,
+ * and would give results as accurate as Horner's method if the
+ * small terms were added from highest degree down.
+ */
+ r = T[4] + z * T[5];
+ t = T[2] + z * T[3];
+ w = z * z;
+ s = z * x;
+ u = T[0] + z * T[1];
+ r = (x + s * u) + (s * w) * (t + w * r);
+ return odd ? -1.0 / r : r;
}
diff --git a/fusl/src/math/__tanl.c b/fusl/src/math/__tanl.c
index 54abc3d..c6116b0 100644
--- a/fusl/src/math/__tanl.c
+++ b/fusl/src/math/__tanl.c
@@ -25,29 +25,30 @@
* See __cosl.c for more details about the polynomial.
*/
static const long double
-T3 = 0.333333333333333333180L, /* 0xaaaaaaaaaaaaaaa5.0p-65 */
-T5 = 0.133333333333333372290L, /* 0x88888888888893c3.0p-66 */
-T7 = 0.0539682539682504975744L, /* 0xdd0dd0dd0dc13ba2.0p-68 */
-pio4 = 0.785398163397448309628L, /* 0xc90fdaa22168c235.0p-64 */
-pio4lo = -1.25413940316708300586e-20L; /* -0xece675d1fc8f8cbb.0p-130 */
-static const double
-T9 = 0.021869488536312216, /* 0x1664f4882cc1c2.0p-58 */
-T11 = 0.0088632355256619590, /* 0x1226e355c17612.0p-59 */
-T13 = 0.0035921281113786528, /* 0x1d6d3d185d7ff8.0p-61 */
-T15 = 0.0014558334756312418, /* 0x17da354aa3f96b.0p-62 */
-T17 = 0.00059003538700862256, /* 0x13559358685b83.0p-63 */
-T19 = 0.00023907843576635544, /* 0x1f56242026b5be.0p-65 */
-T21 = 0.000097154625656538905, /* 0x1977efc26806f4.0p-66 */
-T23 = 0.000038440165747303162, /* 0x14275a09b3ceac.0p-67 */
-T25 = 0.000018082171885432524, /* 0x12f5e563e5487e.0p-68 */
-T27 = 0.0000024196006108814377, /* 0x144c0d80cc6896.0p-71 */
-T29 = 0.0000078293456938132840, /* 0x106b59141a6cb3.0p-69 */
-T31 = -0.0000032609076735050182, /* -0x1b5abef3ba4b59.0p-71 */
-T33 = 0.0000023261313142559411; /* 0x13835436c0c87f.0p-71 */
-#define RPOLY(w) (T5 + w * (T9 + w * (T13 + w * (T17 + w * (T21 + \
- w * (T25 + w * (T29 + w * T33)))))))
-#define VPOLY(w) (T7 + w * (T11 + w * (T15 + w * (T19 + w * (T23 + \
- w * (T27 + w * T31))))))
+ T3 = 0.333333333333333333180L, /* 0xaaaaaaaaaaaaaaa5.0p-65 */
+ T5 = 0.133333333333333372290L, /* 0x88888888888893c3.0p-66 */
+ T7 = 0.0539682539682504975744L, /* 0xdd0dd0dd0dc13ba2.0p-68 */
+ pio4 = 0.785398163397448309628L, /* 0xc90fdaa22168c235.0p-64 */
+ pio4lo = -1.25413940316708300586e-20L; /* -0xece675d1fc8f8cbb.0p-130 */
+static const double T9 = 0.021869488536312216, /* 0x1664f4882cc1c2.0p-58 */
+ T11 = 0.0088632355256619590, /* 0x1226e355c17612.0p-59 */
+ T13 = 0.0035921281113786528, /* 0x1d6d3d185d7ff8.0p-61 */
+ T15 = 0.0014558334756312418, /* 0x17da354aa3f96b.0p-62 */
+ T17 = 0.00059003538700862256, /* 0x13559358685b83.0p-63 */
+ T19 = 0.00023907843576635544, /* 0x1f56242026b5be.0p-65 */
+ T21 = 0.000097154625656538905, /* 0x1977efc26806f4.0p-66 */
+ T23 = 0.000038440165747303162, /* 0x14275a09b3ceac.0p-67 */
+ T25 = 0.000018082171885432524, /* 0x12f5e563e5487e.0p-68 */
+ T27 = 0.0000024196006108814377, /* 0x144c0d80cc6896.0p-71 */
+ T29 = 0.0000078293456938132840, /* 0x106b59141a6cb3.0p-69 */
+ T31 = -0.0000032609076735050182, /* -0x1b5abef3ba4b59.0p-71 */
+ T33 = 0.0000023261313142559411; /* 0x13835436c0c87f.0p-71 */
+#define RPOLY(w) \
+ (T5 + \
+ w * (T9 + \
+ w * (T13 + w * (T17 + w * (T21 + w * (T25 + w * (T29 + w * T33)))))))
+#define VPOLY(w) \
+ (T7 + w * (T11 + w * (T15 + w * (T19 + w * (T23 + w * (T27 + w * T31))))))
#elif LDBL_MANT_DIG == 113
/*
* ld128 version of __tan.c. See __tan.c for most comments.
@@ -58,86 +59,108 @@
*
* See __cosl.c for more details about the polynomial.
*/
-static const long double
-T3 = 0x1.5555555555555555555555555553p-2L,
-T5 = 0x1.1111111111111111111111111eb5p-3L,
-T7 = 0x1.ba1ba1ba1ba1ba1ba1ba1b694cd6p-5L,
-T9 = 0x1.664f4882c10f9f32d6bbe09d8bcdp-6L,
-T11 = 0x1.226e355e6c23c8f5b4f5762322eep-7L,
-T13 = 0x1.d6d3d0e157ddfb5fed8e84e27b37p-9L,
-T15 = 0x1.7da36452b75e2b5fce9ee7c2c92ep-10L,
-T17 = 0x1.355824803674477dfcf726649efep-11L,
-T19 = 0x1.f57d7734d1656e0aceb716f614c2p-13L,
-T21 = 0x1.967e18afcb180ed942dfdc518d6cp-14L,
-T23 = 0x1.497d8eea21e95bc7e2aa79b9f2cdp-15L,
-T25 = 0x1.0b132d39f055c81be49eff7afd50p-16L,
-T27 = 0x1.b0f72d33eff7bfa2fbc1059d90b6p-18L,
-T29 = 0x1.5ef2daf21d1113df38d0fbc00267p-19L,
-T31 = 0x1.1c77d6eac0234988cdaa04c96626p-20L,
-T33 = 0x1.cd2a5a292b180e0bdd701057dfe3p-22L,
-T35 = 0x1.75c7357d0298c01a31d0a6f7d518p-23L,
-T37 = 0x1.2f3190f4718a9a520f98f50081fcp-24L,
-pio4 = 0x1.921fb54442d18469898cc51701b8p-1L,
-pio4lo = 0x1.cd129024e088a67cc74020bbea60p-116L;
+static const long double T3 = 0x1.5555555555555555555555555553p-2L,
+ T5 = 0x1.1111111111111111111111111eb5p-3L,
+ T7 = 0x1.ba1ba1ba1ba1ba1ba1ba1b694cd6p-5L,
+ T9 = 0x1.664f4882c10f9f32d6bbe09d8bcdp-6L,
+ T11 = 0x1.226e355e6c23c8f5b4f5762322eep-7L,
+ T13 = 0x1.d6d3d0e157ddfb5fed8e84e27b37p-9L,
+ T15 = 0x1.7da36452b75e2b5fce9ee7c2c92ep-10L,
+ T17 = 0x1.355824803674477dfcf726649efep-11L,
+ T19 = 0x1.f57d7734d1656e0aceb716f614c2p-13L,
+ T21 = 0x1.967e18afcb180ed942dfdc518d6cp-14L,
+ T23 = 0x1.497d8eea21e95bc7e2aa79b9f2cdp-15L,
+ T25 = 0x1.0b132d39f055c81be49eff7afd50p-16L,
+ T27 = 0x1.b0f72d33eff7bfa2fbc1059d90b6p-18L,
+ T29 = 0x1.5ef2daf21d1113df38d0fbc00267p-19L,
+ T31 = 0x1.1c77d6eac0234988cdaa04c96626p-20L,
+ T33 = 0x1.cd2a5a292b180e0bdd701057dfe3p-22L,
+ T35 = 0x1.75c7357d0298c01a31d0a6f7d518p-23L,
+ T37 = 0x1.2f3190f4718a9a520f98f50081fcp-24L,
+ pio4 = 0x1.921fb54442d18469898cc51701b8p-1L,
+ pio4lo = 0x1.cd129024e088a67cc74020bbea60p-116L;
static const double
-T39 = 0.000000028443389121318352, /* 0x1e8a7592977938.0p-78 */
-T41 = 0.000000011981013102001973, /* 0x19baa1b1223219.0p-79 */
-T43 = 0.0000000038303578044958070, /* 0x107385dfb24529.0p-80 */
-T45 = 0.0000000034664378216909893, /* 0x1dc6c702a05262.0p-81 */
-T47 = -0.0000000015090641701997785, /* -0x19ecef3569ebb6.0p-82 */
-T49 = 0.0000000029449552300483952, /* 0x194c0668da786a.0p-81 */
-T51 = -0.0000000022006995706097711, /* -0x12e763b8845268.0p-81 */
-T53 = 0.0000000015468200913196612, /* 0x1a92fc98c29554.0p-82 */
-T55 = -0.00000000061311613386849674, /* -0x151106cbc779a9.0p-83 */
-T57 = 1.4912469681508012e-10; /* 0x147edbdba6f43a.0p-85 */
-#define RPOLY(w) (T5 + w * (T9 + w * (T13 + w * (T17 + w * (T21 + \
- w * (T25 + w * (T29 + w * (T33 + w * (T37 + w * (T41 + \
- w * (T45 + w * (T49 + w * (T53 + w * T57)))))))))))))
-#define VPOLY(w) (T7 + w * (T11 + w * (T15 + w * (T19 + w * (T23 + \
- w * (T27 + w * (T31 + w * (T35 + w * (T39 + w * (T43 + \
- w * (T47 + w * (T51 + w * T55))))))))))))
+ T39 = 0.000000028443389121318352, /* 0x1e8a7592977938.0p-78 */
+ T41 = 0.000000011981013102001973, /* 0x19baa1b1223219.0p-79 */
+ T43 = 0.0000000038303578044958070, /* 0x107385dfb24529.0p-80 */
+ T45 = 0.0000000034664378216909893, /* 0x1dc6c702a05262.0p-81 */
+ T47 = -0.0000000015090641701997785, /* -0x19ecef3569ebb6.0p-82 */
+ T49 = 0.0000000029449552300483952, /* 0x194c0668da786a.0p-81 */
+ T51 = -0.0000000022006995706097711, /* -0x12e763b8845268.0p-81 */
+ T53 = 0.0000000015468200913196612, /* 0x1a92fc98c29554.0p-82 */
+ T55 = -0.00000000061311613386849674, /* -0x151106cbc779a9.0p-83 */
+ T57 = 1.4912469681508012e-10; /* 0x147edbdba6f43a.0p-85 */
+#define RPOLY(w) \
+ (T5 + \
+ w * (T9 + \
+ w * (T13 + \
+ w * (T17 + \
+ w * (T21 + \
+ w * (T25 + \
+ w * (T29 + \
+ w * (T33 + \
+ w * (T37 + \
+ w * (T41 + \
+ w * (T45 + \
+ w * (T49 + \
+ w * (T53 + \
+ w * T57)))))))))))))
+#define VPOLY(w) \
+ (T7 + \
+ w * (T11 + \
+ w * (T15 + \
+ w * (T19 + \
+ w * (T23 + \
+ w * (T27 + \
+ w * (T31 + \
+ w * (T35 + \
+ w * (T39 + \
+ w * (T43 + \
+ w * (T47 + \
+ w * (T51 + \
+ w * T55))))))))))))
#endif
long double __tanl(long double x, long double y, int odd) {
- long double z, r, v, w, s, a, t;
- int big, sign;
+ long double z, r, v, w, s, a, t;
+ int big, sign;
- big = fabsl(x) >= 0.67434;
- if (big) {
- sign = 0;
- if (x < 0) {
- sign = 1;
- x = -x;
- y = -y;
- }
- x = (pio4 - x) + (pio4lo - y);
- y = 0.0;
- }
- z = x * x;
- w = z * z;
- r = RPOLY(w);
- v = z * VPOLY(w);
- s = z * x;
- r = y + z * (s * (r + v) + y) + T3 * s;
- w = x + r;
- if (big) {
- s = 1 - 2*odd;
- v = s - 2.0 * (x + (r - w * w / (w + s)));
- return sign ? -v : v;
- }
- if (!odd)
- return w;
- /*
- * if allow error up to 2 ulp, simply return
- * -1.0 / (x+r) here
- */
- /* compute -1.0 / (x+r) accurately */
- z = w;
- z = z + 0x1p32 - 0x1p32;
- v = r - (z - x); /* z+v = r+x */
- t = a = -1.0 / w; /* a = -1.0/w */
- t = t + 0x1p32 - 0x1p32;
- s = 1.0 + t * z;
- return t + a * (s + t * v);
+ big = fabsl(x) >= 0.67434;
+ if (big) {
+ sign = 0;
+ if (x < 0) {
+ sign = 1;
+ x = -x;
+ y = -y;
+ }
+ x = (pio4 - x) + (pio4lo - y);
+ y = 0.0;
+ }
+ z = x * x;
+ w = z * z;
+ r = RPOLY(w);
+ v = z * VPOLY(w);
+ s = z * x;
+ r = y + z * (s * (r + v) + y) + T3 * s;
+ w = x + r;
+ if (big) {
+ s = 1 - 2 * odd;
+ v = s - 2.0 * (x + (r - w * w / (w + s)));
+ return sign ? -v : v;
+ }
+ if (!odd)
+ return w;
+ /*
+ * if allow error up to 2 ulp, simply return
+ * -1.0 / (x+r) here
+ */
+ /* compute -1.0 / (x+r) accurately */
+ z = w;
+ z = z + 0x1p32 - 0x1p32;
+ v = r - (z - x); /* z+v = r+x */
+ t = a = -1.0 / w; /* a = -1.0/w */
+ t = t + 0x1p32 - 0x1p32;
+ s = 1.0 + t * z;
+ return t + a * (s + t * v);
}
#endif
diff --git a/fusl/src/math/acos.c b/fusl/src/math/acos.c
index ea9c87b..8060868 100644
--- a/fusl/src/math/acos.c
+++ b/fusl/src/math/acos.c
@@ -35,67 +35,65 @@
#include "libm.h"
-static const double
-pio2_hi = 1.57079632679489655800e+00, /* 0x3FF921FB, 0x54442D18 */
-pio2_lo = 6.12323399573676603587e-17, /* 0x3C91A626, 0x33145C07 */
-pS0 = 1.66666666666666657415e-01, /* 0x3FC55555, 0x55555555 */
-pS1 = -3.25565818622400915405e-01, /* 0xBFD4D612, 0x03EB6F7D */
-pS2 = 2.01212532134862925881e-01, /* 0x3FC9C155, 0x0E884455 */
-pS3 = -4.00555345006794114027e-02, /* 0xBFA48228, 0xB5688F3B */
-pS4 = 7.91534994289814532176e-04, /* 0x3F49EFE0, 0x7501B288 */
-pS5 = 3.47933107596021167570e-05, /* 0x3F023DE1, 0x0DFDF709 */
-qS1 = -2.40339491173441421878e+00, /* 0xC0033A27, 0x1C8A2D4B */
-qS2 = 2.02094576023350569471e+00, /* 0x40002AE5, 0x9C598AC8 */
-qS3 = -6.88283971605453293030e-01, /* 0xBFE6066C, 0x1B8D0159 */
-qS4 = 7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */
+static const double pio2_hi =
+ 1.57079632679489655800e+00, /* 0x3FF921FB, 0x54442D18 */
+ pio2_lo = 6.12323399573676603587e-17, /* 0x3C91A626, 0x33145C07 */
+ pS0 = 1.66666666666666657415e-01, /* 0x3FC55555, 0x55555555 */
+ pS1 = -3.25565818622400915405e-01, /* 0xBFD4D612, 0x03EB6F7D */
+ pS2 = 2.01212532134862925881e-01, /* 0x3FC9C155, 0x0E884455 */
+ pS3 = -4.00555345006794114027e-02, /* 0xBFA48228, 0xB5688F3B */
+ pS4 = 7.91534994289814532176e-04, /* 0x3F49EFE0, 0x7501B288 */
+ pS5 = 3.47933107596021167570e-05, /* 0x3F023DE1, 0x0DFDF709 */
+ qS1 = -2.40339491173441421878e+00, /* 0xC0033A27, 0x1C8A2D4B */
+ qS2 = 2.02094576023350569471e+00, /* 0x40002AE5, 0x9C598AC8 */
+ qS3 = -6.88283971605453293030e-01, /* 0xBFE6066C, 0x1B8D0159 */
+ qS4 = 7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */
-static double R(double z)
-{
- double_t p, q;
- p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5)))));
- q = 1.0+z*(qS1+z*(qS2+z*(qS3+z*qS4)));
- return p/q;
+static double R(double z) {
+ double_t p, q;
+ p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));
+ q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));
+ return p / q;
}
-double acos(double x)
-{
- double z,w,s,c,df;
- uint32_t hx,ix;
+double acos(double x) {
+ double z, w, s, c, df;
+ uint32_t hx, ix;
- GET_HIGH_WORD(hx, x);
- ix = hx & 0x7fffffff;
- /* |x| >= 1 or nan */
- if (ix >= 0x3ff00000) {
- uint32_t lx;
+ GET_HIGH_WORD(hx, x);
+ ix = hx & 0x7fffffff;
+ /* |x| >= 1 or nan */
+ if (ix >= 0x3ff00000) {
+ uint32_t lx;
- GET_LOW_WORD(lx,x);
- if ((ix-0x3ff00000 | lx) == 0) {
- /* acos(1)=0, acos(-1)=pi */
- if (hx >> 31)
- return 2*pio2_hi + 0x1p-120f;
- return 0;
- }
- return 0/(x-x);
- }
- /* |x| < 0.5 */
- if (ix < 0x3fe00000) {
- if (ix <= 0x3c600000) /* |x| < 2**-57 */
- return pio2_hi + 0x1p-120f;
- return pio2_hi - (x - (pio2_lo-x*R(x*x)));
- }
- /* x < -0.5 */
- if (hx >> 31) {
- z = (1.0+x)*0.5;
- s = sqrt(z);
- w = R(z)*s-pio2_lo;
- return 2*(pio2_hi - (s+w));
- }
- /* x > 0.5 */
- z = (1.0-x)*0.5;
- s = sqrt(z);
- df = s;
- SET_LOW_WORD(df,0);
- c = (z-df*df)/(s+df);
- w = R(z)*s+c;
- return 2*(df+w);
+ GET_LOW_WORD(lx, x);
+ if ((ix - 0x3ff00000 | lx) == 0) {
+ /* acos(1)=0, acos(-1)=pi */
+ if (hx >> 31)
+ return 2 * pio2_hi + 0x1p-120f;
+ return 0;
+ }
+ return 0 / (x - x);
+ }
+ /* |x| < 0.5 */
+ if (ix < 0x3fe00000) {
+ if (ix <= 0x3c600000) /* |x| < 2**-57 */
+ return pio2_hi + 0x1p-120f;
+ return pio2_hi - (x - (pio2_lo - x * R(x * x)));
+ }
+ /* x < -0.5 */
+ if (hx >> 31) {
+ z = (1.0 + x) * 0.5;
+ s = sqrt(z);
+ w = R(z) * s - pio2_lo;
+ return 2 * (pio2_hi - (s + w));
+ }
+ /* x > 0.5 */
+ z = (1.0 - x) * 0.5;
+ s = sqrt(z);
+ df = s;
+ SET_LOW_WORD(df, 0);
+ c = (z - df * df) / (s + df);
+ w = R(z) * s + c;
+ return 2 * (df + w);
}
diff --git a/fusl/src/math/acosf.c b/fusl/src/math/acosf.c
index 8ee1a71..83ef10e 100644
--- a/fusl/src/math/acosf.c
+++ b/fusl/src/math/acosf.c
@@ -15,57 +15,52 @@
#include "libm.h"
-static const float
-pio2_hi = 1.5707962513e+00, /* 0x3fc90fda */
-pio2_lo = 7.5497894159e-08, /* 0x33a22168 */
-pS0 = 1.6666586697e-01,
-pS1 = -4.2743422091e-02,
-pS2 = -8.6563630030e-03,
-qS1 = -7.0662963390e-01;
+static const float pio2_hi = 1.5707962513e+00, /* 0x3fc90fda */
+ pio2_lo = 7.5497894159e-08, /* 0x33a22168 */
+ pS0 = 1.6666586697e-01, pS1 = -4.2743422091e-02, pS2 = -8.6563630030e-03,
+ qS1 = -7.0662963390e-01;
-static float R(float z)
-{
- float_t p, q;
- p = z*(pS0+z*(pS1+z*pS2));
- q = 1.0f+z*qS1;
- return p/q;
+static float R(float z) {
+ float_t p, q;
+ p = z * (pS0 + z * (pS1 + z * pS2));
+ q = 1.0f + z * qS1;
+ return p / q;
}
-float acosf(float x)
-{
- float z,w,s,c,df;
- uint32_t hx,ix;
+float acosf(float x) {
+ float z, w, s, c, df;
+ uint32_t hx, ix;
- GET_FLOAT_WORD(hx, x);
- ix = hx & 0x7fffffff;
- /* |x| >= 1 or nan */
- if (ix >= 0x3f800000) {
- if (ix == 0x3f800000) {
- if (hx >> 31)
- return 2*pio2_hi + 0x1p-120f;
- return 0;
- }
- return 0/(x-x);
- }
- /* |x| < 0.5 */
- if (ix < 0x3f000000) {
- if (ix <= 0x32800000) /* |x| < 2**-26 */
- return pio2_hi + 0x1p-120f;
- return pio2_hi - (x - (pio2_lo-x*R(x*x)));
- }
- /* x < -0.5 */
- if (hx >> 31) {
- z = (1+x)*0.5f;
- s = sqrtf(z);
- w = R(z)*s-pio2_lo;
- return 2*(pio2_hi - (s+w));
- }
- /* x > 0.5 */
- z = (1-x)*0.5f;
- s = sqrtf(z);
- GET_FLOAT_WORD(hx,s);
- SET_FLOAT_WORD(df,hx&0xfffff000);
- c = (z-df*df)/(s+df);
- w = R(z)*s+c;
- return 2*(df+w);
+ GET_FLOAT_WORD(hx, x);
+ ix = hx & 0x7fffffff;
+ /* |x| >= 1 or nan */
+ if (ix >= 0x3f800000) {
+ if (ix == 0x3f800000) {
+ if (hx >> 31)
+ return 2 * pio2_hi + 0x1p-120f;
+ return 0;
+ }
+ return 0 / (x - x);
+ }
+ /* |x| < 0.5 */
+ if (ix < 0x3f000000) {
+ if (ix <= 0x32800000) /* |x| < 2**-26 */
+ return pio2_hi + 0x1p-120f;
+ return pio2_hi - (x - (pio2_lo - x * R(x * x)));
+ }
+ /* x < -0.5 */
+ if (hx >> 31) {
+ z = (1 + x) * 0.5f;
+ s = sqrtf(z);
+ w = R(z) * s - pio2_lo;
+ return 2 * (pio2_hi - (s + w));
+ }
+ /* x > 0.5 */
+ z = (1 - x) * 0.5f;
+ s = sqrtf(z);
+ GET_FLOAT_WORD(hx, s);
+ SET_FLOAT_WORD(df, hx & 0xfffff000);
+ c = (z - df * df) / (s + df);
+ w = R(z) * s + c;
+ return 2 * (df + w);
}
diff --git a/fusl/src/math/acosh.c b/fusl/src/math/acosh.c
index badbf90..a0299e5 100644
--- a/fusl/src/math/acosh.c
+++ b/fusl/src/math/acosh.c
@@ -1,24 +1,26 @@
#include "libm.h"
-#if FLT_EVAL_METHOD==2
+#if FLT_EVAL_METHOD == 2
#undef sqrt
#define sqrt sqrtl
#endif
/* acosh(x) = log(x + sqrt(x*x-1)) */
-double acosh(double x)
-{
- union {double f; uint64_t i;} u = {.f = x};
- unsigned e = u.i >> 52 & 0x7ff;
+double acosh(double x) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {.f = x};
+ unsigned e = u.i >> 52 & 0x7ff;
- /* x < 1 domain error is handled in the called functions */
+ /* x < 1 domain error is handled in the called functions */
- if (e < 0x3ff + 1)
- /* |x| < 2, up to 2ulp error in [1,1.125] */
- return log1p(x-1 + sqrt((x-1)*(x-1)+2*(x-1)));
- if (e < 0x3ff + 26)
- /* |x| < 0x1p26 */
- return log(2*x - 1/(x+sqrt(x*x-1)));
- /* |x| >= 0x1p26 or nan */
- return log(x) + 0.693147180559945309417232121458176568;
+ if (e < 0x3ff + 1)
+ /* |x| < 2, up to 2ulp error in [1,1.125] */
+ return log1p(x - 1 + sqrt((x - 1) * (x - 1) + 2 * (x - 1)));
+ if (e < 0x3ff + 26)
+ /* |x| < 0x1p26 */
+ return log(2 * x - 1 / (x + sqrt(x * x - 1)));
+ /* |x| >= 0x1p26 or nan */
+ return log(x) + 0.693147180559945309417232121458176568;
}
diff --git a/fusl/src/math/acoshf.c b/fusl/src/math/acoshf.c
index 8a4ec4d..e7896cd 100644
--- a/fusl/src/math/acoshf.c
+++ b/fusl/src/math/acoshf.c
@@ -1,26 +1,28 @@
#include "libm.h"
-#if FLT_EVAL_METHOD==2
+#if FLT_EVAL_METHOD == 2
#undef sqrtf
#define sqrtf sqrtl
-#elif FLT_EVAL_METHOD==1
+#elif FLT_EVAL_METHOD == 1
#undef sqrtf
#define sqrtf sqrt
#endif
/* acosh(x) = log(x + sqrt(x*x-1)) */
-float acoshf(float x)
-{
- union {float f; uint32_t i;} u = {x};
- uint32_t a = u.i & 0x7fffffff;
+float acoshf(float x) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {x};
+ uint32_t a = u.i & 0x7fffffff;
- if (a < 0x3f800000+(1<<23))
- /* |x| < 2, invalid if x < 1 or nan */
- /* up to 2ulp error in [1,1.125] */
- return log1pf(x-1 + sqrtf((x-1)*(x-1)+2*(x-1)));
- if (a < 0x3f800000+(12<<23))
- /* |x| < 0x1p12 */
- return logf(2*x - 1/(x+sqrtf(x*x-1)));
- /* x >= 0x1p12 */
- return logf(x) + 0.693147180559945309417232121458176568f;
+ if (a < 0x3f800000 + (1 << 23))
+ /* |x| < 2, invalid if x < 1 or nan */
+ /* up to 2ulp error in [1,1.125] */
+ return log1pf(x - 1 + sqrtf((x - 1) * (x - 1) + 2 * (x - 1)));
+ if (a < 0x3f800000 + (12 << 23))
+ /* |x| < 0x1p12 */
+ return logf(2 * x - 1 / (x + sqrtf(x * x - 1)));
+ /* x >= 0x1p12 */
+ return logf(x) + 0.693147180559945309417232121458176568f;
}
diff --git a/fusl/src/math/acoshl.c b/fusl/src/math/acoshl.c
index 8d4b43f..55800f2 100644
--- a/fusl/src/math/acoshl.c
+++ b/fusl/src/math/acoshl.c
@@ -1,29 +1,26 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double acoshl(long double x)
-{
- return acosh(x);
+long double acoshl(long double x) {
+ return acosh(x);
}
#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
/* acosh(x) = log(x + sqrt(x*x-1)) */
-long double acoshl(long double x)
-{
- union ldshape u = {x};
- int e = u.i.se & 0x7fff;
+long double acoshl(long double x) {
+ union ldshape u = {x};
+ int e = u.i.se & 0x7fff;
- if (e < 0x3fff + 1)
- /* |x| < 2, invalid if x < 1 or nan */
- return log1pl(x-1 + sqrtl((x-1)*(x-1)+2*(x-1)));
- if (e < 0x3fff + 32)
- /* |x| < 0x1p32 */
- return logl(2*x - 1/(x+sqrtl(x*x-1)));
- return logl(x) + 0.693147180559945309417232121458176568L;
+ if (e < 0x3fff + 1)
+ /* |x| < 2, invalid if x < 1 or nan */
+ return log1pl(x - 1 + sqrtl((x - 1) * (x - 1) + 2 * (x - 1)));
+ if (e < 0x3fff + 32)
+ /* |x| < 0x1p32 */
+ return logl(2 * x - 1 / (x + sqrtl(x * x - 1)));
+ return logl(x) + 0.693147180559945309417232121458176568L;
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
// TODO: broken implementation to make things compile
-long double acoshl(long double x)
-{
- return acosh(x);
+long double acoshl(long double x) {
+ return acosh(x);
}
#endif
diff --git a/fusl/src/math/acosl.c b/fusl/src/math/acosl.c
index c03bdf0..cfabb37 100644
--- a/fusl/src/math/acosl.c
+++ b/fusl/src/math/acosl.c
@@ -17,9 +17,8 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double acosl(long double x)
-{
- return acos(x);
+long double acosl(long double x) {
+ return acos(x);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
#include "__invtrigl.h"
@@ -29,39 +28,38 @@
#define CLEARBOTTOM(u) (u.i.lo = 0)
#endif
-long double acosl(long double x)
-{
- union ldshape u = {x};
- long double z, s, c, f;
- uint16_t e = u.i.se & 0x7fff;
+long double acosl(long double x) {
+ union ldshape u = {x};
+ long double z, s, c, f;
+ uint16_t e = u.i.se & 0x7fff;
- /* |x| >= 1 or nan */
- if (e >= 0x3fff) {
- if (x == 1)
- return 0;
- if (x == -1)
- return 2*pio2_hi + 0x1p-120f;
- return 0/(x-x);
- }
- /* |x| < 0.5 */
- if (e < 0x3fff - 1) {
- if (e < 0x3fff - LDBL_MANT_DIG - 1)
- return pio2_hi + 0x1p-120f;
- return pio2_hi - (__invtrigl_R(x*x)*x - pio2_lo + x);
- }
- /* x < -0.5 */
- if (u.i.se >> 15) {
- z = (1 + x)*0.5;
- s = sqrtl(z);
- return 2*(pio2_hi - (__invtrigl_R(z)*s - pio2_lo + s));
- }
- /* x > 0.5 */
- z = (1 - x)*0.5;
- s = sqrtl(z);
- u.f = s;
- CLEARBOTTOM(u);
- f = u.f;
- c = (z - f*f)/(s + f);
- return 2*(__invtrigl_R(z)*s + c + f);
+ /* |x| >= 1 or nan */
+ if (e >= 0x3fff) {
+ if (x == 1)
+ return 0;
+ if (x == -1)
+ return 2 * pio2_hi + 0x1p-120f;
+ return 0 / (x - x);
+ }
+ /* |x| < 0.5 */
+ if (e < 0x3fff - 1) {
+ if (e < 0x3fff - LDBL_MANT_DIG - 1)
+ return pio2_hi + 0x1p-120f;
+ return pio2_hi - (__invtrigl_R(x * x) * x - pio2_lo + x);
+ }
+ /* x < -0.5 */
+ if (u.i.se >> 15) {
+ z = (1 + x) * 0.5;
+ s = sqrtl(z);
+ return 2 * (pio2_hi - (__invtrigl_R(z) * s - pio2_lo + s));
+ }
+ /* x > 0.5 */
+ z = (1 - x) * 0.5;
+ s = sqrtl(z);
+ u.f = s;
+ CLEARBOTTOM(u);
+ f = u.f;
+ c = (z - f * f) / (s + f);
+ return 2 * (__invtrigl_R(z) * s + c + f);
}
#endif
diff --git a/fusl/src/math/arm/fabs.c b/fusl/src/math/arm/fabs.c
index f890520..1b093a7 100644
--- a/fusl/src/math/arm/fabs.c
+++ b/fusl/src/math/arm/fabs.c
@@ -2,10 +2,9 @@
#if __ARM_PCS_VFP
-double fabs(double x)
-{
- __asm__ ("vabs.f64 %P0, %P1" : "=w"(x) : "w"(x));
- return x;
+double fabs(double x) {
+ __asm__("vabs.f64 %P0, %P1" : "=w"(x) : "w"(x));
+ return x;
}
#else
diff --git a/fusl/src/math/arm/fabsf.c b/fusl/src/math/arm/fabsf.c
index 28153a6..36e5e96 100644
--- a/fusl/src/math/arm/fabsf.c
+++ b/fusl/src/math/arm/fabsf.c
@@ -2,10 +2,9 @@
#if __ARM_PCS_VFP
-float fabsf(float x)
-{
- __asm__ ("vabs.f32 %0, %1" : "=t"(x) : "t"(x));
- return x;
+float fabsf(float x) {
+ __asm__("vabs.f32 %0, %1" : "=t"(x) : "t"(x));
+ return x;
}
#else
diff --git a/fusl/src/math/arm/sqrt.c b/fusl/src/math/arm/sqrt.c
index c9c0008..20f559e 100644
--- a/fusl/src/math/arm/sqrt.c
+++ b/fusl/src/math/arm/sqrt.c
@@ -2,10 +2,9 @@
#if __VFP_FP__ && !__SOFTFP__
-double sqrt(double x)
-{
- __asm__ ("vsqrt.f64 %P0, %P1" : "=w"(x) : "w"(x));
- return x;
+double sqrt(double x) {
+ __asm__("vsqrt.f64 %P0, %P1" : "=w"(x) : "w"(x));
+ return x;
}
#else
diff --git a/fusl/src/math/arm/sqrtf.c b/fusl/src/math/arm/sqrtf.c
index e657665..5b51c15 100644
--- a/fusl/src/math/arm/sqrtf.c
+++ b/fusl/src/math/arm/sqrtf.c
@@ -2,10 +2,9 @@
#if __VFP_FP__ && !__SOFTFP__
-float sqrtf(float x)
-{
- __asm__ ("vsqrt.f32 %0, %1" : "=t"(x) : "t"(x));
- return x;
+float sqrtf(float x) {
+ __asm__("vsqrt.f32 %0, %1" : "=t"(x) : "t"(x));
+ return x;
}
#else
diff --git a/fusl/src/math/asin.c b/fusl/src/math/asin.c
index c926b18..9b92be8 100644
--- a/fusl/src/math/asin.c
+++ b/fusl/src/math/asin.c
@@ -41,67 +41,66 @@
#include "libm.h"
-static const double
-pio2_hi = 1.57079632679489655800e+00, /* 0x3FF921FB, 0x54442D18 */
-pio2_lo = 6.12323399573676603587e-17, /* 0x3C91A626, 0x33145C07 */
-/* coefficients for R(x^2) */
-pS0 = 1.66666666666666657415e-01, /* 0x3FC55555, 0x55555555 */
-pS1 = -3.25565818622400915405e-01, /* 0xBFD4D612, 0x03EB6F7D */
-pS2 = 2.01212532134862925881e-01, /* 0x3FC9C155, 0x0E884455 */
-pS3 = -4.00555345006794114027e-02, /* 0xBFA48228, 0xB5688F3B */
-pS4 = 7.91534994289814532176e-04, /* 0x3F49EFE0, 0x7501B288 */
-pS5 = 3.47933107596021167570e-05, /* 0x3F023DE1, 0x0DFDF709 */
-qS1 = -2.40339491173441421878e+00, /* 0xC0033A27, 0x1C8A2D4B */
-qS2 = 2.02094576023350569471e+00, /* 0x40002AE5, 0x9C598AC8 */
-qS3 = -6.88283971605453293030e-01, /* 0xBFE6066C, 0x1B8D0159 */
-qS4 = 7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */
+static const double pio2_hi =
+ 1.57079632679489655800e+00, /* 0x3FF921FB, 0x54442D18 */
+ pio2_lo = 6.12323399573676603587e-17, /* 0x3C91A626, 0x33145C07 */
+ /* coefficients for R(x^2) */
+ pS0 = 1.66666666666666657415e-01, /* 0x3FC55555, 0x55555555 */
+ pS1 = -3.25565818622400915405e-01, /* 0xBFD4D612, 0x03EB6F7D */
+ pS2 = 2.01212532134862925881e-01, /* 0x3FC9C155, 0x0E884455 */
+ pS3 = -4.00555345006794114027e-02, /* 0xBFA48228, 0xB5688F3B */
+ pS4 = 7.91534994289814532176e-04, /* 0x3F49EFE0, 0x7501B288 */
+ pS5 = 3.47933107596021167570e-05, /* 0x3F023DE1, 0x0DFDF709 */
+ qS1 = -2.40339491173441421878e+00, /* 0xC0033A27, 0x1C8A2D4B */
+ qS2 = 2.02094576023350569471e+00, /* 0x40002AE5, 0x9C598AC8 */
+ qS3 = -6.88283971605453293030e-01, /* 0xBFE6066C, 0x1B8D0159 */
+ qS4 = 7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */
-static double R(double z)
-{
- double_t p, q;
- p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5)))));
- q = 1.0+z*(qS1+z*(qS2+z*(qS3+z*qS4)));
- return p/q;
+static double R(double z) {
+ double_t p, q;
+ p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));
+ q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));
+ return p / q;
}
-double asin(double x)
-{
- double z,r,s;
- uint32_t hx,ix;
+double asin(double x) {
+ double z, r, s;
+ uint32_t hx, ix;
- GET_HIGH_WORD(hx, x);
- ix = hx & 0x7fffffff;
- /* |x| >= 1 or nan */
- if (ix >= 0x3ff00000) {
- uint32_t lx;
- GET_LOW_WORD(lx, x);
- if ((ix-0x3ff00000 | lx) == 0)
- /* asin(1) = +-pi/2 with inexact */
- return x*pio2_hi + 0x1p-120f;
- return 0/(x-x);
- }
- /* |x| < 0.5 */
- if (ix < 0x3fe00000) {
- /* if 0x1p-1022 <= |x| < 0x1p-26, avoid raising underflow */
- if (ix < 0x3e500000 && ix >= 0x00100000)
- return x;
- return x + x*R(x*x);
- }
- /* 1 > |x| >= 0.5 */
- z = (1 - fabs(x))*0.5;
- s = sqrt(z);
- r = R(z);
- if (ix >= 0x3fef3333) { /* if |x| > 0.975 */
- x = pio2_hi-(2*(s+s*r)-pio2_lo);
- } else {
- double f,c;
- /* f+c = sqrt(z) */
- f = s;
- SET_LOW_WORD(f,0);
- c = (z-f*f)/(s+f);
- x = 0.5*pio2_hi - (2*s*r - (pio2_lo-2*c) - (0.5*pio2_hi-2*f));
- }
- if (hx >> 31)
- return -x;
- return x;
+ GET_HIGH_WORD(hx, x);
+ ix = hx & 0x7fffffff;
+ /* |x| >= 1 or nan */
+ if (ix >= 0x3ff00000) {
+ uint32_t lx;
+ GET_LOW_WORD(lx, x);
+ if ((ix - 0x3ff00000 | lx) == 0)
+ /* asin(1) = +-pi/2 with inexact */
+ return x * pio2_hi + 0x1p-120f;
+ return 0 / (x - x);
+ }
+ /* |x| < 0.5 */
+ if (ix < 0x3fe00000) {
+ /* if 0x1p-1022 <= |x| < 0x1p-26, avoid raising underflow */
+ if (ix < 0x3e500000 && ix >= 0x00100000)
+ return x;
+ return x + x * R(x * x);
+ }
+ /* 1 > |x| >= 0.5 */
+ z = (1 - fabs(x)) * 0.5;
+ s = sqrt(z);
+ r = R(z);
+ if (ix >= 0x3fef3333) { /* if |x| > 0.975 */
+ x = pio2_hi - (2 * (s + s * r) - pio2_lo);
+ } else {
+ double f, c;
+ /* f+c = sqrt(z) */
+ f = s;
+ SET_LOW_WORD(f, 0);
+ c = (z - f * f) / (s + f);
+ x = 0.5 * pio2_hi -
+ (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));
+ }
+ if (hx >> 31)
+ return -x;
+ return x;
}
diff --git a/fusl/src/math/asinf.c b/fusl/src/math/asinf.c
index bcd304a..3d5f637 100644
--- a/fusl/src/math/asinf.c
+++ b/fusl/src/math/asinf.c
@@ -14,48 +14,43 @@
*/
#include "libm.h"
-static const double
-pio2 = 1.570796326794896558e+00;
+static const double pio2 = 1.570796326794896558e+00;
static const float
-/* coefficients for R(x^2) */
-pS0 = 1.6666586697e-01,
-pS1 = -4.2743422091e-02,
-pS2 = -8.6563630030e-03,
-qS1 = -7.0662963390e-01;
+ /* coefficients for R(x^2) */
+ pS0 = 1.6666586697e-01,
+ pS1 = -4.2743422091e-02, pS2 = -8.6563630030e-03, qS1 = -7.0662963390e-01;
-static float R(float z)
-{
- float_t p, q;
- p = z*(pS0+z*(pS1+z*pS2));
- q = 1.0f+z*qS1;
- return p/q;
+static float R(float z) {
+ float_t p, q;
+ p = z * (pS0 + z * (pS1 + z * pS2));
+ q = 1.0f + z * qS1;
+ return p / q;
}
-float asinf(float x)
-{
- double s;
- float z;
- uint32_t hx,ix;
+float asinf(float x) {
+ double s;
+ float z;
+ uint32_t hx, ix;
- GET_FLOAT_WORD(hx, x);
- ix = hx & 0x7fffffff;
- if (ix >= 0x3f800000) { /* |x| >= 1 */
- if (ix == 0x3f800000) /* |x| == 1 */
- return x*pio2 + 0x1p-120f; /* asin(+-1) = +-pi/2 with inexact */
- return 0/(x-x); /* asin(|x|>1) is NaN */
- }
- if (ix < 0x3f000000) { /* |x| < 0.5 */
- /* if 0x1p-126 <= |x| < 0x1p-12, avoid raising underflow */
- if (ix < 0x39800000 && ix >= 0x00800000)
- return x;
- return x + x*R(x*x);
- }
- /* 1 > |x| >= 0.5 */
- z = (1 - fabsf(x))*0.5f;
- s = sqrt(z);
- x = pio2 - 2*(s+s*R(z));
- if (hx >> 31)
- return -x;
- return x;
+ GET_FLOAT_WORD(hx, x);
+ ix = hx & 0x7fffffff;
+ if (ix >= 0x3f800000) { /* |x| >= 1 */
+ if (ix == 0x3f800000) /* |x| == 1 */
+ return x * pio2 + 0x1p-120f; /* asin(+-1) = +-pi/2 with inexact */
+ return 0 / (x - x); /* asin(|x|>1) is NaN */
+ }
+ if (ix < 0x3f000000) { /* |x| < 0.5 */
+ /* if 0x1p-126 <= |x| < 0x1p-12, avoid raising underflow */
+ if (ix < 0x39800000 && ix >= 0x00800000)
+ return x;
+ return x + x * R(x * x);
+ }
+ /* 1 > |x| >= 0.5 */
+ z = (1 - fabsf(x)) * 0.5f;
+ s = sqrt(z);
+ x = pio2 - 2 * (s + s * R(z));
+ if (hx >> 31)
+ return -x;
+ return x;
}
diff --git a/fusl/src/math/asinh.c b/fusl/src/math/asinh.c
index 0829f22..b6d00df 100644
--- a/fusl/src/math/asinh.c
+++ b/fusl/src/math/asinh.c
@@ -1,28 +1,30 @@
#include "libm.h"
/* asinh(x) = sign(x)*log(|x|+sqrt(x*x+1)) ~= x - x^3/6 + o(x^5) */
-double asinh(double x)
-{
- union {double f; uint64_t i;} u = {.f = x};
- unsigned e = u.i >> 52 & 0x7ff;
- unsigned s = u.i >> 63;
+double asinh(double x) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {.f = x};
+ unsigned e = u.i >> 52 & 0x7ff;
+ unsigned s = u.i >> 63;
- /* |x| */
- u.i &= (uint64_t)-1/2;
- x = u.f;
+ /* |x| */
+ u.i &= (uint64_t)-1 / 2;
+ x = u.f;
- if (e >= 0x3ff + 26) {
- /* |x| >= 0x1p26 or inf or nan */
- x = log(x) + 0.693147180559945309417232121458176568;
- } else if (e >= 0x3ff + 1) {
- /* |x| >= 2 */
- x = log(2*x + 1/(sqrt(x*x+1)+x));
- } else if (e >= 0x3ff - 26) {
- /* |x| >= 0x1p-26, up to 1.6ulp error in [0.125,0.5] */
- x = log1p(x + x*x/(sqrt(x*x+1)+1));
- } else {
- /* |x| < 0x1p-26, raise inexact if x != 0 */
- FORCE_EVAL(x + 0x1p120f);
- }
- return s ? -x : x;
+ if (e >= 0x3ff + 26) {
+ /* |x| >= 0x1p26 or inf or nan */
+ x = log(x) + 0.693147180559945309417232121458176568;
+ } else if (e >= 0x3ff + 1) {
+ /* |x| >= 2 */
+ x = log(2 * x + 1 / (sqrt(x * x + 1) + x));
+ } else if (e >= 0x3ff - 26) {
+ /* |x| >= 0x1p-26, up to 1.6ulp error in [0.125,0.5] */
+ x = log1p(x + x * x / (sqrt(x * x + 1) + 1));
+ } else {
+ /* |x| < 0x1p-26, raise inexact if x != 0 */
+ FORCE_EVAL(x + 0x1p120f);
+ }
+ return s ? -x : x;
}
diff --git a/fusl/src/math/asinhf.c b/fusl/src/math/asinhf.c
index fc9f091..5d79d1c 100644
--- a/fusl/src/math/asinhf.c
+++ b/fusl/src/math/asinhf.c
@@ -1,28 +1,30 @@
#include "libm.h"
/* asinh(x) = sign(x)*log(|x|+sqrt(x*x+1)) ~= x - x^3/6 + o(x^5) */
-float asinhf(float x)
-{
- union {float f; uint32_t i;} u = {.f = x};
- uint32_t i = u.i & 0x7fffffff;
- unsigned s = u.i >> 31;
+float asinhf(float x) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {.f = x};
+ uint32_t i = u.i & 0x7fffffff;
+ unsigned s = u.i >> 31;
- /* |x| */
- u.i = i;
- x = u.f;
+ /* |x| */
+ u.i = i;
+ x = u.f;
- if (i >= 0x3f800000 + (12<<23)) {
- /* |x| >= 0x1p12 or inf or nan */
- x = logf(x) + 0.693147180559945309417232121458176568f;
- } else if (i >= 0x3f800000 + (1<<23)) {
- /* |x| >= 2 */
- x = logf(2*x + 1/(sqrtf(x*x+1)+x));
- } else if (i >= 0x3f800000 - (12<<23)) {
- /* |x| >= 0x1p-12, up to 1.6ulp error in [0.125,0.5] */
- x = log1pf(x + x*x/(sqrtf(x*x+1)+1));
- } else {
- /* |x| < 0x1p-12, raise inexact if x!=0 */
- FORCE_EVAL(x + 0x1p120f);
- }
- return s ? -x : x;
+ if (i >= 0x3f800000 + (12 << 23)) {
+ /* |x| >= 0x1p12 or inf or nan */
+ x = logf(x) + 0.693147180559945309417232121458176568f;
+ } else if (i >= 0x3f800000 + (1 << 23)) {
+ /* |x| >= 2 */
+ x = logf(2 * x + 1 / (sqrtf(x * x + 1) + x));
+ } else if (i >= 0x3f800000 - (12 << 23)) {
+ /* |x| >= 0x1p-12, up to 1.6ulp error in [0.125,0.5] */
+ x = log1pf(x + x * x / (sqrtf(x * x + 1) + 1));
+ } else {
+ /* |x| < 0x1p-12, raise inexact if x!=0 */
+ FORCE_EVAL(x + 0x1p120f);
+ }
+ return s ? -x : x;
}
diff --git a/fusl/src/math/asinhl.c b/fusl/src/math/asinhl.c
index 8635f52..2be91e9 100644
--- a/fusl/src/math/asinhl.c
+++ b/fusl/src/math/asinhl.c
@@ -1,41 +1,38 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double asinhl(long double x)
-{
- return asinh(x);
+long double asinhl(long double x) {
+ return asinh(x);
}
#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
/* asinh(x) = sign(x)*log(|x|+sqrt(x*x+1)) ~= x - x^3/6 + o(x^5) */
-long double asinhl(long double x)
-{
- union ldshape u = {x};
- unsigned e = u.i.se & 0x7fff;
- unsigned s = u.i.se >> 15;
+long double asinhl(long double x) {
+ union ldshape u = {x};
+ unsigned e = u.i.se & 0x7fff;
+ unsigned s = u.i.se >> 15;
- /* |x| */
- u.i.se = e;
- x = u.f;
+ /* |x| */
+ u.i.se = e;
+ x = u.f;
- if (e >= 0x3fff + 32) {
- /* |x| >= 0x1p32 or inf or nan */
- x = logl(x) + 0.693147180559945309417232121458176568L;
- } else if (e >= 0x3fff + 1) {
- /* |x| >= 2 */
- x = logl(2*x + 1/(sqrtl(x*x+1)+x));
- } else if (e >= 0x3fff - 32) {
- /* |x| >= 0x1p-32 */
- x = log1pl(x + x*x/(sqrtl(x*x+1)+1));
- } else {
- /* |x| < 0x1p-32, raise inexact if x!=0 */
- FORCE_EVAL(x + 0x1p120f);
- }
- return s ? -x : x;
+ if (e >= 0x3fff + 32) {
+ /* |x| >= 0x1p32 or inf or nan */
+ x = logl(x) + 0.693147180559945309417232121458176568L;
+ } else if (e >= 0x3fff + 1) {
+ /* |x| >= 2 */
+ x = logl(2 * x + 1 / (sqrtl(x * x + 1) + x));
+ } else if (e >= 0x3fff - 32) {
+ /* |x| >= 0x1p-32 */
+ x = log1pl(x + x * x / (sqrtl(x * x + 1) + 1));
+ } else {
+ /* |x| < 0x1p-32, raise inexact if x!=0 */
+ FORCE_EVAL(x + 0x1p120f);
+ }
+ return s ? -x : x;
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
// TODO: broken implementation to make things compile
-long double asinhl(long double x)
-{
- return asinh(x);
+long double asinhl(long double x) {
+ return asinh(x);
}
#endif
diff --git a/fusl/src/math/asinl.c b/fusl/src/math/asinl.c
index 347c535..7494848 100644
--- a/fusl/src/math/asinl.c
+++ b/fusl/src/math/asinl.c
@@ -17,55 +17,54 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double asinl(long double x)
-{
- return asin(x);
+long double asinl(long double x) {
+ return asin(x);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
#include "__invtrigl.h"
#if LDBL_MANT_DIG == 64
-#define CLOSETO1(u) (u.i.m>>56 >= 0xf7)
+#define CLOSETO1(u) (u.i.m >> 56 >= 0xf7)
#define CLEARBOTTOM(u) (u.i.m &= -1ULL << 32)
#elif LDBL_MANT_DIG == 113
#define CLOSETO1(u) (u.i.top >= 0xee00)
#define CLEARBOTTOM(u) (u.i.lo = 0)
#endif
-long double asinl(long double x)
-{
- union ldshape u = {x};
- long double z, r, s;
- uint16_t e = u.i.se & 0x7fff;
- int sign = u.i.se >> 15;
+long double asinl(long double x) {
+ union ldshape u = {x};
+ long double z, r, s;
+ uint16_t e = u.i.se & 0x7fff;
+ int sign = u.i.se >> 15;
- if (e >= 0x3fff) { /* |x| >= 1 or nan */
- /* asin(+-1)=+-pi/2 with inexact */
- if (x == 1 || x == -1)
- return x*pio2_hi + 0x1p-120f;
- return 0/(x-x);
- }
- if (e < 0x3fff - 1) { /* |x| < 0.5 */
- if (e < 0x3fff - (LDBL_MANT_DIG+1)/2) {
- /* return x with inexact if x!=0 */
- FORCE_EVAL(x + 0x1p120f);
- return x;
- }
- return x + x*__invtrigl_R(x*x);
- }
- /* 1 > |x| >= 0.5 */
- z = (1.0 - fabsl(x))*0.5;
- s = sqrtl(z);
- r = __invtrigl_R(z);
- if (CLOSETO1(u)) {
- x = pio2_hi - (2*(s+s*r)-pio2_lo);
- } else {
- long double f, c;
- u.f = s;
- CLEARBOTTOM(u);
- f = u.f;
- c = (z - f*f)/(s + f);
- x = 0.5*pio2_hi-(2*s*r - (pio2_lo-2*c) - (0.5*pio2_hi-2*f));
- }
- return sign ? -x : x;
+ if (e >= 0x3fff) { /* |x| >= 1 or nan */
+ /* asin(+-1)=+-pi/2 with inexact */
+ if (x == 1 || x == -1)
+ return x * pio2_hi + 0x1p-120f;
+ return 0 / (x - x);
+ }
+ if (e < 0x3fff - 1) { /* |x| < 0.5 */
+ if (e < 0x3fff - (LDBL_MANT_DIG + 1) / 2) {
+ /* return x with inexact if x!=0 */
+ FORCE_EVAL(x + 0x1p120f);
+ return x;
+ }
+ return x + x * __invtrigl_R(x * x);
+ }
+ /* 1 > |x| >= 0.5 */
+ z = (1.0 - fabsl(x)) * 0.5;
+ s = sqrtl(z);
+ r = __invtrigl_R(z);
+ if (CLOSETO1(u)) {
+ x = pio2_hi - (2 * (s + s * r) - pio2_lo);
+ } else {
+ long double f, c;
+ u.f = s;
+ CLEARBOTTOM(u);
+ f = u.f;
+ c = (z - f * f) / (s + f);
+ x = 0.5 * pio2_hi -
+ (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));
+ }
+ return sign ? -x : x;
}
#endif
diff --git a/fusl/src/math/atan.c b/fusl/src/math/atan.c
index 63b0ab2..8d33b53 100644
--- a/fusl/src/math/atan.c
+++ b/fusl/src/math/atan.c
@@ -29,88 +29,87 @@
* to produce the hexadecimal values shown.
*/
-
#include "libm.h"
static const double atanhi[] = {
- 4.63647609000806093515e-01, /* atan(0.5)hi 0x3FDDAC67, 0x0561BB4F */
- 7.85398163397448278999e-01, /* atan(1.0)hi 0x3FE921FB, 0x54442D18 */
- 9.82793723247329054082e-01, /* atan(1.5)hi 0x3FEF730B, 0xD281F69B */
- 1.57079632679489655800e+00, /* atan(inf)hi 0x3FF921FB, 0x54442D18 */
+ 4.63647609000806093515e-01, /* atan(0.5)hi 0x3FDDAC67, 0x0561BB4F */
+ 7.85398163397448278999e-01, /* atan(1.0)hi 0x3FE921FB, 0x54442D18 */
+ 9.82793723247329054082e-01, /* atan(1.5)hi 0x3FEF730B, 0xD281F69B */
+ 1.57079632679489655800e+00, /* atan(inf)hi 0x3FF921FB, 0x54442D18 */
};
static const double atanlo[] = {
- 2.26987774529616870924e-17, /* atan(0.5)lo 0x3C7A2B7F, 0x222F65E2 */
- 3.06161699786838301793e-17, /* atan(1.0)lo 0x3C81A626, 0x33145C07 */
- 1.39033110312309984516e-17, /* atan(1.5)lo 0x3C700788, 0x7AF0CBBD */
- 6.12323399573676603587e-17, /* atan(inf)lo 0x3C91A626, 0x33145C07 */
+ 2.26987774529616870924e-17, /* atan(0.5)lo 0x3C7A2B7F, 0x222F65E2 */
+ 3.06161699786838301793e-17, /* atan(1.0)lo 0x3C81A626, 0x33145C07 */
+ 1.39033110312309984516e-17, /* atan(1.5)lo 0x3C700788, 0x7AF0CBBD */
+ 6.12323399573676603587e-17, /* atan(inf)lo 0x3C91A626, 0x33145C07 */
};
static const double aT[] = {
- 3.33333333333329318027e-01, /* 0x3FD55555, 0x5555550D */
- -1.99999999998764832476e-01, /* 0xBFC99999, 0x9998EBC4 */
- 1.42857142725034663711e-01, /* 0x3FC24924, 0x920083FF */
- -1.11111104054623557880e-01, /* 0xBFBC71C6, 0xFE231671 */
- 9.09088713343650656196e-02, /* 0x3FB745CD, 0xC54C206E */
- -7.69187620504482999495e-02, /* 0xBFB3B0F2, 0xAF749A6D */
- 6.66107313738753120669e-02, /* 0x3FB10D66, 0xA0D03D51 */
- -5.83357013379057348645e-02, /* 0xBFADDE2D, 0x52DEFD9A */
- 4.97687799461593236017e-02, /* 0x3FA97B4B, 0x24760DEB */
- -3.65315727442169155270e-02, /* 0xBFA2B444, 0x2C6A6C2F */
- 1.62858201153657823623e-02, /* 0x3F90AD3A, 0xE322DA11 */
+ 3.33333333333329318027e-01, /* 0x3FD55555, 0x5555550D */
+ -1.99999999998764832476e-01, /* 0xBFC99999, 0x9998EBC4 */
+ 1.42857142725034663711e-01, /* 0x3FC24924, 0x920083FF */
+ -1.11111104054623557880e-01, /* 0xBFBC71C6, 0xFE231671 */
+ 9.09088713343650656196e-02, /* 0x3FB745CD, 0xC54C206E */
+ -7.69187620504482999495e-02, /* 0xBFB3B0F2, 0xAF749A6D */
+ 6.66107313738753120669e-02, /* 0x3FB10D66, 0xA0D03D51 */
+ -5.83357013379057348645e-02, /* 0xBFADDE2D, 0x52DEFD9A */
+ 4.97687799461593236017e-02, /* 0x3FA97B4B, 0x24760DEB */
+ -3.65315727442169155270e-02, /* 0xBFA2B444, 0x2C6A6C2F */
+ 1.62858201153657823623e-02, /* 0x3F90AD3A, 0xE322DA11 */
};
-double atan(double x)
-{
- double_t w,s1,s2,z;
- uint32_t ix,sign;
- int id;
+double atan(double x) {
+ double_t w, s1, s2, z;
+ uint32_t ix, sign;
+ int id;
- GET_HIGH_WORD(ix, x);
- sign = ix >> 31;
- ix &= 0x7fffffff;
- if (ix >= 0x44100000) { /* if |x| >= 2^66 */
- if (isnan(x))
- return x;
- z = atanhi[3] + 0x1p-120f;
- return sign ? -z : z;
- }
- if (ix < 0x3fdc0000) { /* |x| < 0.4375 */
- if (ix < 0x3e400000) { /* |x| < 2^-27 */
- if (ix < 0x00100000)
- /* raise underflow for subnormal x */
- FORCE_EVAL((float)x);
- return x;
- }
- id = -1;
- } else {
- x = fabs(x);
- if (ix < 0x3ff30000) { /* |x| < 1.1875 */
- if (ix < 0x3fe60000) { /* 7/16 <= |x| < 11/16 */
- id = 0;
- x = (2.0*x-1.0)/(2.0+x);
- } else { /* 11/16 <= |x| < 19/16 */
- id = 1;
- x = (x-1.0)/(x+1.0);
- }
- } else {
- if (ix < 0x40038000) { /* |x| < 2.4375 */
- id = 2;
- x = (x-1.5)/(1.0+1.5*x);
- } else { /* 2.4375 <= |x| < 2^66 */
- id = 3;
- x = -1.0/x;
- }
- }
- }
- /* end of argument reduction */
- z = x*x;
- w = z*z;
- /* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */
- s1 = z*(aT[0]+w*(aT[2]+w*(aT[4]+w*(aT[6]+w*(aT[8]+w*aT[10])))));
- s2 = w*(aT[1]+w*(aT[3]+w*(aT[5]+w*(aT[7]+w*aT[9]))));
- if (id < 0)
- return x - x*(s1+s2);
- z = atanhi[id] - (x*(s1+s2) - atanlo[id] - x);
- return sign ? -z : z;
+ GET_HIGH_WORD(ix, x);
+ sign = ix >> 31;
+ ix &= 0x7fffffff;
+ if (ix >= 0x44100000) { /* if |x| >= 2^66 */
+ if (isnan(x))
+ return x;
+ z = atanhi[3] + 0x1p-120f;
+ return sign ? -z : z;
+ }
+ if (ix < 0x3fdc0000) { /* |x| < 0.4375 */
+ if (ix < 0x3e400000) { /* |x| < 2^-27 */
+ if (ix < 0x00100000)
+ /* raise underflow for subnormal x */
+ FORCE_EVAL((float)x);
+ return x;
+ }
+ id = -1;
+ } else {
+ x = fabs(x);
+ if (ix < 0x3ff30000) { /* |x| < 1.1875 */
+ if (ix < 0x3fe60000) { /* 7/16 <= |x| < 11/16 */
+ id = 0;
+ x = (2.0 * x - 1.0) / (2.0 + x);
+ } else { /* 11/16 <= |x| < 19/16 */
+ id = 1;
+ x = (x - 1.0) / (x + 1.0);
+ }
+ } else {
+ if (ix < 0x40038000) { /* |x| < 2.4375 */
+ id = 2;
+ x = (x - 1.5) / (1.0 + 1.5 * x);
+ } else { /* 2.4375 <= |x| < 2^66 */
+ id = 3;
+ x = -1.0 / x;
+ }
+ }
+ }
+ /* end of argument reduction */
+ z = x * x;
+ w = z * z;
+ /* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */
+ s1 = z * (aT[0] +
+ w * (aT[2] + w * (aT[4] + w * (aT[6] + w * (aT[8] + w * aT[10])))));
+ s2 = w * (aT[1] + w * (aT[3] + w * (aT[5] + w * (aT[7] + w * aT[9]))));
+ if (id < 0)
+ return x - x * (s1 + s2);
+ z = atanhi[id] - (x * (s1 + s2) - atanlo[id] - x);
+ return sign ? -z : z;
}
diff --git a/fusl/src/math/atan2.c b/fusl/src/math/atan2.c
index 5a1903c..11427d7 100644
--- a/fusl/src/math/atan2.c
+++ b/fusl/src/math/atan2.c
@@ -39,69 +39,81 @@
#include "libm.h"
-static const double
-pi = 3.1415926535897931160E+00, /* 0x400921FB, 0x54442D18 */
-pi_lo = 1.2246467991473531772E-16; /* 0x3CA1A626, 0x33145C07 */
+static const double pi = 3.1415926535897931160E+00, /* 0x400921FB, 0x54442D18 */
+ pi_lo = 1.2246467991473531772E-16; /* 0x3CA1A626, 0x33145C07 */
-double atan2(double y, double x)
-{
- double z;
- uint32_t m,lx,ly,ix,iy;
+double atan2(double y, double x) {
+ double z;
+ uint32_t m, lx, ly, ix, iy;
- if (isnan(x) || isnan(y))
- return x+y;
- EXTRACT_WORDS(ix, lx, x);
- EXTRACT_WORDS(iy, ly, y);
- if ((ix-0x3ff00000 | lx) == 0) /* x = 1.0 */
- return atan(y);
- m = ((iy>>31)&1) | ((ix>>30)&2); /* 2*sign(x)+sign(y) */
- ix = ix & 0x7fffffff;
- iy = iy & 0x7fffffff;
+ if (isnan(x) || isnan(y))
+ return x + y;
+ EXTRACT_WORDS(ix, lx, x);
+ EXTRACT_WORDS(iy, ly, y);
+ if ((ix - 0x3ff00000 | lx) == 0) /* x = 1.0 */
+ return atan(y);
+ m = ((iy >> 31) & 1) | ((ix >> 30) & 2); /* 2*sign(x)+sign(y) */
+ ix = ix & 0x7fffffff;
+ iy = iy & 0x7fffffff;
- /* when y = 0 */
- if ((iy|ly) == 0) {
- switch(m) {
- case 0:
- case 1: return y; /* atan(+-0,+anything)=+-0 */
- case 2: return pi; /* atan(+0,-anything) = pi */
- case 3: return -pi; /* atan(-0,-anything) =-pi */
- }
- }
- /* when x = 0 */
- if ((ix|lx) == 0)
- return m&1 ? -pi/2 : pi/2;
- /* when x is INF */
- if (ix == 0x7ff00000) {
- if (iy == 0x7ff00000) {
- switch(m) {
- case 0: return pi/4; /* atan(+INF,+INF) */
- case 1: return -pi/4; /* atan(-INF,+INF) */
- case 2: return 3*pi/4; /* atan(+INF,-INF) */
- case 3: return -3*pi/4; /* atan(-INF,-INF) */
- }
- } else {
- switch(m) {
- case 0: return 0.0; /* atan(+...,+INF) */
- case 1: return -0.0; /* atan(-...,+INF) */
- case 2: return pi; /* atan(+...,-INF) */
- case 3: return -pi; /* atan(-...,-INF) */
- }
- }
- }
- /* |y/x| > 0x1p64 */
- if (ix+(64<<20) < iy || iy == 0x7ff00000)
- return m&1 ? -pi/2 : pi/2;
+ /* when y = 0 */
+ if ((iy | ly) == 0) {
+ switch (m) {
+ case 0:
+ case 1:
+ return y; /* atan(+-0,+anything)=+-0 */
+ case 2:
+ return pi; /* atan(+0,-anything) = pi */
+ case 3:
+ return -pi; /* atan(-0,-anything) =-pi */
+ }
+ }
+ /* when x = 0 */
+ if ((ix | lx) == 0)
+ return m & 1 ? -pi / 2 : pi / 2;
+ /* when x is INF */
+ if (ix == 0x7ff00000) {
+ if (iy == 0x7ff00000) {
+ switch (m) {
+ case 0:
+ return pi / 4; /* atan(+INF,+INF) */
+ case 1:
+ return -pi / 4; /* atan(-INF,+INF) */
+ case 2:
+ return 3 * pi / 4; /* atan(+INF,-INF) */
+ case 3:
+ return -3 * pi / 4; /* atan(-INF,-INF) */
+ }
+ } else {
+ switch (m) {
+ case 0:
+ return 0.0; /* atan(+...,+INF) */
+ case 1:
+ return -0.0; /* atan(-...,+INF) */
+ case 2:
+ return pi; /* atan(+...,-INF) */
+ case 3:
+ return -pi; /* atan(-...,-INF) */
+ }
+ }
+ }
+ /* |y/x| > 0x1p64 */
+ if (ix + (64 << 20) < iy || iy == 0x7ff00000)
+ return m & 1 ? -pi / 2 : pi / 2;
- /* z = atan(|y/x|) without spurious underflow */
- if ((m&2) && iy+(64<<20) < ix) /* |y/x| < 0x1p-64, x<0 */
- z = 0;
- else
- z = atan(fabs(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(-,-) */
- }
+ /* z = atan(|y/x|) without spurious underflow */
+ if ((m & 2) && iy + (64 << 20) < ix) /* |y/x| < 0x1p-64, x<0 */
+ z = 0;
+ else
+ z = atan(fabs(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/fusl/src/math/atan2f.c b/fusl/src/math/atan2f.c
index c634d00..559f0b7 100644
--- a/fusl/src/math/atan2f.c
+++ b/fusl/src/math/atan2f.c
@@ -15,69 +15,81 @@
#include "libm.h"
-static const float
-pi = 3.1415927410e+00, /* 0x40490fdb */
-pi_lo = -8.7422776573e-08; /* 0xb3bbbd2e */
+static const float pi = 3.1415927410e+00, /* 0x40490fdb */
+ pi_lo = -8.7422776573e-08; /* 0xb3bbbd2e */
-float atan2f(float y, float x)
-{
- float z;
- uint32_t m,ix,iy;
+float atan2f(float y, float x) {
+ float z;
+ uint32_t m, ix, iy;
- if (isnan(x) || isnan(y))
- return x+y;
- GET_FLOAT_WORD(ix, x);
- GET_FLOAT_WORD(iy, y);
- if (ix == 0x3f800000) /* x=1.0 */
- return atanf(y);
- m = ((iy>>31)&1) | ((ix>>30)&2); /* 2*sign(x)+sign(y) */
- ix &= 0x7fffffff;
- iy &= 0x7fffffff;
+ if (isnan(x) || isnan(y))
+ return x + y;
+ GET_FLOAT_WORD(ix, x);
+ GET_FLOAT_WORD(iy, y);
+ if (ix == 0x3f800000) /* x=1.0 */
+ return atanf(y);
+ m = ((iy >> 31) & 1) | ((ix >> 30) & 2); /* 2*sign(x)+sign(y) */
+ ix &= 0x7fffffff;
+ iy &= 0x7fffffff;
- /* when y = 0 */
- if (iy == 0) {
- switch (m) {
- case 0:
- case 1: return y; /* atan(+-0,+anything)=+-0 */
- case 2: return pi; /* atan(+0,-anything) = pi */
- case 3: return -pi; /* atan(-0,-anything) =-pi */
- }
- }
- /* when x = 0 */
- if (ix == 0)
- return m&1 ? -pi/2 : pi/2;
- /* when x is INF */
- if (ix == 0x7f800000) {
- if (iy == 0x7f800000) {
- switch (m) {
- case 0: return pi/4; /* atan(+INF,+INF) */
- case 1: return -pi/4; /* atan(-INF,+INF) */
- case 2: return 3*pi/4; /*atan(+INF,-INF)*/
- case 3: return -3*pi/4; /*atan(-INF,-INF)*/
- }
- } else {
- switch (m) {
- case 0: return 0.0f; /* atan(+...,+INF) */
- case 1: return -0.0f; /* atan(-...,+INF) */
- case 2: return pi; /* atan(+...,-INF) */
- case 3: return -pi; /* atan(-...,-INF) */
- }
- }
- }
- /* |y/x| > 0x1p26 */
- if (ix+(26<<23) < iy || iy == 0x7f800000)
- return m&1 ? -pi/2 : pi/2;
+ /* when y = 0 */
+ if (iy == 0) {
+ switch (m) {
+ case 0:
+ case 1:
+ return y; /* atan(+-0,+anything)=+-0 */
+ case 2:
+ return pi; /* atan(+0,-anything) = pi */
+ case 3:
+ return -pi; /* atan(-0,-anything) =-pi */
+ }
+ }
+ /* when x = 0 */
+ if (ix == 0)
+ return m & 1 ? -pi / 2 : pi / 2;
+ /* when x is INF */
+ if (ix == 0x7f800000) {
+ if (iy == 0x7f800000) {
+ switch (m) {
+ case 0:
+ return pi / 4; /* atan(+INF,+INF) */
+ case 1:
+ return -pi / 4; /* atan(-INF,+INF) */
+ case 2:
+ return 3 * pi / 4; /*atan(+INF,-INF)*/
+ case 3:
+ return -3 * pi / 4; /*atan(-INF,-INF)*/
+ }
+ } else {
+ switch (m) {
+ case 0:
+ return 0.0f; /* atan(+...,+INF) */
+ case 1:
+ return -0.0f; /* atan(-...,+INF) */
+ case 2:
+ return pi; /* atan(+...,-INF) */
+ case 3:
+ return -pi; /* atan(-...,-INF) */
+ }
+ }
+ }
+ /* |y/x| > 0x1p26 */
+ if (ix + (26 << 23) < iy || iy == 0x7f800000)
+ return m & 1 ? -pi / 2 : pi / 2;
- /* z = atan(|y/x|) with correct underflow */
- if ((m&2) && iy+(26<<23) < ix) /*|y/x| < 0x1p-26, x < 0 */
- z = 0.0;
- else
- z = atanf(fabsf(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(-,-) */
- }
+ /* z = atan(|y/x|) with correct underflow */
+ if ((m & 2) && iy + (26 << 23) < ix) /*|y/x| < 0x1p-26, x < 0 */
+ z = 0.0;
+ else
+ z = atanf(fabsf(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/fusl/src/math/atan2l.c b/fusl/src/math/atan2l.c
index f0937a9..055da95 100644
--- a/fusl/src/math/atan2l.c
+++ b/fusl/src/math/atan2l.c
@@ -18,68 +18,80 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double atan2l(long double y, long double x)
-{
- return atan2(y, x);
+long double atan2l(long double y, long double x) {
+ return atan2(y, x);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
#include "__invtrigl.h"
-long double atan2l(long double y, long double x)
-{
- union ldshape ux, uy;
- long double z;
- int m, ex, ey;
+long double atan2l(long double y, long double x) {
+ union ldshape ux, uy;
+ long double z;
+ int m, ex, ey;
- if (isnan(x) || isnan(y))
- return x+y;
- if (x == 1)
- return atanl(y);
- ux.f = x;
- uy.f = y;
- ex = ux.i.se & 0x7fff;
- ey = uy.i.se & 0x7fff;
- m = 2*(ux.i.se>>15) | uy.i.se>>15;
- if (y == 0) {
- switch(m) {
- case 0:
- case 1: return y; /* atan(+-0,+anything)=+-0 */
- case 2: return 2*pio2_hi; /* atan(+0,-anything) = pi */
- case 3: return -2*pio2_hi; /* atan(-0,-anything) =-pi */
- }
- }
- if (x == 0)
- return m&1 ? -pio2_hi : pio2_hi;
- if (ex == 0x7fff) {
- if (ey == 0x7fff) {
- switch(m) {
- case 0: return pio2_hi/2; /* atan(+INF,+INF) */
- case 1: return -pio2_hi/2; /* atan(-INF,+INF) */
- case 2: return 1.5*pio2_hi; /* atan(+INF,-INF) */
- case 3: return -1.5*pio2_hi; /* atan(-INF,-INF) */
- }
- } else {
- switch(m) {
- case 0: return 0.0; /* atan(+...,+INF) */
- case 1: return -0.0; /* atan(-...,+INF) */
- case 2: return 2*pio2_hi; /* atan(+...,-INF) */
- case 3: return -2*pio2_hi; /* atan(-...,-INF) */
- }
- }
- }
- if (ex+120 < ey || ey == 0x7fff)
- return m&1 ? -pio2_hi : pio2_hi;
- /* z = atan(|y/x|) without spurious underflow */
- if ((m&2) && ey+120 < ex) /* |y/x| < 0x1p-120, x<0 */
- z = 0.0;
- else
- z = atanl(fabsl(y/x));
- switch (m) {
- case 0: return z; /* atan(+,+) */
- case 1: return -z; /* atan(-,+) */
- case 2: return 2*pio2_hi-(z-2*pio2_lo); /* atan(+,-) */
- default: /* case 3 */
- return (z-2*pio2_lo)-2*pio2_hi; /* atan(-,-) */
- }
+ if (isnan(x) || isnan(y))
+ return x + y;
+ if (x == 1)
+ return atanl(y);
+ ux.f = x;
+ uy.f = y;
+ ex = ux.i.se & 0x7fff;
+ ey = uy.i.se & 0x7fff;
+ m = 2 * (ux.i.se >> 15) | uy.i.se >> 15;
+ if (y == 0) {
+ switch (m) {
+ case 0:
+ case 1:
+ return y; /* atan(+-0,+anything)=+-0 */
+ case 2:
+ return 2 * pio2_hi; /* atan(+0,-anything) = pi */
+ case 3:
+ return -2 * pio2_hi; /* atan(-0,-anything) =-pi */
+ }
+ }
+ if (x == 0)
+ return m & 1 ? -pio2_hi : pio2_hi;
+ if (ex == 0x7fff) {
+ if (ey == 0x7fff) {
+ switch (m) {
+ case 0:
+ return pio2_hi / 2; /* atan(+INF,+INF) */
+ case 1:
+ return -pio2_hi / 2; /* atan(-INF,+INF) */
+ case 2:
+ return 1.5 * pio2_hi; /* atan(+INF,-INF) */
+ case 3:
+ return -1.5 * pio2_hi; /* atan(-INF,-INF) */
+ }
+ } else {
+ switch (m) {
+ case 0:
+ return 0.0; /* atan(+...,+INF) */
+ case 1:
+ return -0.0; /* atan(-...,+INF) */
+ case 2:
+ return 2 * pio2_hi; /* atan(+...,-INF) */
+ case 3:
+ return -2 * pio2_hi; /* atan(-...,-INF) */
+ }
+ }
+ }
+ if (ex + 120 < ey || ey == 0x7fff)
+ return m & 1 ? -pio2_hi : pio2_hi;
+ /* z = atan(|y/x|) without spurious underflow */
+ if ((m & 2) && ey + 120 < ex) /* |y/x| < 0x1p-120, x<0 */
+ z = 0.0;
+ else
+ z = atanl(fabsl(y / x));
+ switch (m) {
+ case 0:
+ return z; /* atan(+,+) */
+ case 1:
+ return -z; /* atan(-,+) */
+ case 2:
+ return 2 * pio2_hi - (z - 2 * pio2_lo); /* atan(+,-) */
+ default: /* case 3 */
+ return (z - 2 * pio2_lo) - 2 * pio2_hi; /* atan(-,-) */
+ }
}
#endif
diff --git a/fusl/src/math/atanf.c b/fusl/src/math/atanf.c
index 178341b..a63fccc 100644
--- a/fusl/src/math/atanf.c
+++ b/fusl/src/math/atanf.c
@@ -13,82 +13,77 @@
* ====================================================
*/
-
#include "libm.h"
static const float atanhi[] = {
- 4.6364760399e-01, /* atan(0.5)hi 0x3eed6338 */
- 7.8539812565e-01, /* atan(1.0)hi 0x3f490fda */
- 9.8279368877e-01, /* atan(1.5)hi 0x3f7b985e */
- 1.5707962513e+00, /* atan(inf)hi 0x3fc90fda */
+ 4.6364760399e-01, /* atan(0.5)hi 0x3eed6338 */
+ 7.8539812565e-01, /* atan(1.0)hi 0x3f490fda */
+ 9.8279368877e-01, /* atan(1.5)hi 0x3f7b985e */
+ 1.5707962513e+00, /* atan(inf)hi 0x3fc90fda */
};
static const float atanlo[] = {
- 5.0121582440e-09, /* atan(0.5)lo 0x31ac3769 */
- 3.7748947079e-08, /* atan(1.0)lo 0x33222168 */
- 3.4473217170e-08, /* atan(1.5)lo 0x33140fb4 */
- 7.5497894159e-08, /* atan(inf)lo 0x33a22168 */
+ 5.0121582440e-09, /* atan(0.5)lo 0x31ac3769 */
+ 3.7748947079e-08, /* atan(1.0)lo 0x33222168 */
+ 3.4473217170e-08, /* atan(1.5)lo 0x33140fb4 */
+ 7.5497894159e-08, /* atan(inf)lo 0x33a22168 */
};
static const float aT[] = {
- 3.3333328366e-01,
- -1.9999158382e-01,
- 1.4253635705e-01,
- -1.0648017377e-01,
- 6.1687607318e-02,
+ 3.3333328366e-01, -1.9999158382e-01, 1.4253635705e-01,
+ -1.0648017377e-01, 6.1687607318e-02,
};
-float atanf(float x)
-{
- float_t w,s1,s2,z;
- uint32_t ix,sign;
- int id;
+float atanf(float x) {
+ float_t w, s1, s2, z;
+ uint32_t ix, sign;
+ int id;
- GET_FLOAT_WORD(ix, x);
- sign = ix>>31;
- ix &= 0x7fffffff;
- if (ix >= 0x4c800000) { /* if |x| >= 2**26 */
- if (isnan(x))
- return x;
- z = atanhi[3] + 0x1p-120f;
- return sign ? -z : z;
- }
- if (ix < 0x3ee00000) { /* |x| < 0.4375 */
- if (ix < 0x39800000) { /* |x| < 2**-12 */
- if (ix < 0x00800000)
- /* raise underflow for subnormal x */
- FORCE_EVAL(x*x);
- return x;
- }
- id = -1;
- } else {
- x = fabsf(x);
- if (ix < 0x3f980000) { /* |x| < 1.1875 */
- if (ix < 0x3f300000) { /* 7/16 <= |x| < 11/16 */
- id = 0;
- x = (2.0f*x - 1.0f)/(2.0f + x);
- } else { /* 11/16 <= |x| < 19/16 */
- id = 1;
- x = (x - 1.0f)/(x + 1.0f);
- }
- } else {
- if (ix < 0x401c0000) { /* |x| < 2.4375 */
- id = 2;
- x = (x - 1.5f)/(1.0f + 1.5f*x);
- } else { /* 2.4375 <= |x| < 2**26 */
- id = 3;
- x = -1.0f/x;
- }
- }
- }
- /* end of argument reduction */
- z = x*x;
- w = z*z;
- /* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */
- s1 = z*(aT[0]+w*(aT[2]+w*aT[4]));
- s2 = w*(aT[1]+w*aT[3]);
- if (id < 0)
- return x - x*(s1+s2);
- z = atanhi[id] - ((x*(s1+s2) - atanlo[id]) - x);
- return sign ? -z : z;
+ GET_FLOAT_WORD(ix, x);
+ sign = ix >> 31;
+ ix &= 0x7fffffff;
+ if (ix >= 0x4c800000) { /* if |x| >= 2**26 */
+ if (isnan(x))
+ return x;
+ z = atanhi[3] + 0x1p-120f;
+ return sign ? -z : z;
+ }
+ if (ix < 0x3ee00000) { /* |x| < 0.4375 */
+ if (ix < 0x39800000) { /* |x| < 2**-12 */
+ if (ix < 0x00800000)
+ /* raise underflow for subnormal x */
+ FORCE_EVAL(x * x);
+ return x;
+ }
+ id = -1;
+ } else {
+ x = fabsf(x);
+ if (ix < 0x3f980000) { /* |x| < 1.1875 */
+ if (ix < 0x3f300000) { /* 7/16 <= |x| < 11/16 */
+ id = 0;
+ x = (2.0f * x - 1.0f) / (2.0f + x);
+ } else { /* 11/16 <= |x| < 19/16 */
+ id = 1;
+ x = (x - 1.0f) / (x + 1.0f);
+ }
+ } else {
+ if (ix < 0x401c0000) { /* |x| < 2.4375 */
+ id = 2;
+ x = (x - 1.5f) / (1.0f + 1.5f * x);
+ } else { /* 2.4375 <= |x| < 2**26 */
+ id = 3;
+ x = -1.0f / x;
+ }
+ }
+ }
+ /* end of argument reduction */
+ z = x * x;
+ w = z * z;
+ /* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */
+ s1 = z * (aT[0] + w * (aT[2] + w * aT[4]));
+ s2 = w * (aT[1] + w * aT[3]);
+ if (id < 0)
+ return x - x * (s1 + s2);
+ z = atanhi[id] - ((x * (s1 + s2) - atanlo[id]) - x);
+ return sign ? -z : z;
}
diff --git a/fusl/src/math/atanh.c b/fusl/src/math/atanh.c
index 63a035d..291cf15 100644
--- a/fusl/src/math/atanh.c
+++ b/fusl/src/math/atanh.c
@@ -1,29 +1,31 @@
#include "libm.h"
/* atanh(x) = log((1+x)/(1-x))/2 = log1p(2x/(1-x))/2 ~= x + x^3/3 + o(x^5) */
-double atanh(double x)
-{
- union {double f; uint64_t i;} u = {.f = x};
- unsigned e = u.i >> 52 & 0x7ff;
- unsigned s = u.i >> 63;
- double_t y;
+double atanh(double x) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {.f = x};
+ unsigned e = u.i >> 52 & 0x7ff;
+ unsigned s = u.i >> 63;
+ double_t y;
- /* |x| */
- u.i &= (uint64_t)-1/2;
- y = u.f;
+ /* |x| */
+ u.i &= (uint64_t)-1 / 2;
+ y = u.f;
- if (e < 0x3ff - 1) {
- if (e < 0x3ff - 32) {
- /* handle underflow */
- if (e == 0)
- FORCE_EVAL((float)y);
- } else {
- /* |x| < 0.5, up to 1.7ulp error */
- y = 0.5*log1p(2*y + 2*y*y/(1-y));
- }
- } else {
- /* avoid overflow */
- y = 0.5*log1p(2*(y/(1-y)));
- }
- return s ? -y : y;
+ if (e < 0x3ff - 1) {
+ if (e < 0x3ff - 32) {
+ /* handle underflow */
+ if (e == 0)
+ FORCE_EVAL((float)y);
+ } else {
+ /* |x| < 0.5, up to 1.7ulp error */
+ y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));
+ }
+ } else {
+ /* avoid overflow */
+ y = 0.5 * log1p(2 * (y / (1 - y)));
+ }
+ return s ? -y : y;
}
diff --git a/fusl/src/math/atanhf.c b/fusl/src/math/atanhf.c
index 65f07c0..346be6b 100644
--- a/fusl/src/math/atanhf.c
+++ b/fusl/src/math/atanhf.c
@@ -1,28 +1,30 @@
#include "libm.h"
/* atanh(x) = log((1+x)/(1-x))/2 = log1p(2x/(1-x))/2 ~= x + x^3/3 + o(x^5) */
-float atanhf(float x)
-{
- union {float f; uint32_t i;} u = {.f = x};
- unsigned s = u.i >> 31;
- float_t y;
+float atanhf(float x) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {.f = x};
+ unsigned s = u.i >> 31;
+ float_t y;
- /* |x| */
- u.i &= 0x7fffffff;
- y = u.f;
+ /* |x| */
+ u.i &= 0x7fffffff;
+ y = u.f;
- if (u.i < 0x3f800000 - (1<<23)) {
- if (u.i < 0x3f800000 - (32<<23)) {
- /* handle underflow */
- if (u.i < (1<<23))
- FORCE_EVAL((float)(y*y));
- } else {
- /* |x| < 0.5, up to 1.7ulp error */
- y = 0.5f*log1pf(2*y + 2*y*y/(1-y));
- }
- } else {
- /* avoid overflow */
- y = 0.5f*log1pf(2*(y/(1-y)));
- }
- return s ? -y : y;
+ if (u.i < 0x3f800000 - (1 << 23)) {
+ if (u.i < 0x3f800000 - (32 << 23)) {
+ /* handle underflow */
+ if (u.i < (1 << 23))
+ FORCE_EVAL((float)(y * y));
+ } else {
+ /* |x| < 0.5, up to 1.7ulp error */
+ y = 0.5f * log1pf(2 * y + 2 * y * y / (1 - y));
+ }
+ } else {
+ /* avoid overflow */
+ y = 0.5f * log1pf(2 * (y / (1 - y)));
+ }
+ return s ? -y : y;
}
diff --git a/fusl/src/math/atanhl.c b/fusl/src/math/atanhl.c
index 87cd1cd..4c6db53 100644
--- a/fusl/src/math/atanhl.c
+++ b/fusl/src/math/atanhl.c
@@ -1,35 +1,33 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double atanhl(long double x)
-{
- return atanh(x);
+long double atanhl(long double x) {
+ return atanh(x);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
/* atanh(x) = log((1+x)/(1-x))/2 = log1p(2x/(1-x))/2 ~= x + x^3/3 + o(x^5) */
-long double atanhl(long double x)
-{
- union ldshape u = {x};
- unsigned e = u.i.se & 0x7fff;
- unsigned s = u.i.se >> 15;
+long double atanhl(long double x) {
+ union ldshape u = {x};
+ unsigned e = u.i.se & 0x7fff;
+ unsigned s = u.i.se >> 15;
- /* |x| */
- u.i.se = e;
- x = u.f;
+ /* |x| */
+ u.i.se = e;
+ x = u.f;
- if (e < 0x3ff - 1) {
- if (e < 0x3ff - LDBL_MANT_DIG/2) {
- /* handle underflow */
- if (e == 0)
- FORCE_EVAL((float)x);
- } else {
- /* |x| < 0.5, up to 1.7ulp error */
- x = 0.5*log1pl(2*x + 2*x*x/(1-x));
- }
- } else {
- /* avoid overflow */
- x = 0.5*log1pl(2*(x/(1-x)));
- }
- return s ? -x : x;
+ if (e < 0x3ff - 1) {
+ if (e < 0x3ff - LDBL_MANT_DIG / 2) {
+ /* handle underflow */
+ if (e == 0)
+ FORCE_EVAL((float)x);
+ } else {
+ /* |x| < 0.5, up to 1.7ulp error */
+ x = 0.5 * log1pl(2 * x + 2 * x * x / (1 - x));
+ }
+ } else {
+ /* avoid overflow */
+ x = 0.5 * log1pl(2 * (x / (1 - x)));
+ }
+ return s ? -x : x;
}
#endif
diff --git a/fusl/src/math/atanl.c b/fusl/src/math/atanl.c
index 79a3edb..cefd937 100644
--- a/fusl/src/math/atanl.c
+++ b/fusl/src/math/atanl.c
@@ -17,168 +17,175 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double atanl(long double x)
-{
- return atan(x);
+long double atanl(long double x) {
+ return atan(x);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
#if LDBL_MANT_DIG == 64
-#define EXPMAN(u) ((u.i.se & 0x7fff)<<8 | (u.i.m>>55 & 0xff))
+#define EXPMAN(u) ((u.i.se & 0x7fff) << 8 | (u.i.m >> 55 & 0xff))
static const long double atanhi[] = {
- 4.63647609000806116202e-01L,
- 7.85398163397448309628e-01L,
- 9.82793723247329067960e-01L,
- 1.57079632679489661926e+00L,
+ 4.63647609000806116202e-01L, 7.85398163397448309628e-01L,
+ 9.82793723247329067960e-01L, 1.57079632679489661926e+00L,
};
static const long double atanlo[] = {
- 1.18469937025062860669e-20L,
- -1.25413940316708300586e-20L,
- 2.55232234165405176172e-20L,
- -2.50827880633416601173e-20L,
+ 1.18469937025062860669e-20L, -1.25413940316708300586e-20L,
+ 2.55232234165405176172e-20L, -2.50827880633416601173e-20L,
};
static const long double aT[] = {
- 3.33333333333333333017e-01L,
- -1.99999999999999632011e-01L,
- 1.42857142857046531280e-01L,
- -1.11111111100562372733e-01L,
- 9.09090902935647302252e-02L,
- -7.69230552476207730353e-02L,
- 6.66661718042406260546e-02L,
- -5.88158892835030888692e-02L,
- 5.25499891539726639379e-02L,
- -4.70119845393155721494e-02L,
- 4.03539201366454414072e-02L,
- -2.91303858419364158725e-02L,
- 1.24822046299269234080e-02L,
+ 3.33333333333333333017e-01L, -1.99999999999999632011e-01L,
+ 1.42857142857046531280e-01L, -1.11111111100562372733e-01L,
+ 9.09090902935647302252e-02L, -7.69230552476207730353e-02L,
+ 6.66661718042406260546e-02L, -5.88158892835030888692e-02L,
+ 5.25499891539726639379e-02L, -4.70119845393155721494e-02L,
+ 4.03539201366454414072e-02L, -2.91303858419364158725e-02L,
+ 1.24822046299269234080e-02L,
};
-static long double T_even(long double x)
-{
- return aT[0] + x * (aT[2] + x * (aT[4] + x * (aT[6] +
- x * (aT[8] + x * (aT[10] + x * aT[12])))));
+static long double T_even(long double x) {
+ return aT[0] +
+ x * (aT[2] +
+ x * (aT[4] +
+ x * (aT[6] + x * (aT[8] + x * (aT[10] + x * aT[12])))));
}
-static long double T_odd(long double x)
-{
- return aT[1] + x * (aT[3] + x * (aT[5] + x * (aT[7] +
- x * (aT[9] + x * aT[11]))));
+static long double T_odd(long double x) {
+ return aT[1] +
+ x * (aT[3] + x * (aT[5] + x * (aT[7] + x * (aT[9] + x * aT[11]))));
}
#elif LDBL_MANT_DIG == 113
-#define EXPMAN(u) ((u.i.se & 0x7fff)<<8 | u.i.top>>8)
+#define EXPMAN(u) ((u.i.se & 0x7fff) << 8 | u.i.top >> 8)
const long double atanhi[] = {
- 4.63647609000806116214256231461214397e-01L,
- 7.85398163397448309615660845819875699e-01L,
- 9.82793723247329067985710611014666038e-01L,
- 1.57079632679489661923132169163975140e+00L,
+ 4.63647609000806116214256231461214397e-01L,
+ 7.85398163397448309615660845819875699e-01L,
+ 9.82793723247329067985710611014666038e-01L,
+ 1.57079632679489661923132169163975140e+00L,
};
const long double atanlo[] = {
- 4.89509642257333492668618435220297706e-36L,
- 2.16795253253094525619926100651083806e-35L,
- -2.31288434538183565909319952098066272e-35L,
- 4.33590506506189051239852201302167613e-35L,
+ 4.89509642257333492668618435220297706e-36L,
+ 2.16795253253094525619926100651083806e-35L,
+ -2.31288434538183565909319952098066272e-35L,
+ 4.33590506506189051239852201302167613e-35L,
};
const long double aT[] = {
- 3.33333333333333333333333333333333125e-01L,
- -1.99999999999999999999999999999180430e-01L,
- 1.42857142857142857142857142125269827e-01L,
- -1.11111111111111111111110834490810169e-01L,
- 9.09090909090909090908522355708623681e-02L,
- -7.69230769230769230696553844935357021e-02L,
- 6.66666666666666660390096773046256096e-02L,
- -5.88235294117646671706582985209643694e-02L,
- 5.26315789473666478515847092020327506e-02L,
- -4.76190476189855517021024424991436144e-02L,
- 4.34782608678695085948531993458097026e-02L,
- -3.99999999632663469330634215991142368e-02L,
- 3.70370363987423702891250829918659723e-02L,
- -3.44827496515048090726669907612335954e-02L,
- 3.22579620681420149871973710852268528e-02L,
- -3.03020767654269261041647570626778067e-02L,
- 2.85641979882534783223403715930946138e-02L,
- -2.69824879726738568189929461383741323e-02L,
- 2.54194698498808542954187110873675769e-02L,
- -2.35083879708189059926183138130183215e-02L,
- 2.04832358998165364349957325067131428e-02L,
- -1.54489555488544397858507248612362957e-02L,
- 8.64492360989278761493037861575248038e-03L,
- -2.58521121597609872727919154569765469e-03L,
+ 3.33333333333333333333333333333333125e-01L,
+ -1.99999999999999999999999999999180430e-01L,
+ 1.42857142857142857142857142125269827e-01L,
+ -1.11111111111111111111110834490810169e-01L,
+ 9.09090909090909090908522355708623681e-02L,
+ -7.69230769230769230696553844935357021e-02L,
+ 6.66666666666666660390096773046256096e-02L,
+ -5.88235294117646671706582985209643694e-02L,
+ 5.26315789473666478515847092020327506e-02L,
+ -4.76190476189855517021024424991436144e-02L,
+ 4.34782608678695085948531993458097026e-02L,
+ -3.99999999632663469330634215991142368e-02L,
+ 3.70370363987423702891250829918659723e-02L,
+ -3.44827496515048090726669907612335954e-02L,
+ 3.22579620681420149871973710852268528e-02L,
+ -3.03020767654269261041647570626778067e-02L,
+ 2.85641979882534783223403715930946138e-02L,
+ -2.69824879726738568189929461383741323e-02L,
+ 2.54194698498808542954187110873675769e-02L,
+ -2.35083879708189059926183138130183215e-02L,
+ 2.04832358998165364349957325067131428e-02L,
+ -1.54489555488544397858507248612362957e-02L,
+ 8.64492360989278761493037861575248038e-03L,
+ -2.58521121597609872727919154569765469e-03L,
};
-static long double T_even(long double x)
-{
- return (aT[0] + x * (aT[2] + x * (aT[4] + x * (aT[6] + x * (aT[8] +
- x * (aT[10] + x * (aT[12] + x * (aT[14] + x * (aT[16] +
- x * (aT[18] + x * (aT[20] + x * aT[22])))))))))));
+static long double T_even(long double x) {
+ return (
+ aT[0] +
+ x * (aT[2] +
+ x * (aT[4] +
+ x * (aT[6] +
+ x * (aT[8] +
+ x * (aT[10] +
+ x * (aT[12] +
+ x * (aT[14] +
+ x * (aT[16] +
+ x * (aT[18] +
+ x * (aT[20] +
+ x * aT[22])))))))))));
}
-static long double T_odd(long double x)
-{
- return (aT[1] + x * (aT[3] + x * (aT[5] + x * (aT[7] + x * (aT[9] +
- x * (aT[11] + x * (aT[13] + x * (aT[15] + x * (aT[17] +
- x * (aT[19] + x * (aT[21] + x * aT[23])))))))))));
+static long double T_odd(long double x) {
+ return (
+ aT[1] +
+ x * (aT[3] +
+ x * (aT[5] +
+ x * (aT[7] +
+ x * (aT[9] +
+ x * (aT[11] +
+ x * (aT[13] +
+ x * (aT[15] +
+ x * (aT[17] +
+ x * (aT[19] +
+ x * (aT[21] +
+ x * aT[23])))))))))));
}
#endif
-long double atanl(long double x)
-{
- union ldshape u = {x};
- long double w, s1, s2, z;
- int id;
- unsigned e = u.i.se & 0x7fff;
- unsigned sign = u.i.se >> 15;
- unsigned expman;
+long double atanl(long double x) {
+ union ldshape u = {x};
+ long double w, s1, s2, z;
+ int id;
+ unsigned e = u.i.se & 0x7fff;
+ unsigned sign = u.i.se >> 15;
+ unsigned expman;
- if (e >= 0x3fff + LDBL_MANT_DIG + 1) { /* if |x| is large, atan(x)~=pi/2 */
- if (isnan(x))
- return x;
- return sign ? -atanhi[3] : atanhi[3];
- }
- /* Extract the exponent and the first few bits of the mantissa. */
- expman = EXPMAN(u);
- if (expman < ((0x3fff - 2) << 8) + 0xc0) { /* |x| < 0.4375 */
- if (e < 0x3fff - (LDBL_MANT_DIG+1)/2) { /* if |x| is small, atanl(x)~=x */
- /* raise underflow if subnormal */
- if (e == 0)
- FORCE_EVAL((float)x);
- return x;
- }
- id = -1;
- } else {
- x = fabsl(x);
- if (expman < (0x3fff << 8) + 0x30) { /* |x| < 1.1875 */
- if (expman < ((0x3fff - 1) << 8) + 0x60) { /* 7/16 <= |x| < 11/16 */
- id = 0;
- x = (2.0*x-1.0)/(2.0+x);
- } else { /* 11/16 <= |x| < 19/16 */
- id = 1;
- x = (x-1.0)/(x+1.0);
- }
- } else {
- if (expman < ((0x3fff + 1) << 8) + 0x38) { /* |x| < 2.4375 */
- id = 2;
- x = (x-1.5)/(1.0+1.5*x);
- } else { /* 2.4375 <= |x| */
- id = 3;
- x = -1.0/x;
- }
- }
- }
- /* end of argument reduction */
- z = x*x;
- w = z*z;
- /* break sum aT[i]z**(i+1) into odd and even poly */
- s1 = z*T_even(w);
- s2 = w*T_odd(w);
- if (id < 0)
- return x - x*(s1+s2);
- z = atanhi[id] - ((x*(s1+s2) - atanlo[id]) - x);
- return sign ? -z : z;
+ if (e >= 0x3fff + LDBL_MANT_DIG + 1) { /* if |x| is large, atan(x)~=pi/2 */
+ if (isnan(x))
+ return x;
+ return sign ? -atanhi[3] : atanhi[3];
+ }
+ /* Extract the exponent and the first few bits of the mantissa. */
+ expman = EXPMAN(u);
+ if (expman < ((0x3fff - 2) << 8) + 0xc0) { /* |x| < 0.4375 */
+ if (e <
+ 0x3fff - (LDBL_MANT_DIG + 1) / 2) { /* if |x| is small, atanl(x)~=x */
+ /* raise underflow if subnormal */
+ if (e == 0)
+ FORCE_EVAL((float)x);
+ return x;
+ }
+ id = -1;
+ } else {
+ x = fabsl(x);
+ if (expman < (0x3fff << 8) + 0x30) { /* |x| < 1.1875 */
+ if (expman < ((0x3fff - 1) << 8) + 0x60) { /* 7/16 <= |x| < 11/16 */
+ id = 0;
+ x = (2.0 * x - 1.0) / (2.0 + x);
+ } else { /* 11/16 <= |x| < 19/16 */
+ id = 1;
+ x = (x - 1.0) / (x + 1.0);
+ }
+ } else {
+ if (expman < ((0x3fff + 1) << 8) + 0x38) { /* |x| < 2.4375 */
+ id = 2;
+ x = (x - 1.5) / (1.0 + 1.5 * x);
+ } else { /* 2.4375 <= |x| */
+ id = 3;
+ x = -1.0 / x;
+ }
+ }
+ }
+ /* end of argument reduction */
+ z = x * x;
+ w = z * z;
+ /* break sum aT[i]z**(i+1) into odd and even poly */
+ s1 = z * T_even(w);
+ s2 = w * T_odd(w);
+ if (id < 0)
+ return x - x * (s1 + s2);
+ z = atanhi[id] - ((x * (s1 + s2) - atanlo[id]) - x);
+ return sign ? -z : z;
}
#endif
diff --git a/fusl/src/math/cbrt.c b/fusl/src/math/cbrt.c
index 7599d3e..d6879df 100644
--- a/fusl/src/math/cbrt.c
+++ b/fusl/src/math/cbrt.c
@@ -19,85 +19,86 @@
#include <stdint.h>
static const uint32_t
-B1 = 715094163, /* B1 = (1023-1023/3-0.03306235651)*2**20 */
-B2 = 696219795; /* B2 = (1023-1023/3-54/3-0.03306235651)*2**20 */
+ B1 = 715094163, /* B1 = (1023-1023/3-0.03306235651)*2**20 */
+ B2 = 696219795; /* B2 = (1023-1023/3-54/3-0.03306235651)*2**20 */
/* |1/cbrt(x) - p(x)| < 2**-23.5 (~[-7.93e-8, 7.929e-8]). */
-static const double
-P0 = 1.87595182427177009643, /* 0x3ffe03e6, 0x0f61e692 */
-P1 = -1.88497979543377169875, /* 0xbffe28e0, 0x92f02420 */
-P2 = 1.621429720105354466140, /* 0x3ff9f160, 0x4a49d6c2 */
-P3 = -0.758397934778766047437, /* 0xbfe844cb, 0xbee751d9 */
-P4 = 0.145996192886612446982; /* 0x3fc2b000, 0xd4e4edd7 */
+static const double P0 = 1.87595182427177009643, /* 0x3ffe03e6, 0x0f61e692 */
+ P1 = -1.88497979543377169875, /* 0xbffe28e0, 0x92f02420 */
+ P2 = 1.621429720105354466140, /* 0x3ff9f160, 0x4a49d6c2 */
+ P3 = -0.758397934778766047437, /* 0xbfe844cb, 0xbee751d9 */
+ P4 = 0.145996192886612446982; /* 0x3fc2b000, 0xd4e4edd7 */
-double cbrt(double x)
-{
- union {double f; uint64_t i;} u = {x};
- double_t r,s,t,w;
- uint32_t hx = u.i>>32 & 0x7fffffff;
+double cbrt(double x) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {x};
+ double_t r, s, t, w;
+ uint32_t hx = u.i >> 32 & 0x7fffffff;
- if (hx >= 0x7ff00000) /* cbrt(NaN,INF) is itself */
- return x+x;
+ if (hx >= 0x7ff00000) /* cbrt(NaN,INF) is itself */
+ return x + x;
- /*
- * Rough cbrt to 5 bits:
- * cbrt(2**e*(1+m) ~= 2**(e/3)*(1+(e%3+m)/3)
- * where e is integral and >= 0, m is real and in [0, 1), and "/" and
- * "%" are integer division and modulus with rounding towards minus
- * infinity. The RHS is always >= the LHS and has a maximum relative
- * error of about 1 in 16. Adding a bias of -0.03306235651 to the
- * (e%3+m)/3 term reduces the error to about 1 in 32. With the IEEE
- * floating point representation, for finite positive normal values,
- * ordinary integer divison of the value in bits magically gives
- * almost exactly the RHS of the above provided we first subtract the
- * exponent bias (1023 for doubles) and later add it back. We do the
- * subtraction virtually to keep e >= 0 so that ordinary integer
- * division rounds towards minus infinity; this is also efficient.
- */
- if (hx < 0x00100000) { /* zero or subnormal? */
- u.f = x*0x1p54;
- hx = u.i>>32 & 0x7fffffff;
- if (hx == 0)
- return x; /* cbrt(0) is itself */
- hx = hx/3 + B2;
- } else
- hx = hx/3 + B1;
- u.i &= 1ULL<<63;
- u.i |= (uint64_t)hx << 32;
- t = u.f;
+ /*
+ * Rough cbrt to 5 bits:
+ * cbrt(2**e*(1+m) ~= 2**(e/3)*(1+(e%3+m)/3)
+ * where e is integral and >= 0, m is real and in [0, 1), and "/" and
+ * "%" are integer division and modulus with rounding towards minus
+ * infinity. The RHS is always >= the LHS and has a maximum relative
+ * error of about 1 in 16. Adding a bias of -0.03306235651 to the
+ * (e%3+m)/3 term reduces the error to about 1 in 32. With the IEEE
+ * floating point representation, for finite positive normal values,
+ * ordinary integer divison of the value in bits magically gives
+ * almost exactly the RHS of the above provided we first subtract the
+ * exponent bias (1023 for doubles) and later add it back. We do the
+ * subtraction virtually to keep e >= 0 so that ordinary integer
+ * division rounds towards minus infinity; this is also efficient.
+ */
+ if (hx < 0x00100000) { /* zero or subnormal? */
+ u.f = x * 0x1p54;
+ hx = u.i >> 32 & 0x7fffffff;
+ if (hx == 0)
+ return x; /* cbrt(0) is itself */
+ hx = hx / 3 + B2;
+ } else
+ hx = hx / 3 + B1;
+ u.i &= 1ULL << 63;
+ u.i |= (uint64_t)hx << 32;
+ t = u.f;
- /*
- * New cbrt to 23 bits:
- * cbrt(x) = t*cbrt(x/t**3) ~= t*P(t**3/x)
- * where P(r) is a polynomial of degree 4 that approximates 1/cbrt(r)
- * to within 2**-23.5 when |r - 1| < 1/10. The rough approximation
- * has produced t such than |t/cbrt(x) - 1| ~< 1/32, and cubing this
- * gives us bounds for r = t**3/x.
- *
- * Try to optimize for parallel evaluation as in __tanf.c.
- */
- r = (t*t)*(t/x);
- t = t*((P0+r*(P1+r*P2))+((r*r)*r)*(P3+r*P4));
+ /*
+ * New cbrt to 23 bits:
+ * cbrt(x) = t*cbrt(x/t**3) ~= t*P(t**3/x)
+ * where P(r) is a polynomial of degree 4 that approximates 1/cbrt(r)
+ * to within 2**-23.5 when |r - 1| < 1/10. The rough approximation
+ * has produced t such than |t/cbrt(x) - 1| ~< 1/32, and cubing this
+ * gives us bounds for r = t**3/x.
+ *
+ * Try to optimize for parallel evaluation as in __tanf.c.
+ */
+ r = (t * t) * (t / x);
+ t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));
- /*
- * Round t away from zero to 23 bits (sloppily except for ensuring that
- * the result is larger in magnitude than cbrt(x) but not much more than
- * 2 23-bit ulps larger). With rounding towards zero, the error bound
- * would be ~5/6 instead of ~4/6. With a maximum error of 2 23-bit ulps
- * in the rounded t, the infinite-precision error in the Newton
- * approximation barely affects third digit in the final error
- * 0.667; the error in the rounded t can be up to about 3 23-bit ulps
- * before the final error is larger than 0.667 ulps.
- */
- u.f = t;
- u.i = (u.i + 0x80000000) & 0xffffffffc0000000ULL;
- t = u.f;
+ /*
+ * Round t away from zero to 23 bits (sloppily except for ensuring that
+ * the result is larger in magnitude than cbrt(x) but not much more than
+ * 2 23-bit ulps larger). With rounding towards zero, the error bound
+ * would be ~5/6 instead of ~4/6. With a maximum error of 2 23-bit ulps
+ * in the rounded t, the infinite-precision error in the Newton
+ * approximation barely affects third digit in the final error
+ * 0.667; the error in the rounded t can be up to about 3 23-bit ulps
+ * before the final error is larger than 0.667 ulps.
+ */
+ u.f = t;
+ u.i = (u.i + 0x80000000) & 0xffffffffc0000000ULL;
+ t = u.f;
- /* one step Newton iteration to 53 bits with error < 0.667 ulps */
- s = t*t; /* t*t is exact */
- r = x/s; /* error <= 0.5 ulps; |r| < |t| */
- w = t+t; /* t+t is exact */
- r = (r-t)/(w+r); /* r-t is exact; w+r ~= 3*t */
- t = t+t*r; /* error <= 0.5 + 0.5/3 + epsilon */
- return t;
+ /* one step Newton iteration to 53 bits with error < 0.667 ulps */
+ s = t * t; /* t*t is exact */
+ r = x / s; /* error <= 0.5 ulps; |r| < |t| */
+ w = t + t; /* t+t is exact */
+ r = (r - t) / (w + r); /* r-t is exact; w+r ~= 3*t */
+ t = t + t * r; /* error <= 0.5 + 0.5/3 + epsilon */
+ return t;
}
diff --git a/fusl/src/math/cbrtf.c b/fusl/src/math/cbrtf.c
index 89c2c86..f86b1b5 100644
--- a/fusl/src/math/cbrtf.c
+++ b/fusl/src/math/cbrtf.c
@@ -21,46 +21,48 @@
#include <stdint.h>
static const unsigned
-B1 = 709958130, /* B1 = (127-127.0/3-0.03306235651)*2**23 */
-B2 = 642849266; /* B2 = (127-127.0/3-24/3-0.03306235651)*2**23 */
+ B1 = 709958130, /* B1 = (127-127.0/3-0.03306235651)*2**23 */
+ B2 = 642849266; /* B2 = (127-127.0/3-24/3-0.03306235651)*2**23 */
-float cbrtf(float x)
-{
- double_t r,T;
- union {float f; uint32_t i;} u = {x};
- uint32_t hx = u.i & 0x7fffffff;
+float cbrtf(float x) {
+ double_t r, T;
+ union {
+ float f;
+ uint32_t i;
+ } u = {x};
+ uint32_t hx = u.i & 0x7fffffff;
- if (hx >= 0x7f800000) /* cbrt(NaN,INF) is itself */
- return x + x;
+ if (hx >= 0x7f800000) /* cbrt(NaN,INF) is itself */
+ return x + x;
- /* rough cbrt to 5 bits */
- if (hx < 0x00800000) { /* zero or subnormal? */
- if (hx == 0)
- return x; /* cbrt(+-0) is itself */
- u.f = x*0x1p24f;
- hx = u.i & 0x7fffffff;
- hx = hx/3 + B2;
- } else
- hx = hx/3 + B1;
- u.i &= 0x80000000;
- u.i |= hx;
+ /* rough cbrt to 5 bits */
+ if (hx < 0x00800000) { /* zero or subnormal? */
+ if (hx == 0)
+ return x; /* cbrt(+-0) is itself */
+ u.f = x * 0x1p24f;
+ hx = u.i & 0x7fffffff;
+ hx = hx / 3 + B2;
+ } else
+ hx = hx / 3 + B1;
+ u.i &= 0x80000000;
+ u.i |= hx;
- /*
- * First step Newton iteration (solving t*t-x/t == 0) to 16 bits. In
- * double precision so that its terms can be arranged for efficiency
- * without causing overflow or underflow.
- */
- T = u.f;
- r = T*T*T;
- T = T*((double_t)x+x+r)/(x+r+r);
+ /*
+ * First step Newton iteration (solving t*t-x/t == 0) to 16 bits. In
+ * double precision so that its terms can be arranged for efficiency
+ * without causing overflow or underflow.
+ */
+ T = u.f;
+ r = T * T * T;
+ T = T * ((double_t)x + x + r) / (x + r + r);
- /*
- * Second step Newton iteration to 47 bits. In double precision for
- * efficiency and accuracy.
- */
- r = T*T*T;
- T = T*((double_t)x+x+r)/(x+r+r);
+ /*
+ * Second step Newton iteration to 47 bits. In double precision for
+ * efficiency and accuracy.
+ */
+ r = T * T * T;
+ T = T * ((double_t)x + x + r) / (x + r + r);
- /* rounding to 24 bits is perfect in round-to-nearest mode */
- return T;
+ /* rounding to 24 bits is perfect in round-to-nearest mode */
+ return T;
}
diff --git a/fusl/src/math/cbrtl.c b/fusl/src/math/cbrtl.c
index ceff913..525f4ed 100644
--- a/fusl/src/math/cbrtl.c
+++ b/fusl/src/math/cbrtl.c
@@ -18,107 +18,109 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double cbrtl(long double x)
-{
- return cbrt(x);
+long double cbrtl(long double x) {
+ return cbrt(x);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-static const unsigned B1 = 709958130; /* B1 = (127-127.0/3-0.03306235651)*2**23 */
+static const unsigned B1 =
+ 709958130; /* B1 = (127-127.0/3-0.03306235651)*2**23 */
-long double cbrtl(long double x)
-{
- union ldshape u = {x}, v;
- union {float f; uint32_t i;} uft;
- long double r, s, t, w;
- double_t dr, dt, dx;
- float_t ft;
- int e = u.i.se & 0x7fff;
- int sign = u.i.se & 0x8000;
+long double cbrtl(long double x) {
+ union ldshape u = {x}, v;
+ union {
+ float f;
+ uint32_t i;
+ } uft;
+ long double r, s, t, w;
+ double_t dr, dt, dx;
+ float_t ft;
+ int e = u.i.se & 0x7fff;
+ int sign = u.i.se & 0x8000;
- /*
- * If x = +-Inf, then cbrt(x) = +-Inf.
- * If x = NaN, then cbrt(x) = NaN.
- */
- if (e == 0x7fff)
- return x + x;
- if (e == 0) {
- /* Adjust subnormal numbers. */
- u.f *= 0x1p120;
- e = u.i.se & 0x7fff;
- /* If x = +-0, then cbrt(x) = +-0. */
- if (e == 0)
- return x;
- e -= 120;
- }
- e -= 0x3fff;
- u.i.se = 0x3fff;
- x = u.f;
- switch (e % 3) {
- case 1:
- case -2:
- x *= 2;
- e--;
- break;
- case 2:
- case -1:
- x *= 4;
- e -= 2;
- break;
- }
- v.f = 1.0;
- v.i.se = sign | (0x3fff + e/3);
+ /*
+ * If x = +-Inf, then cbrt(x) = +-Inf.
+ * If x = NaN, then cbrt(x) = NaN.
+ */
+ if (e == 0x7fff)
+ return x + x;
+ if (e == 0) {
+ /* Adjust subnormal numbers. */
+ u.f *= 0x1p120;
+ e = u.i.se & 0x7fff;
+ /* If x = +-0, then cbrt(x) = +-0. */
+ if (e == 0)
+ return x;
+ e -= 120;
+ }
+ e -= 0x3fff;
+ u.i.se = 0x3fff;
+ x = u.f;
+ switch (e % 3) {
+ case 1:
+ case -2:
+ x *= 2;
+ e--;
+ break;
+ case 2:
+ case -1:
+ x *= 4;
+ e -= 2;
+ break;
+ }
+ v.f = 1.0;
+ v.i.se = sign | (0x3fff + e / 3);
- /*
- * The following is the guts of s_cbrtf, with the handling of
- * special values removed and extra care for accuracy not taken,
- * but with most of the extra accuracy not discarded.
- */
+ /*
+ * The following is the guts of s_cbrtf, with the handling of
+ * special values removed and extra care for accuracy not taken,
+ * but with most of the extra accuracy not discarded.
+ */
- /* ~5-bit estimate: */
- uft.f = x;
- uft.i = (uft.i & 0x7fffffff)/3 + B1;
- ft = uft.f;
+ /* ~5-bit estimate: */
+ uft.f = x;
+ uft.i = (uft.i & 0x7fffffff) / 3 + B1;
+ ft = uft.f;
- /* ~16-bit estimate: */
- dx = x;
- dt = ft;
- dr = dt * dt * dt;
- dt = dt * (dx + dx + dr) / (dx + dr + dr);
+ /* ~16-bit estimate: */
+ dx = x;
+ dt = ft;
+ dr = dt * dt * dt;
+ dt = dt * (dx + dx + dr) / (dx + dr + dr);
- /* ~47-bit estimate: */
- dr = dt * dt * dt;
- dt = dt * (dx + dx + dr) / (dx + dr + dr);
+ /* ~47-bit estimate: */
+ dr = dt * dt * dt;
+ dt = dt * (dx + dx + dr) / (dx + dr + dr);
#if LDBL_MANT_DIG == 64
- /*
- * dt is cbrtl(x) to ~47 bits (after x has been reduced to 1 <= x < 8).
- * Round it away from zero to 32 bits (32 so that t*t is exact, and
- * away from zero for technical reasons).
- */
- t = dt + (0x1.0p32L + 0x1.0p-31L) - 0x1.0p32;
+ /*
+ * dt is cbrtl(x) to ~47 bits (after x has been reduced to 1 <= x < 8).
+ * Round it away from zero to 32 bits (32 so that t*t is exact, and
+ * away from zero for technical reasons).
+ */
+ t = dt + (0x1.0p32L + 0x1.0p-31L) - 0x1.0p32;
#elif LDBL_MANT_DIG == 113
- /*
- * Round dt away from zero to 47 bits. Since we don't trust the 47,
- * add 2 47-bit ulps instead of 1 to round up. Rounding is slow and
- * might be avoidable in this case, since on most machines dt will
- * have been evaluated in 53-bit precision and the technical reasons
- * for rounding up might not apply to either case in cbrtl() since
- * dt is much more accurate than needed.
- */
- t = dt + 0x2.0p-46 + 0x1.0p60L - 0x1.0p60;
+ /*
+ * Round dt away from zero to 47 bits. Since we don't trust the 47,
+ * add 2 47-bit ulps instead of 1 to round up. Rounding is slow and
+ * might be avoidable in this case, since on most machines dt will
+ * have been evaluated in 53-bit precision and the technical reasons
+ * for rounding up might not apply to either case in cbrtl() since
+ * dt is much more accurate than needed.
+ */
+ t = dt + 0x2.0p-46 + 0x1.0p60L - 0x1.0p60;
#endif
- /*
- * Final step Newton iteration to 64 or 113 bits with
- * error < 0.667 ulps
- */
- s = t*t; /* t*t is exact */
- r = x/s; /* error <= 0.5 ulps; |r| < |t| */
- w = t+t; /* t+t is exact */
- r = (r-t)/(w+r); /* r-t is exact; w+r ~= 3*t */
- t = t+t*r; /* error <= 0.5 + 0.5/3 + epsilon */
+ /*
+ * Final step Newton iteration to 64 or 113 bits with
+ * error < 0.667 ulps
+ */
+ s = t * t; /* t*t is exact */
+ r = x / s; /* error <= 0.5 ulps; |r| < |t| */
+ w = t + t; /* t+t is exact */
+ r = (r - t) / (w + r); /* r-t is exact; w+r ~= 3*t */
+ t = t + t * r; /* error <= 0.5 + 0.5/3 + epsilon */
- t *= v.f;
- return t;
+ t *= v.f;
+ return t;
}
#endif
diff --git a/fusl/src/math/ceil.c b/fusl/src/math/ceil.c
index b13e6f2..4c6ca5e 100644
--- a/fusl/src/math/ceil.c
+++ b/fusl/src/math/ceil.c
@@ -1,31 +1,33 @@
#include "libm.h"
-#if FLT_EVAL_METHOD==0 || FLT_EVAL_METHOD==1
+#if FLT_EVAL_METHOD == 0 || FLT_EVAL_METHOD == 1
#define EPS DBL_EPSILON
-#elif FLT_EVAL_METHOD==2
+#elif FLT_EVAL_METHOD == 2
#define EPS LDBL_EPSILON
#endif
-static const double_t toint = 1/EPS;
+static const double_t toint = 1 / EPS;
-double ceil(double x)
-{
- union {double f; uint64_t i;} u = {x};
- int e = u.i >> 52 & 0x7ff;
- double_t y;
+double ceil(double x) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {x};
+ int e = u.i >> 52 & 0x7ff;
+ double_t y;
- if (e >= 0x3ff+52 || x == 0)
- return x;
- /* y = int(x) - x, where int(x) is an integer neighbor of x */
- if (u.i >> 63)
- y = x - toint + toint - x;
- else
- y = x + toint - toint - x;
- /* special case because of non-nearest rounding modes */
- if (e <= 0x3ff-1) {
- FORCE_EVAL(y);
- return u.i >> 63 ? -0.0 : 1;
- }
- if (y < 0)
- return x + y + 1;
- return x + y;
+ if (e >= 0x3ff + 52 || x == 0)
+ return x;
+ /* y = int(x) - x, where int(x) is an integer neighbor of x */
+ if (u.i >> 63)
+ y = x - toint + toint - x;
+ else
+ y = x + toint - toint - x;
+ /* special case because of non-nearest rounding modes */
+ if (e <= 0x3ff - 1) {
+ FORCE_EVAL(y);
+ return u.i >> 63 ? -0.0 : 1;
+ }
+ if (y < 0)
+ return x + y + 1;
+ return x + y;
}
diff --git a/fusl/src/math/ceilf.c b/fusl/src/math/ceilf.c
index 869835f..813d614 100644
--- a/fusl/src/math/ceilf.c
+++ b/fusl/src/math/ceilf.c
@@ -1,27 +1,29 @@
#include "libm.h"
-float ceilf(float x)
-{
- union {float f; uint32_t i;} u = {x};
- int e = (int)(u.i >> 23 & 0xff) - 0x7f;
- uint32_t m;
+float ceilf(float x) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {x};
+ int e = (int)(u.i >> 23 & 0xff) - 0x7f;
+ uint32_t m;
- if (e >= 23)
- return x;
- if (e >= 0) {
- m = 0x007fffff >> e;
- if ((u.i & m) == 0)
- return x;
- FORCE_EVAL(x + 0x1p120f);
- if (u.i >> 31 == 0)
- u.i += m;
- u.i &= ~m;
- } else {
- FORCE_EVAL(x + 0x1p120f);
- if (u.i >> 31)
- u.f = -0.0;
- else if (u.i << 1)
- u.f = 1.0;
- }
- return u.f;
+ if (e >= 23)
+ return x;
+ if (e >= 0) {
+ m = 0x007fffff >> e;
+ if ((u.i & m) == 0)
+ return x;
+ FORCE_EVAL(x + 0x1p120f);
+ if (u.i >> 31 == 0)
+ u.i += m;
+ u.i &= ~m;
+ } else {
+ FORCE_EVAL(x + 0x1p120f);
+ if (u.i >> 31)
+ u.f = -0.0;
+ else if (u.i << 1)
+ u.f = 1.0;
+ }
+ return u.f;
}
diff --git a/fusl/src/math/ceill.c b/fusl/src/math/ceill.c
index 60a8302..7cc8c73 100644
--- a/fusl/src/math/ceill.c
+++ b/fusl/src/math/ceill.c
@@ -1,34 +1,32 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double ceill(long double x)
-{
- return ceil(x);
+long double ceill(long double x) {
+ return ceil(x);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-static const long double toint = 1/LDBL_EPSILON;
+static const long double toint = 1 / LDBL_EPSILON;
-long double ceill(long double x)
-{
- union ldshape u = {x};
- int e = u.i.se & 0x7fff;
- long double y;
+long double ceill(long double x) {
+ union ldshape u = {x};
+ int e = u.i.se & 0x7fff;
+ long double y;
- 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 ? -0.0 : 1;
- }
- if (y < 0)
- return x + y + 1;
- return x + y;
+ 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 ? -0.0 : 1;
+ }
+ if (y < 0)
+ return x + y + 1;
+ return x + y;
}
#endif
diff --git a/fusl/src/math/copysign.c b/fusl/src/math/copysign.c
index b09331b..226d499 100644
--- a/fusl/src/math/copysign.c
+++ b/fusl/src/math/copysign.c
@@ -1,8 +1,11 @@
#include "libm.h"
double copysign(double x, double y) {
- union {double f; uint64_t i;} ux={x}, uy={y};
- ux.i &= -1ULL/2;
- ux.i |= uy.i & 1ULL<<63;
- return ux.f;
+ union {
+ double f;
+ uint64_t i;
+ } ux = {x}, uy = {y};
+ ux.i &= -1ULL / 2;
+ ux.i |= uy.i & 1ULL << 63;
+ return ux.f;
}
diff --git a/fusl/src/math/copysignf.c b/fusl/src/math/copysignf.c
index 0af6ae9..32626d5 100644
--- a/fusl/src/math/copysignf.c
+++ b/fusl/src/math/copysignf.c
@@ -1,10 +1,12 @@
#include <math.h>
#include <stdint.h>
-float copysignf(float x, float y)
-{
- union {float f; uint32_t i;} ux={x}, uy={y};
- ux.i &= 0x7fffffff;
- ux.i |= uy.i & 0x80000000;
- return ux.f;
+float copysignf(float x, float y) {
+ union {
+ float f;
+ uint32_t i;
+ } ux = {x}, uy = {y};
+ ux.i &= 0x7fffffff;
+ ux.i |= uy.i & 0x80000000;
+ return ux.f;
}
diff --git a/fusl/src/math/copysignl.c b/fusl/src/math/copysignl.c
index 9dd933c..e006650 100644
--- a/fusl/src/math/copysignl.c
+++ b/fusl/src/math/copysignl.c
@@ -1,16 +1,14 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double copysignl(long double x, long double y)
-{
- return copysign(x, y);
+long double copysignl(long double x, long double y) {
+ return copysign(x, y);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-long double copysignl(long double x, long double y)
-{
- union ldshape ux = {x}, uy = {y};
- ux.i.se &= 0x7fff;
- ux.i.se |= uy.i.se & 0x8000;
- return ux.f;
+long double copysignl(long double x, long double y) {
+ union ldshape ux = {x}, uy = {y};
+ ux.i.se &= 0x7fff;
+ ux.i.se |= uy.i.se & 0x8000;
+ return ux.f;
}
#endif
diff --git a/fusl/src/math/cos.c b/fusl/src/math/cos.c
index ee97f68..fa5989e 100644
--- a/fusl/src/math/cos.c
+++ b/fusl/src/math/cos.c
@@ -42,36 +42,38 @@
#include "libm.h"
-double cos(double x)
-{
- double y[2];
- uint32_t ix;
- unsigned n;
+double cos(double x) {
+ double y[2];
+ uint32_t ix;
+ unsigned n;
- GET_HIGH_WORD(ix, x);
- ix &= 0x7fffffff;
+ GET_HIGH_WORD(ix, x);
+ ix &= 0x7fffffff;
- /* |x| ~< pi/4 */
- if (ix <= 0x3fe921fb) {
- if (ix < 0x3e46a09e) { /* |x| < 2**-27 * sqrt(2) */
- /* raise inexact if x!=0 */
- FORCE_EVAL(x + 0x1p120f);
- return 1.0;
- }
- return __cos(x, 0);
- }
+ /* |x| ~< pi/4 */
+ if (ix <= 0x3fe921fb) {
+ if (ix < 0x3e46a09e) { /* |x| < 2**-27 * sqrt(2) */
+ /* raise inexact if x!=0 */
+ FORCE_EVAL(x + 0x1p120f);
+ return 1.0;
+ }
+ return __cos(x, 0);
+ }
- /* cos(Inf or NaN) is NaN */
- if (ix >= 0x7ff00000)
- return x-x;
+ /* cos(Inf or NaN) is NaN */
+ if (ix >= 0x7ff00000)
+ return x - x;
- /* argument reduction */
- n = __rem_pio2(x, y);
- switch (n&3) {
- case 0: return __cos(y[0], y[1]);
- case 1: return -__sin(y[0], y[1], 1);
- case 2: return -__cos(y[0], y[1]);
- default:
- return __sin(y[0], y[1], 1);
- }
+ /* argument reduction */
+ n = __rem_pio2(x, y);
+ switch (n & 3) {
+ case 0:
+ return __cos(y[0], y[1]);
+ case 1:
+ return -__sin(y[0], y[1], 1);
+ case 2:
+ return -__cos(y[0], y[1]);
+ default:
+ return __sin(y[0], y[1], 1);
+ }
}
diff --git a/fusl/src/math/cosf.c b/fusl/src/math/cosf.c
index 23f3e5b..d47fe88 100644
--- a/fusl/src/math/cosf.c
+++ b/fusl/src/math/cosf.c
@@ -17,62 +17,63 @@
#include "libm.h"
/* Small multiples of pi/2 rounded to double precision. */
-static const double
-c1pio2 = 1*M_PI_2, /* 0x3FF921FB, 0x54442D18 */
-c2pio2 = 2*M_PI_2, /* 0x400921FB, 0x54442D18 */
-c3pio2 = 3*M_PI_2, /* 0x4012D97C, 0x7F3321D2 */
-c4pio2 = 4*M_PI_2; /* 0x401921FB, 0x54442D18 */
+static const double c1pio2 = 1 * M_PI_2, /* 0x3FF921FB, 0x54442D18 */
+ c2pio2 = 2 * M_PI_2, /* 0x400921FB, 0x54442D18 */
+ c3pio2 = 3 * M_PI_2, /* 0x4012D97C, 0x7F3321D2 */
+ c4pio2 = 4 * M_PI_2; /* 0x401921FB, 0x54442D18 */
-float cosf(float x)
-{
- double y;
- uint32_t ix;
- unsigned n, sign;
+float cosf(float x) {
+ double y;
+ uint32_t ix;
+ unsigned n, sign;
- GET_FLOAT_WORD(ix, x);
- sign = ix >> 31;
- ix &= 0x7fffffff;
+ GET_FLOAT_WORD(ix, x);
+ sign = ix >> 31;
+ ix &= 0x7fffffff;
- if (ix <= 0x3f490fda) { /* |x| ~<= pi/4 */
- if (ix < 0x39800000) { /* |x| < 2**-12 */
- /* raise inexact if x != 0 */
- FORCE_EVAL(x + 0x1p120f);
- return 1.0f;
- }
- return __cosdf(x);
- }
- if (ix <= 0x407b53d1) { /* |x| ~<= 5*pi/4 */
- if (ix > 0x4016cbe3) /* |x| ~> 3*pi/4 */
- return -__cosdf(sign ? x+c2pio2 : x-c2pio2);
- else {
- if (sign)
- return __sindf(x + c1pio2);
- else
- return __sindf(c1pio2 - x);
- }
- }
- if (ix <= 0x40e231d5) { /* |x| ~<= 9*pi/4 */
- if (ix > 0x40afeddf) /* |x| ~> 7*pi/4 */
- return __cosdf(sign ? x+c4pio2 : x-c4pio2);
- else {
- if (sign)
- return __sindf(-x - c3pio2);
- else
- return __sindf(x - c3pio2);
- }
- }
+ if (ix <= 0x3f490fda) { /* |x| ~<= pi/4 */
+ if (ix < 0x39800000) { /* |x| < 2**-12 */
+ /* raise inexact if x != 0 */
+ FORCE_EVAL(x + 0x1p120f);
+ return 1.0f;
+ }
+ return __cosdf(x);
+ }
+ if (ix <= 0x407b53d1) { /* |x| ~<= 5*pi/4 */
+ if (ix > 0x4016cbe3) /* |x| ~> 3*pi/4 */
+ return -__cosdf(sign ? x + c2pio2 : x - c2pio2);
+ else {
+ if (sign)
+ return __sindf(x + c1pio2);
+ else
+ return __sindf(c1pio2 - x);
+ }
+ }
+ if (ix <= 0x40e231d5) { /* |x| ~<= 9*pi/4 */
+ if (ix > 0x40afeddf) /* |x| ~> 7*pi/4 */
+ return __cosdf(sign ? x + c4pio2 : x - c4pio2);
+ else {
+ if (sign)
+ return __sindf(-x - c3pio2);
+ else
+ return __sindf(x - c3pio2);
+ }
+ }
- /* cos(Inf or NaN) is NaN */
- if (ix >= 0x7f800000)
- return x-x;
+ /* cos(Inf or NaN) is NaN */
+ if (ix >= 0x7f800000)
+ return x - x;
- /* general argument reduction needed */
- n = __rem_pio2f(x,&y);
- switch (n&3) {
- case 0: return __cosdf(y);
- case 1: return __sindf(-y);
- case 2: return -__cosdf(y);
- default:
- return __sindf(y);
- }
+ /* general argument reduction needed */
+ n = __rem_pio2f(x, &y);
+ switch (n & 3) {
+ case 0:
+ return __cosdf(y);
+ case 1:
+ return __sindf(-y);
+ case 2:
+ return -__cosdf(y);
+ default:
+ return __sindf(y);
+ }
}
diff --git a/fusl/src/math/cosh.c b/fusl/src/math/cosh.c
index 100f823..c346db6 100644
--- a/fusl/src/math/cosh.c
+++ b/fusl/src/math/cosh.c
@@ -4,37 +4,39 @@
* = 1 + 0.5*(exp(x)-1)*(exp(x)-1)/exp(x)
* = 1 + x*x/2 + o(x^4)
*/
-double cosh(double x)
-{
- union {double f; uint64_t i;} u = {.f = x};
- uint32_t w;
- double t;
+double cosh(double x) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {.f = x};
+ uint32_t w;
+ double t;
- /* |x| */
- u.i &= (uint64_t)-1/2;
- x = u.f;
- w = u.i >> 32;
+ /* |x| */
+ u.i &= (uint64_t)-1 / 2;
+ x = u.f;
+ w = u.i >> 32;
- /* |x| < log(2) */
- if (w < 0x3fe62e42) {
- if (w < 0x3ff00000 - (26<<20)) {
- /* raise inexact if x!=0 */
- FORCE_EVAL(x + 0x1p120f);
- return 1;
- }
- t = expm1(x);
- return 1 + t*t/(2*(1+t));
- }
+ /* |x| < log(2) */
+ if (w < 0x3fe62e42) {
+ if (w < 0x3ff00000 - (26 << 20)) {
+ /* raise inexact if x!=0 */
+ FORCE_EVAL(x + 0x1p120f);
+ return 1;
+ }
+ t = expm1(x);
+ return 1 + t * t / (2 * (1 + t));
+ }
- /* |x| < log(DBL_MAX) */
- if (w < 0x40862e42) {
- t = exp(x);
- /* note: if x>log(0x1p26) then the 1/t is not needed */
- return 0.5*(t + 1/t);
- }
+ /* |x| < log(DBL_MAX) */
+ if (w < 0x40862e42) {
+ t = exp(x);
+ /* note: if x>log(0x1p26) then the 1/t is not needed */
+ return 0.5 * (t + 1 / t);
+ }
- /* |x| > log(DBL_MAX) or nan */
- /* note: the result is stored to handle overflow */
- t = __expo2(x);
- return t;
+ /* |x| > log(DBL_MAX) or nan */
+ /* note: the result is stored to handle overflow */
+ t = __expo2(x);
+ return t;
}
diff --git a/fusl/src/math/coshf.c b/fusl/src/math/coshf.c
index b09f2ee..488942e 100644
--- a/fusl/src/math/coshf.c
+++ b/fusl/src/math/coshf.c
@@ -1,33 +1,35 @@
#include "libm.h"
-float coshf(float x)
-{
- union {float f; uint32_t i;} u = {.f = x};
- uint32_t w;
- float t;
+float coshf(float x) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {.f = x};
+ uint32_t w;
+ float t;
- /* |x| */
- u.i &= 0x7fffffff;
- x = u.f;
- w = u.i;
+ /* |x| */
+ u.i &= 0x7fffffff;
+ x = u.f;
+ w = u.i;
- /* |x| < log(2) */
- if (w < 0x3f317217) {
- if (w < 0x3f800000 - (12<<23)) {
- FORCE_EVAL(x + 0x1p120f);
- return 1;
- }
- t = expm1f(x);
- return 1 + t*t/(2*(1+t));
- }
+ /* |x| < log(2) */
+ if (w < 0x3f317217) {
+ if (w < 0x3f800000 - (12 << 23)) {
+ FORCE_EVAL(x + 0x1p120f);
+ return 1;
+ }
+ t = expm1f(x);
+ return 1 + t * t / (2 * (1 + t));
+ }
- /* |x| < log(FLT_MAX) */
- if (w < 0x42b17217) {
- t = expf(x);
- return 0.5f*(t + 1/t);
- }
+ /* |x| < log(FLT_MAX) */
+ if (w < 0x42b17217) {
+ t = expf(x);
+ return 0.5f * (t + 1 / t);
+ }
- /* |x| > log(FLT_MAX) or nan */
- t = __expo2f(x);
- return t;
+ /* |x| > log(FLT_MAX) or nan */
+ t = __expo2f(x);
+ return t;
}
diff --git a/fusl/src/math/coshl.c b/fusl/src/math/coshl.c
index 06a56fe..bc2ddf3 100644
--- a/fusl/src/math/coshl.c
+++ b/fusl/src/math/coshl.c
@@ -1,47 +1,44 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double coshl(long double x)
-{
- return cosh(x);
+long double coshl(long double x) {
+ return cosh(x);
}
#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
-long double coshl(long double x)
-{
- union ldshape u = {x};
- unsigned ex = u.i.se & 0x7fff;
- uint32_t w;
- long double t;
+long double coshl(long double x) {
+ union ldshape u = {x};
+ unsigned ex = u.i.se & 0x7fff;
+ uint32_t w;
+ long double t;
- /* |x| */
- u.i.se = ex;
- x = u.f;
- w = u.i.m >> 32;
+ /* |x| */
+ u.i.se = ex;
+ x = u.f;
+ w = u.i.m >> 32;
- /* |x| < log(2) */
- if (ex < 0x3fff-1 || (ex == 0x3fff-1 && w < 0xb17217f7)) {
- if (ex < 0x3fff-32) {
- FORCE_EVAL(x + 0x1p120f);
- return 1;
- }
- t = expm1l(x);
- return 1 + t*t/(2*(1+t));
- }
+ /* |x| < log(2) */
+ if (ex < 0x3fff - 1 || (ex == 0x3fff - 1 && w < 0xb17217f7)) {
+ if (ex < 0x3fff - 32) {
+ FORCE_EVAL(x + 0x1p120f);
+ return 1;
+ }
+ t = expm1l(x);
+ return 1 + t * t / (2 * (1 + t));
+ }
- /* |x| < log(LDBL_MAX) */
- if (ex < 0x3fff+13 || (ex == 0x3fff+13 && w < 0xb17217f7)) {
- t = expl(x);
- return 0.5*(t + 1/t);
- }
+ /* |x| < log(LDBL_MAX) */
+ if (ex < 0x3fff + 13 || (ex == 0x3fff + 13 && w < 0xb17217f7)) {
+ t = expl(x);
+ return 0.5 * (t + 1 / t);
+ }
- /* |x| > log(LDBL_MAX) or nan */
- t = expl(0.5*x);
- return 0.5*t*t;
+ /* |x| > log(LDBL_MAX) or nan */
+ t = expl(0.5 * x);
+ return 0.5 * t * t;
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
// TODO: broken implementation to make things compile
-long double coshl(long double x)
-{
- return cosh(x);
+long double coshl(long double x) {
+ return cosh(x);
}
#endif
diff --git a/fusl/src/math/cosl.c b/fusl/src/math/cosl.c
index 79c41c7..6c44a5b 100644
--- a/fusl/src/math/cosl.c
+++ b/fusl/src/math/cosl.c
@@ -2,38 +2,37 @@
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
long double cosl(long double x) {
- return cos(x);
+ return cos(x);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-long double cosl(long double x)
-{
- union ldshape u = {x};
- unsigned n;
- long double y[2], hi, lo;
+long double cosl(long double x) {
+ union ldshape u = {x};
+ unsigned n;
+ long double y[2], hi, lo;
- u.i.se &= 0x7fff;
- if (u.i.se == 0x7fff)
- return x - x;
- x = u.f;
- if (x < M_PI_4) {
- if (u.i.se < 0x3fff - LDBL_MANT_DIG)
- /* raise inexact if x!=0 */
- return 1.0 + x;
- return __cosl(x, 0);
- }
- n = __rem_pio2l(x, y);
- hi = y[0];
- lo = y[1];
- switch (n & 3) {
- case 0:
- return __cosl(hi, lo);
- case 1:
- return -__sinl(hi, lo, 1);
- case 2:
- return -__cosl(hi, lo);
- case 3:
- default:
- return __sinl(hi, lo, 1);
- }
+ u.i.se &= 0x7fff;
+ if (u.i.se == 0x7fff)
+ return x - x;
+ x = u.f;
+ if (x < M_PI_4) {
+ if (u.i.se < 0x3fff - LDBL_MANT_DIG)
+ /* raise inexact if x!=0 */
+ return 1.0 + x;
+ return __cosl(x, 0);
+ }
+ n = __rem_pio2l(x, y);
+ hi = y[0];
+ lo = y[1];
+ switch (n & 3) {
+ case 0:
+ return __cosl(hi, lo);
+ case 1:
+ return -__sinl(hi, lo, 1);
+ case 2:
+ return -__cosl(hi, lo);
+ case 3:
+ default:
+ return __sinl(hi, lo, 1);
+ }
}
#endif
diff --git a/fusl/src/math/erf.c b/fusl/src/math/erf.c
index 2f30a29..aff8bd0 100644
--- a/fusl/src/math/erf.c
+++ b/fusl/src/math/erf.c
@@ -105,169 +105,173 @@
#include "libm.h"
-static const double
-erx = 8.45062911510467529297e-01, /* 0x3FEB0AC1, 0x60000000 */
-/*
- * Coefficients for approximation to erf on [0,0.84375]
- */
-efx8 = 1.02703333676410069053e+00, /* 0x3FF06EBA, 0x8214DB69 */
-pp0 = 1.28379167095512558561e-01, /* 0x3FC06EBA, 0x8214DB68 */
-pp1 = -3.25042107247001499370e-01, /* 0xBFD4CD7D, 0x691CB913 */
-pp2 = -2.84817495755985104766e-02, /* 0xBF9D2A51, 0xDBD7194F */
-pp3 = -5.77027029648944159157e-03, /* 0xBF77A291, 0x236668E4 */
-pp4 = -2.37630166566501626084e-05, /* 0xBEF8EAD6, 0x120016AC */
-qq1 = 3.97917223959155352819e-01, /* 0x3FD97779, 0xCDDADC09 */
-qq2 = 6.50222499887672944485e-02, /* 0x3FB0A54C, 0x5536CEBA */
-qq3 = 5.08130628187576562776e-03, /* 0x3F74D022, 0xC4D36B0F */
-qq4 = 1.32494738004321644526e-04, /* 0x3F215DC9, 0x221C1A10 */
-qq5 = -3.96022827877536812320e-06, /* 0xBED09C43, 0x42A26120 */
-/*
- * Coefficients for approximation to erf in [0.84375,1.25]
- */
-pa0 = -2.36211856075265944077e-03, /* 0xBF6359B8, 0xBEF77538 */
-pa1 = 4.14856118683748331666e-01, /* 0x3FDA8D00, 0xAD92B34D */
-pa2 = -3.72207876035701323847e-01, /* 0xBFD7D240, 0xFBB8C3F1 */
-pa3 = 3.18346619901161753674e-01, /* 0x3FD45FCA, 0x805120E4 */
-pa4 = -1.10894694282396677476e-01, /* 0xBFBC6398, 0x3D3E28EC */
-pa5 = 3.54783043256182359371e-02, /* 0x3FA22A36, 0x599795EB */
-pa6 = -2.16637559486879084300e-03, /* 0xBF61BF38, 0x0A96073F */
-qa1 = 1.06420880400844228286e-01, /* 0x3FBB3E66, 0x18EEE323 */
-qa2 = 5.40397917702171048937e-01, /* 0x3FE14AF0, 0x92EB6F33 */
-qa3 = 7.18286544141962662868e-02, /* 0x3FB2635C, 0xD99FE9A7 */
-qa4 = 1.26171219808761642112e-01, /* 0x3FC02660, 0xE763351F */
-qa5 = 1.36370839120290507362e-02, /* 0x3F8BEDC2, 0x6B51DD1C */
-qa6 = 1.19844998467991074170e-02, /* 0x3F888B54, 0x5735151D */
-/*
- * Coefficients for approximation to erfc in [1.25,1/0.35]
- */
-ra0 = -9.86494403484714822705e-03, /* 0xBF843412, 0x600D6435 */
-ra1 = -6.93858572707181764372e-01, /* 0xBFE63416, 0xE4BA7360 */
-ra2 = -1.05586262253232909814e+01, /* 0xC0251E04, 0x41B0E726 */
-ra3 = -6.23753324503260060396e+01, /* 0xC04F300A, 0xE4CBA38D */
-ra4 = -1.62396669462573470355e+02, /* 0xC0644CB1, 0x84282266 */
-ra5 = -1.84605092906711035994e+02, /* 0xC067135C, 0xEBCCABB2 */
-ra6 = -8.12874355063065934246e+01, /* 0xC0545265, 0x57E4D2F2 */
-ra7 = -9.81432934416914548592e+00, /* 0xC023A0EF, 0xC69AC25C */
-sa1 = 1.96512716674392571292e+01, /* 0x4033A6B9, 0xBD707687 */
-sa2 = 1.37657754143519042600e+02, /* 0x4061350C, 0x526AE721 */
-sa3 = 4.34565877475229228821e+02, /* 0x407B290D, 0xD58A1A71 */
-sa4 = 6.45387271733267880336e+02, /* 0x40842B19, 0x21EC2868 */
-sa5 = 4.29008140027567833386e+02, /* 0x407AD021, 0x57700314 */
-sa6 = 1.08635005541779435134e+02, /* 0x405B28A3, 0xEE48AE2C */
-sa7 = 6.57024977031928170135e+00, /* 0x401A47EF, 0x8E484A93 */
-sa8 = -6.04244152148580987438e-02, /* 0xBFAEEFF2, 0xEE749A62 */
-/*
- * Coefficients for approximation to erfc in [1/.35,28]
- */
-rb0 = -9.86494292470009928597e-03, /* 0xBF843412, 0x39E86F4A */
-rb1 = -7.99283237680523006574e-01, /* 0xBFE993BA, 0x70C285DE */
-rb2 = -1.77579549177547519889e+01, /* 0xC031C209, 0x555F995A */
-rb3 = -1.60636384855821916062e+02, /* 0xC064145D, 0x43C5ED98 */
-rb4 = -6.37566443368389627722e+02, /* 0xC083EC88, 0x1375F228 */
-rb5 = -1.02509513161107724954e+03, /* 0xC0900461, 0x6A2E5992 */
-rb6 = -4.83519191608651397019e+02, /* 0xC07E384E, 0x9BDC383F */
-sb1 = 3.03380607434824582924e+01, /* 0x403E568B, 0x261D5190 */
-sb2 = 3.25792512996573918826e+02, /* 0x40745CAE, 0x221B9F0A */
-sb3 = 1.53672958608443695994e+03, /* 0x409802EB, 0x189D5118 */
-sb4 = 3.19985821950859553908e+03, /* 0x40A8FFB7, 0x688C246A */
-sb5 = 2.55305040643316442583e+03, /* 0x40A3F219, 0xCEDF3BE6 */
-sb6 = 4.74528541206955367215e+02, /* 0x407DA874, 0xE79FE763 */
-sb7 = -2.24409524465858183362e+01; /* 0xC03670E2, 0x42712D62 */
+static const double erx =
+ 8.45062911510467529297e-01, /* 0x3FEB0AC1, 0x60000000 */
+ /*
+ * Coefficients for approximation to erf on [0,0.84375]
+ */
+ efx8 = 1.02703333676410069053e+00, /* 0x3FF06EBA, 0x8214DB69 */
+ pp0 = 1.28379167095512558561e-01, /* 0x3FC06EBA, 0x8214DB68 */
+ pp1 = -3.25042107247001499370e-01, /* 0xBFD4CD7D, 0x691CB913 */
+ pp2 = -2.84817495755985104766e-02, /* 0xBF9D2A51, 0xDBD7194F */
+ pp3 = -5.77027029648944159157e-03, /* 0xBF77A291, 0x236668E4 */
+ pp4 = -2.37630166566501626084e-05, /* 0xBEF8EAD6, 0x120016AC */
+ qq1 = 3.97917223959155352819e-01, /* 0x3FD97779, 0xCDDADC09 */
+ qq2 = 6.50222499887672944485e-02, /* 0x3FB0A54C, 0x5536CEBA */
+ qq3 = 5.08130628187576562776e-03, /* 0x3F74D022, 0xC4D36B0F */
+ qq4 = 1.32494738004321644526e-04, /* 0x3F215DC9, 0x221C1A10 */
+ qq5 = -3.96022827877536812320e-06, /* 0xBED09C43, 0x42A26120 */
+ /*
+ * Coefficients for approximation to erf in [0.84375,1.25]
+ */
+ pa0 = -2.36211856075265944077e-03, /* 0xBF6359B8, 0xBEF77538 */
+ pa1 = 4.14856118683748331666e-01, /* 0x3FDA8D00, 0xAD92B34D */
+ pa2 = -3.72207876035701323847e-01, /* 0xBFD7D240, 0xFBB8C3F1 */
+ pa3 = 3.18346619901161753674e-01, /* 0x3FD45FCA, 0x805120E4 */
+ pa4 = -1.10894694282396677476e-01, /* 0xBFBC6398, 0x3D3E28EC */
+ pa5 = 3.54783043256182359371e-02, /* 0x3FA22A36, 0x599795EB */
+ pa6 = -2.16637559486879084300e-03, /* 0xBF61BF38, 0x0A96073F */
+ qa1 = 1.06420880400844228286e-01, /* 0x3FBB3E66, 0x18EEE323 */
+ qa2 = 5.40397917702171048937e-01, /* 0x3FE14AF0, 0x92EB6F33 */
+ qa3 = 7.18286544141962662868e-02, /* 0x3FB2635C, 0xD99FE9A7 */
+ qa4 = 1.26171219808761642112e-01, /* 0x3FC02660, 0xE763351F */
+ qa5 = 1.36370839120290507362e-02, /* 0x3F8BEDC2, 0x6B51DD1C */
+ qa6 = 1.19844998467991074170e-02, /* 0x3F888B54, 0x5735151D */
+ /*
+ * Coefficients for approximation to erfc in [1.25,1/0.35]
+ */
+ ra0 = -9.86494403484714822705e-03, /* 0xBF843412, 0x600D6435 */
+ ra1 = -6.93858572707181764372e-01, /* 0xBFE63416, 0xE4BA7360 */
+ ra2 = -1.05586262253232909814e+01, /* 0xC0251E04, 0x41B0E726 */
+ ra3 = -6.23753324503260060396e+01, /* 0xC04F300A, 0xE4CBA38D */
+ ra4 = -1.62396669462573470355e+02, /* 0xC0644CB1, 0x84282266 */
+ ra5 = -1.84605092906711035994e+02, /* 0xC067135C, 0xEBCCABB2 */
+ ra6 = -8.12874355063065934246e+01, /* 0xC0545265, 0x57E4D2F2 */
+ ra7 = -9.81432934416914548592e+00, /* 0xC023A0EF, 0xC69AC25C */
+ sa1 = 1.96512716674392571292e+01, /* 0x4033A6B9, 0xBD707687 */
+ sa2 = 1.37657754143519042600e+02, /* 0x4061350C, 0x526AE721 */
+ sa3 = 4.34565877475229228821e+02, /* 0x407B290D, 0xD58A1A71 */
+ sa4 = 6.45387271733267880336e+02, /* 0x40842B19, 0x21EC2868 */
+ sa5 = 4.29008140027567833386e+02, /* 0x407AD021, 0x57700314 */
+ sa6 = 1.08635005541779435134e+02, /* 0x405B28A3, 0xEE48AE2C */
+ sa7 = 6.57024977031928170135e+00, /* 0x401A47EF, 0x8E484A93 */
+ sa8 = -6.04244152148580987438e-02, /* 0xBFAEEFF2, 0xEE749A62 */
+ /*
+ * Coefficients for approximation to erfc in [1/.35,28]
+ */
+ rb0 = -9.86494292470009928597e-03, /* 0xBF843412, 0x39E86F4A */
+ rb1 = -7.99283237680523006574e-01, /* 0xBFE993BA, 0x70C285DE */
+ rb2 = -1.77579549177547519889e+01, /* 0xC031C209, 0x555F995A */
+ rb3 = -1.60636384855821916062e+02, /* 0xC064145D, 0x43C5ED98 */
+ rb4 = -6.37566443368389627722e+02, /* 0xC083EC88, 0x1375F228 */
+ rb5 = -1.02509513161107724954e+03, /* 0xC0900461, 0x6A2E5992 */
+ rb6 = -4.83519191608651397019e+02, /* 0xC07E384E, 0x9BDC383F */
+ sb1 = 3.03380607434824582924e+01, /* 0x403E568B, 0x261D5190 */
+ sb2 = 3.25792512996573918826e+02, /* 0x40745CAE, 0x221B9F0A */
+ sb3 = 1.53672958608443695994e+03, /* 0x409802EB, 0x189D5118 */
+ sb4 = 3.19985821950859553908e+03, /* 0x40A8FFB7, 0x688C246A */
+ sb5 = 2.55305040643316442583e+03, /* 0x40A3F219, 0xCEDF3BE6 */
+ sb6 = 4.74528541206955367215e+02, /* 0x407DA874, 0xE79FE763 */
+ sb7 = -2.24409524465858183362e+01; /* 0xC03670E2, 0x42712D62 */
-static double erfc1(double x)
-{
- double_t s,P,Q;
+static double erfc1(double x) {
+ double_t s, P, Q;
- s = fabs(x) - 1;
- P = pa0+s*(pa1+s*(pa2+s*(pa3+s*(pa4+s*(pa5+s*pa6)))));
- Q = 1+s*(qa1+s*(qa2+s*(qa3+s*(qa4+s*(qa5+s*qa6)))));
- return 1 - erx - P/Q;
+ s = fabs(x) - 1;
+ P = pa0 + s * (pa1 + s * (pa2 + s * (pa3 + s * (pa4 + s * (pa5 + s * pa6)))));
+ Q = 1 + s * (qa1 + s * (qa2 + s * (qa3 + s * (qa4 + s * (qa5 + s * qa6)))));
+ return 1 - erx - P / Q;
}
-static double erfc2(uint32_t ix, double x)
-{
- double_t s,R,S;
- double z;
+static double erfc2(uint32_t ix, double x) {
+ double_t s, R, S;
+ double z;
- if (ix < 0x3ff40000) /* |x| < 1.25 */
- return erfc1(x);
+ if (ix < 0x3ff40000) /* |x| < 1.25 */
+ return erfc1(x);
- x = fabs(x);
- s = 1/(x*x);
- if (ix < 0x4006db6d) { /* |x| < 1/.35 ~ 2.85714 */
- R = ra0+s*(ra1+s*(ra2+s*(ra3+s*(ra4+s*(
- ra5+s*(ra6+s*ra7))))));
- S = 1.0+s*(sa1+s*(sa2+s*(sa3+s*(sa4+s*(
- sa5+s*(sa6+s*(sa7+s*sa8)))))));
- } else { /* |x| > 1/.35 */
- R = rb0+s*(rb1+s*(rb2+s*(rb3+s*(rb4+s*(
- rb5+s*rb6)))));
- S = 1.0+s*(sb1+s*(sb2+s*(sb3+s*(sb4+s*(
- sb5+s*(sb6+s*sb7))))));
- }
- z = x;
- SET_LOW_WORD(z,0);
- return exp(-z*z-0.5625)*exp((z-x)*(z+x)+R/S)/x;
+ x = fabs(x);
+ s = 1 / (x * x);
+ if (ix < 0x4006db6d) { /* |x| < 1/.35 ~ 2.85714 */
+ R = ra0 +
+ s * (ra1 +
+ s * (ra2 +
+ s * (ra3 + s * (ra4 + s * (ra5 + s * (ra6 + s * ra7))))));
+ S = 1.0 +
+ s * (sa1 +
+ s * (sa2 +
+ s * (sa3 +
+ s * (sa4 +
+ s * (sa5 + s * (sa6 + s * (sa7 + s * sa8)))))));
+ } else { /* |x| > 1/.35 */
+ R = rb0 +
+ s * (rb1 + s * (rb2 + s * (rb3 + s * (rb4 + s * (rb5 + s * rb6)))));
+ S = 1.0 +
+ s * (sb1 +
+ s * (sb2 +
+ s * (sb3 + s * (sb4 + s * (sb5 + s * (sb6 + s * sb7))))));
+ }
+ z = x;
+ SET_LOW_WORD(z, 0);
+ return exp(-z * z - 0.5625) * exp((z - x) * (z + x) + R / S) / x;
}
-double erf(double x)
-{
- double r,s,z,y;
- uint32_t ix;
- int sign;
+double erf(double x) {
+ double r, s, z, y;
+ uint32_t ix;
+ int sign;
- GET_HIGH_WORD(ix, x);
- sign = ix>>31;
- ix &= 0x7fffffff;
- if (ix >= 0x7ff00000) {
- /* erf(nan)=nan, erf(+-inf)=+-1 */
- return 1-2*sign + 1/x;
- }
- if (ix < 0x3feb0000) { /* |x| < 0.84375 */
- if (ix < 0x3e300000) { /* |x| < 2**-28 */
- /* avoid underflow */
- return 0.125*(8*x + efx8*x);
- }
- z = x*x;
- r = pp0+z*(pp1+z*(pp2+z*(pp3+z*pp4)));
- s = 1.0+z*(qq1+z*(qq2+z*(qq3+z*(qq4+z*qq5))));
- y = r/s;
- return x + x*y;
- }
- if (ix < 0x40180000) /* 0.84375 <= |x| < 6 */
- y = 1 - erfc2(ix,x);
- else
- y = 1 - 0x1p-1022;
- return sign ? -y : y;
+ GET_HIGH_WORD(ix, x);
+ sign = ix >> 31;
+ ix &= 0x7fffffff;
+ if (ix >= 0x7ff00000) {
+ /* erf(nan)=nan, erf(+-inf)=+-1 */
+ return 1 - 2 * sign + 1 / x;
+ }
+ if (ix < 0x3feb0000) { /* |x| < 0.84375 */
+ if (ix < 0x3e300000) { /* |x| < 2**-28 */
+ /* avoid underflow */
+ return 0.125 * (8 * x + efx8 * x);
+ }
+ z = x * x;
+ r = pp0 + z * (pp1 + z * (pp2 + z * (pp3 + z * pp4)));
+ s = 1.0 + z * (qq1 + z * (qq2 + z * (qq3 + z * (qq4 + z * qq5))));
+ y = r / s;
+ return x + x * y;
+ }
+ if (ix < 0x40180000) /* 0.84375 <= |x| < 6 */
+ y = 1 - erfc2(ix, x);
+ else
+ y = 1 - 0x1p-1022;
+ return sign ? -y : y;
}
-double erfc(double x)
-{
- double r,s,z,y;
- uint32_t ix;
- int sign;
+double erfc(double x) {
+ double r, s, z, y;
+ uint32_t ix;
+ int sign;
- GET_HIGH_WORD(ix, x);
- sign = ix>>31;
- ix &= 0x7fffffff;
- if (ix >= 0x7ff00000) {
- /* erfc(nan)=nan, erfc(+-inf)=0,2 */
- return 2*sign + 1/x;
- }
- if (ix < 0x3feb0000) { /* |x| < 0.84375 */
- if (ix < 0x3c700000) /* |x| < 2**-56 */
- return 1.0 - x;
- z = x*x;
- r = pp0+z*(pp1+z*(pp2+z*(pp3+z*pp4)));
- s = 1.0+z*(qq1+z*(qq2+z*(qq3+z*(qq4+z*qq5))));
- y = r/s;
- if (sign || ix < 0x3fd00000) { /* x < 1/4 */
- return 1.0 - (x+x*y);
- }
- return 0.5 - (x - 0.5 + x*y);
- }
- if (ix < 0x403c0000) { /* 0.84375 <= |x| < 28 */
- return sign ? 2 - erfc2(ix,x) : erfc2(ix,x);
- }
- return sign ? 2 - 0x1p-1022 : 0x1p-1022*0x1p-1022;
+ GET_HIGH_WORD(ix, x);
+ sign = ix >> 31;
+ ix &= 0x7fffffff;
+ if (ix >= 0x7ff00000) {
+ /* erfc(nan)=nan, erfc(+-inf)=0,2 */
+ return 2 * sign + 1 / x;
+ }
+ if (ix < 0x3feb0000) { /* |x| < 0.84375 */
+ if (ix < 0x3c700000) /* |x| < 2**-56 */
+ return 1.0 - x;
+ z = x * x;
+ r = pp0 + z * (pp1 + z * (pp2 + z * (pp3 + z * pp4)));
+ s = 1.0 + z * (qq1 + z * (qq2 + z * (qq3 + z * (qq4 + z * qq5))));
+ y = r / s;
+ if (sign || ix < 0x3fd00000) { /* x < 1/4 */
+ return 1.0 - (x + x * y);
+ }
+ return 0.5 - (x - 0.5 + x * y);
+ }
+ if (ix < 0x403c0000) { /* 0.84375 <= |x| < 28 */
+ return sign ? 2 - erfc2(ix, x) : erfc2(ix, x);
+ }
+ return sign ? 2 - 0x1p-1022 : 0x1p-1022 * 0x1p-1022;
}
diff --git a/fusl/src/math/erff.c b/fusl/src/math/erff.c
index ed5f397..13abe22 100644
--- a/fusl/src/math/erff.c
+++ b/fusl/src/math/erff.c
@@ -15,169 +15,172 @@
#include "libm.h"
-static const float
-erx = 8.4506291151e-01, /* 0x3f58560b */
-/*
- * Coefficients for approximation to erf on [0,0.84375]
- */
-efx8 = 1.0270333290e+00, /* 0x3f8375d4 */
-pp0 = 1.2837916613e-01, /* 0x3e0375d4 */
-pp1 = -3.2504209876e-01, /* 0xbea66beb */
-pp2 = -2.8481749818e-02, /* 0xbce9528f */
-pp3 = -5.7702702470e-03, /* 0xbbbd1489 */
-pp4 = -2.3763017452e-05, /* 0xb7c756b1 */
-qq1 = 3.9791721106e-01, /* 0x3ecbbbce */
-qq2 = 6.5022252500e-02, /* 0x3d852a63 */
-qq3 = 5.0813062117e-03, /* 0x3ba68116 */
-qq4 = 1.3249473704e-04, /* 0x390aee49 */
-qq5 = -3.9602282413e-06, /* 0xb684e21a */
-/*
- * Coefficients for approximation to erf in [0.84375,1.25]
- */
-pa0 = -2.3621185683e-03, /* 0xbb1acdc6 */
-pa1 = 4.1485610604e-01, /* 0x3ed46805 */
-pa2 = -3.7220788002e-01, /* 0xbebe9208 */
-pa3 = 3.1834661961e-01, /* 0x3ea2fe54 */
-pa4 = -1.1089469492e-01, /* 0xbde31cc2 */
-pa5 = 3.5478305072e-02, /* 0x3d1151b3 */
-pa6 = -2.1663755178e-03, /* 0xbb0df9c0 */
-qa1 = 1.0642088205e-01, /* 0x3dd9f331 */
-qa2 = 5.4039794207e-01, /* 0x3f0a5785 */
-qa3 = 7.1828655899e-02, /* 0x3d931ae7 */
-qa4 = 1.2617121637e-01, /* 0x3e013307 */
-qa5 = 1.3637083583e-02, /* 0x3c5f6e13 */
-qa6 = 1.1984500103e-02, /* 0x3c445aa3 */
-/*
- * Coefficients for approximation to erfc in [1.25,1/0.35]
- */
-ra0 = -9.8649440333e-03, /* 0xbc21a093 */
-ra1 = -6.9385856390e-01, /* 0xbf31a0b7 */
-ra2 = -1.0558626175e+01, /* 0xc128f022 */
-ra3 = -6.2375331879e+01, /* 0xc2798057 */
-ra4 = -1.6239666748e+02, /* 0xc322658c */
-ra5 = -1.8460508728e+02, /* 0xc3389ae7 */
-ra6 = -8.1287437439e+01, /* 0xc2a2932b */
-ra7 = -9.8143291473e+00, /* 0xc11d077e */
-sa1 = 1.9651271820e+01, /* 0x419d35ce */
-sa2 = 1.3765776062e+02, /* 0x4309a863 */
-sa3 = 4.3456588745e+02, /* 0x43d9486f */
-sa4 = 6.4538726807e+02, /* 0x442158c9 */
-sa5 = 4.2900814819e+02, /* 0x43d6810b */
-sa6 = 1.0863500214e+02, /* 0x42d9451f */
-sa7 = 6.5702495575e+00, /* 0x40d23f7c */
-sa8 = -6.0424413532e-02, /* 0xbd777f97 */
-/*
- * Coefficients for approximation to erfc in [1/.35,28]
- */
-rb0 = -9.8649431020e-03, /* 0xbc21a092 */
-rb1 = -7.9928326607e-01, /* 0xbf4c9dd4 */
-rb2 = -1.7757955551e+01, /* 0xc18e104b */
-rb3 = -1.6063638306e+02, /* 0xc320a2ea */
-rb4 = -6.3756646729e+02, /* 0xc41f6441 */
-rb5 = -1.0250950928e+03, /* 0xc480230b */
-rb6 = -4.8351919556e+02, /* 0xc3f1c275 */
-sb1 = 3.0338060379e+01, /* 0x41f2b459 */
-sb2 = 3.2579251099e+02, /* 0x43a2e571 */
-sb3 = 1.5367296143e+03, /* 0x44c01759 */
-sb4 = 3.1998581543e+03, /* 0x4547fdbb */
-sb5 = 2.5530502930e+03, /* 0x451f90ce */
-sb6 = 4.7452853394e+02, /* 0x43ed43a7 */
-sb7 = -2.2440952301e+01; /* 0xc1b38712 */
+static const float erx = 8.4506291151e-01, /* 0x3f58560b */
+ /*
+ * Coefficients for approximation to erf on [0,0.84375]
+ */
+ efx8 = 1.0270333290e+00, /* 0x3f8375d4 */
+ pp0 = 1.2837916613e-01, /* 0x3e0375d4 */
+ pp1 = -3.2504209876e-01, /* 0xbea66beb */
+ pp2 = -2.8481749818e-02, /* 0xbce9528f */
+ pp3 = -5.7702702470e-03, /* 0xbbbd1489 */
+ pp4 = -2.3763017452e-05, /* 0xb7c756b1 */
+ qq1 = 3.9791721106e-01, /* 0x3ecbbbce */
+ qq2 = 6.5022252500e-02, /* 0x3d852a63 */
+ qq3 = 5.0813062117e-03, /* 0x3ba68116 */
+ qq4 = 1.3249473704e-04, /* 0x390aee49 */
+ qq5 = -3.9602282413e-06, /* 0xb684e21a */
+ /*
+ * Coefficients for approximation to erf in [0.84375,1.25]
+ */
+ pa0 = -2.3621185683e-03, /* 0xbb1acdc6 */
+ pa1 = 4.1485610604e-01, /* 0x3ed46805 */
+ pa2 = -3.7220788002e-01, /* 0xbebe9208 */
+ pa3 = 3.1834661961e-01, /* 0x3ea2fe54 */
+ pa4 = -1.1089469492e-01, /* 0xbde31cc2 */
+ pa5 = 3.5478305072e-02, /* 0x3d1151b3 */
+ pa6 = -2.1663755178e-03, /* 0xbb0df9c0 */
+ qa1 = 1.0642088205e-01, /* 0x3dd9f331 */
+ qa2 = 5.4039794207e-01, /* 0x3f0a5785 */
+ qa3 = 7.1828655899e-02, /* 0x3d931ae7 */
+ qa4 = 1.2617121637e-01, /* 0x3e013307 */
+ qa5 = 1.3637083583e-02, /* 0x3c5f6e13 */
+ qa6 = 1.1984500103e-02, /* 0x3c445aa3 */
+ /*
+ * Coefficients for approximation to erfc in [1.25,1/0.35]
+ */
+ ra0 = -9.8649440333e-03, /* 0xbc21a093 */
+ ra1 = -6.9385856390e-01, /* 0xbf31a0b7 */
+ ra2 = -1.0558626175e+01, /* 0xc128f022 */
+ ra3 = -6.2375331879e+01, /* 0xc2798057 */
+ ra4 = -1.6239666748e+02, /* 0xc322658c */
+ ra5 = -1.8460508728e+02, /* 0xc3389ae7 */
+ ra6 = -8.1287437439e+01, /* 0xc2a2932b */
+ ra7 = -9.8143291473e+00, /* 0xc11d077e */
+ sa1 = 1.9651271820e+01, /* 0x419d35ce */
+ sa2 = 1.3765776062e+02, /* 0x4309a863 */
+ sa3 = 4.3456588745e+02, /* 0x43d9486f */
+ sa4 = 6.4538726807e+02, /* 0x442158c9 */
+ sa5 = 4.2900814819e+02, /* 0x43d6810b */
+ sa6 = 1.0863500214e+02, /* 0x42d9451f */
+ sa7 = 6.5702495575e+00, /* 0x40d23f7c */
+ sa8 = -6.0424413532e-02, /* 0xbd777f97 */
+ /*
+ * Coefficients for approximation to erfc in [1/.35,28]
+ */
+ rb0 = -9.8649431020e-03, /* 0xbc21a092 */
+ rb1 = -7.9928326607e-01, /* 0xbf4c9dd4 */
+ rb2 = -1.7757955551e+01, /* 0xc18e104b */
+ rb3 = -1.6063638306e+02, /* 0xc320a2ea */
+ rb4 = -6.3756646729e+02, /* 0xc41f6441 */
+ rb5 = -1.0250950928e+03, /* 0xc480230b */
+ rb6 = -4.8351919556e+02, /* 0xc3f1c275 */
+ sb1 = 3.0338060379e+01, /* 0x41f2b459 */
+ sb2 = 3.2579251099e+02, /* 0x43a2e571 */
+ sb3 = 1.5367296143e+03, /* 0x44c01759 */
+ sb4 = 3.1998581543e+03, /* 0x4547fdbb */
+ sb5 = 2.5530502930e+03, /* 0x451f90ce */
+ sb6 = 4.7452853394e+02, /* 0x43ed43a7 */
+ sb7 = -2.2440952301e+01; /* 0xc1b38712 */
-static float erfc1(float x)
-{
- float_t s,P,Q;
+static float erfc1(float x) {
+ float_t s, P, Q;
- s = fabsf(x) - 1;
- P = pa0+s*(pa1+s*(pa2+s*(pa3+s*(pa4+s*(pa5+s*pa6)))));
- Q = 1+s*(qa1+s*(qa2+s*(qa3+s*(qa4+s*(qa5+s*qa6)))));
- return 1 - erx - P/Q;
+ s = fabsf(x) - 1;
+ P = pa0 + s * (pa1 + s * (pa2 + s * (pa3 + s * (pa4 + s * (pa5 + s * pa6)))));
+ Q = 1 + s * (qa1 + s * (qa2 + s * (qa3 + s * (qa4 + s * (qa5 + s * qa6)))));
+ return 1 - erx - P / Q;
}
-static float erfc2(uint32_t ix, float x)
-{
- float_t s,R,S;
- float z;
+static float erfc2(uint32_t ix, float x) {
+ float_t s, R, S;
+ float z;
- if (ix < 0x3fa00000) /* |x| < 1.25 */
- return erfc1(x);
+ if (ix < 0x3fa00000) /* |x| < 1.25 */
+ return erfc1(x);
- x = fabsf(x);
- s = 1/(x*x);
- if (ix < 0x4036db6d) { /* |x| < 1/0.35 */
- R = ra0+s*(ra1+s*(ra2+s*(ra3+s*(ra4+s*(
- ra5+s*(ra6+s*ra7))))));
- S = 1.0f+s*(sa1+s*(sa2+s*(sa3+s*(sa4+s*(
- sa5+s*(sa6+s*(sa7+s*sa8)))))));
- } else { /* |x| >= 1/0.35 */
- R = rb0+s*(rb1+s*(rb2+s*(rb3+s*(rb4+s*(
- rb5+s*rb6)))));
- S = 1.0f+s*(sb1+s*(sb2+s*(sb3+s*(sb4+s*(
- sb5+s*(sb6+s*sb7))))));
- }
- GET_FLOAT_WORD(ix, x);
- SET_FLOAT_WORD(z, ix&0xffffe000);
- return expf(-z*z - 0.5625f) * expf((z-x)*(z+x) + R/S)/x;
+ x = fabsf(x);
+ s = 1 / (x * x);
+ if (ix < 0x4036db6d) { /* |x| < 1/0.35 */
+ R = ra0 +
+ s * (ra1 +
+ s * (ra2 +
+ s * (ra3 + s * (ra4 + s * (ra5 + s * (ra6 + s * ra7))))));
+ S = 1.0f +
+ s * (sa1 +
+ s * (sa2 +
+ s * (sa3 +
+ s * (sa4 +
+ s * (sa5 + s * (sa6 + s * (sa7 + s * sa8)))))));
+ } else { /* |x| >= 1/0.35 */
+ R = rb0 +
+ s * (rb1 + s * (rb2 + s * (rb3 + s * (rb4 + s * (rb5 + s * rb6)))));
+ S = 1.0f +
+ s * (sb1 +
+ s * (sb2 +
+ s * (sb3 + s * (sb4 + s * (sb5 + s * (sb6 + s * sb7))))));
+ }
+ GET_FLOAT_WORD(ix, x);
+ SET_FLOAT_WORD(z, ix & 0xffffe000);
+ return expf(-z * z - 0.5625f) * expf((z - x) * (z + x) + R / S) / x;
}
-float erff(float x)
-{
- float r,s,z,y;
- uint32_t ix;
- int sign;
+float erff(float x) {
+ float r, s, z, y;
+ uint32_t ix;
+ int sign;
- GET_FLOAT_WORD(ix, x);
- sign = ix>>31;
- ix &= 0x7fffffff;
- if (ix >= 0x7f800000) {
- /* erf(nan)=nan, erf(+-inf)=+-1 */
- return 1-2*sign + 1/x;
- }
- if (ix < 0x3f580000) { /* |x| < 0.84375 */
- if (ix < 0x31800000) { /* |x| < 2**-28 */
- /*avoid underflow */
- return 0.125f*(8*x + efx8*x);
- }
- z = x*x;
- r = pp0+z*(pp1+z*(pp2+z*(pp3+z*pp4)));
- s = 1+z*(qq1+z*(qq2+z*(qq3+z*(qq4+z*qq5))));
- y = r/s;
- return x + x*y;
- }
- if (ix < 0x40c00000) /* |x| < 6 */
- y = 1 - erfc2(ix,x);
- else
- y = 1 - 0x1p-120f;
- return sign ? -y : y;
+ GET_FLOAT_WORD(ix, x);
+ sign = ix >> 31;
+ ix &= 0x7fffffff;
+ if (ix >= 0x7f800000) {
+ /* erf(nan)=nan, erf(+-inf)=+-1 */
+ return 1 - 2 * sign + 1 / x;
+ }
+ if (ix < 0x3f580000) { /* |x| < 0.84375 */
+ if (ix < 0x31800000) { /* |x| < 2**-28 */
+ /*avoid underflow */
+ return 0.125f * (8 * x + efx8 * x);
+ }
+ z = x * x;
+ r = pp0 + z * (pp1 + z * (pp2 + z * (pp3 + z * pp4)));
+ s = 1 + z * (qq1 + z * (qq2 + z * (qq3 + z * (qq4 + z * qq5))));
+ y = r / s;
+ return x + x * y;
+ }
+ if (ix < 0x40c00000) /* |x| < 6 */
+ y = 1 - erfc2(ix, x);
+ else
+ y = 1 - 0x1p-120f;
+ return sign ? -y : y;
}
-float erfcf(float x)
-{
- float r,s,z,y;
- uint32_t ix;
- int sign;
+float erfcf(float x) {
+ float r, s, z, y;
+ uint32_t ix;
+ int sign;
- GET_FLOAT_WORD(ix, x);
- sign = ix>>31;
- ix &= 0x7fffffff;
- if (ix >= 0x7f800000) {
- /* erfc(nan)=nan, erfc(+-inf)=0,2 */
- return 2*sign + 1/x;
- }
+ GET_FLOAT_WORD(ix, x);
+ sign = ix >> 31;
+ ix &= 0x7fffffff;
+ if (ix >= 0x7f800000) {
+ /* erfc(nan)=nan, erfc(+-inf)=0,2 */
+ return 2 * sign + 1 / x;
+ }
- if (ix < 0x3f580000) { /* |x| < 0.84375 */
- if (ix < 0x23800000) /* |x| < 2**-56 */
- return 1.0f - x;
- z = x*x;
- r = pp0+z*(pp1+z*(pp2+z*(pp3+z*pp4)));
- s = 1.0f+z*(qq1+z*(qq2+z*(qq3+z*(qq4+z*qq5))));
- y = r/s;
- if (sign || ix < 0x3e800000) /* x < 1/4 */
- return 1.0f - (x+x*y);
- return 0.5f - (x - 0.5f + x*y);
- }
- if (ix < 0x41e00000) { /* |x| < 28 */
- return sign ? 2 - erfc2(ix,x) : erfc2(ix,x);
- }
- return sign ? 2 - 0x1p-120f : 0x1p-120f*0x1p-120f;
+ if (ix < 0x3f580000) { /* |x| < 0.84375 */
+ if (ix < 0x23800000) /* |x| < 2**-56 */
+ return 1.0f - x;
+ z = x * x;
+ r = pp0 + z * (pp1 + z * (pp2 + z * (pp3 + z * pp4)));
+ s = 1.0f + z * (qq1 + z * (qq2 + z * (qq3 + z * (qq4 + z * qq5))));
+ y = r / s;
+ if (sign || ix < 0x3e800000) /* x < 1/4 */
+ return 1.0f - (x + x * y);
+ return 0.5f - (x - 0.5f + x * y);
+ }
+ if (ix < 0x41e00000) { /* |x| < 28 */
+ return sign ? 2 - erfc2(ix, x) : erfc2(ix, x);
+ }
+ return sign ? 2 - 0x1p-120f : 0x1p-120f * 0x1p-120f;
}
diff --git a/fusl/src/math/erfl.c b/fusl/src/math/erfl.c
index e267c23..a5a6a73 100644
--- a/fusl/src/math/erfl.c
+++ b/fusl/src/math/erfl.c
@@ -97,257 +97,277 @@
* erfc/erf(NaN) is NaN
*/
-
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double erfl(long double x)
-{
- return erf(x);
+long double erfl(long double x) {
+ return erf(x);
}
-long double erfcl(long double x)
-{
- return erfc(x);
+long double erfcl(long double x) {
+ return erfc(x);
}
#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
static const long double
-erx = 0.845062911510467529296875L,
+ erx = 0.845062911510467529296875L,
-/*
- * Coefficients for approximation to erf on [0,0.84375]
- */
-/* 8 * (2/sqrt(pi) - 1) */
-efx8 = 1.0270333367641005911692712249723613735048E0L,
-pp[6] = {
- 1.122751350964552113068262337278335028553E6L,
- -2.808533301997696164408397079650699163276E6L,
- -3.314325479115357458197119660818768924100E5L,
- -6.848684465326256109712135497895525446398E4L,
- -2.657817695110739185591505062971929859314E3L,
- -1.655310302737837556654146291646499062882E2L,
+ /*
+ * Coefficients for approximation to erf on [0,0.84375]
+ */
+ /* 8 * (2/sqrt(pi) - 1) */
+ efx8 = 1.0270333367641005911692712249723613735048E0L,
+ pp[6] =
+ {
+ 1.122751350964552113068262337278335028553E6L,
+ -2.808533301997696164408397079650699163276E6L,
+ -3.314325479115357458197119660818768924100E5L,
+ -6.848684465326256109712135497895525446398E4L,
+ -2.657817695110739185591505062971929859314E3L,
+ -1.655310302737837556654146291646499062882E2L,
},
-qq[6] = {
- 8.745588372054466262548908189000448124232E6L,
- 3.746038264792471129367533128637019611485E6L,
- 7.066358783162407559861156173539693900031E5L,
- 7.448928604824620999413120955705448117056E4L,
- 4.511583986730994111992253980546131408924E3L,
- 1.368902937933296323345610240009071254014E2L,
- /* 1.000000000000000000000000000000000000000E0 */
+ qq[6] =
+ {
+ 8.745588372054466262548908189000448124232E6L,
+ 3.746038264792471129367533128637019611485E6L,
+ 7.066358783162407559861156173539693900031E5L,
+ 7.448928604824620999413120955705448117056E4L,
+ 4.511583986730994111992253980546131408924E3L,
+ 1.368902937933296323345610240009071254014E2L,
+ /* 1.000000000000000000000000000000000000000E0 */
},
-/*
- * Coefficients for approximation to erf in [0.84375,1.25]
- */
-/* erf(x+1) = 0.845062911510467529296875 + pa(x)/qa(x)
- -0.15625 <= x <= +.25
- Peak relative error 8.5e-22 */
-pa[8] = {
- -1.076952146179812072156734957705102256059E0L,
- 1.884814957770385593365179835059971587220E2L,
- -5.339153975012804282890066622962070115606E1L,
- 4.435910679869176625928504532109635632618E1L,
- 1.683219516032328828278557309642929135179E1L,
- -2.360236618396952560064259585299045804293E0L,
- 1.852230047861891953244413872297940938041E0L,
- 9.394994446747752308256773044667843200719E-2L,
+ /*
+ * Coefficients for approximation to erf in [0.84375,1.25]
+ */
+ /* erf(x+1) = 0.845062911510467529296875 + pa(x)/qa(x)
+ -0.15625 <= x <= +.25
+ Peak relative error 8.5e-22 */
+ pa[8] =
+ {
+ -1.076952146179812072156734957705102256059E0L,
+ 1.884814957770385593365179835059971587220E2L,
+ -5.339153975012804282890066622962070115606E1L,
+ 4.435910679869176625928504532109635632618E1L,
+ 1.683219516032328828278557309642929135179E1L,
+ -2.360236618396952560064259585299045804293E0L,
+ 1.852230047861891953244413872297940938041E0L,
+ 9.394994446747752308256773044667843200719E-2L,
},
-qa[7] = {
- 4.559263722294508998149925774781887811255E2L,
- 3.289248982200800575749795055149780689738E2L,
- 2.846070965875643009598627918383314457912E2L,
- 1.398715859064535039433275722017479994465E2L,
- 6.060190733759793706299079050985358190726E1L,
- 2.078695677795422351040502569964299664233E1L,
- 4.641271134150895940966798357442234498546E0L,
- /* 1.000000000000000000000000000000000000000E0 */
+ qa[7] =
+ {
+ 4.559263722294508998149925774781887811255E2L,
+ 3.289248982200800575749795055149780689738E2L,
+ 2.846070965875643009598627918383314457912E2L,
+ 1.398715859064535039433275722017479994465E2L,
+ 6.060190733759793706299079050985358190726E1L,
+ 2.078695677795422351040502569964299664233E1L,
+ 4.641271134150895940966798357442234498546E0L,
+ /* 1.000000000000000000000000000000000000000E0 */
},
-/*
- * Coefficients for approximation to erfc in [1.25,1/0.35]
- */
-/* erfc(1/x) = x exp (-1/x^2 - 0.5625 + ra(x^2)/sa(x^2))
- 1/2.85711669921875 < 1/x < 1/1.25
- Peak relative error 3.1e-21 */
-ra[] = {
- 1.363566591833846324191000679620738857234E-1L,
- 1.018203167219873573808450274314658434507E1L,
- 1.862359362334248675526472871224778045594E2L,
- 1.411622588180721285284945138667933330348E3L,
- 5.088538459741511988784440103218342840478E3L,
- 8.928251553922176506858267311750789273656E3L,
- 7.264436000148052545243018622742770549982E3L,
- 2.387492459664548651671894725748959751119E3L,
- 2.220916652813908085449221282808458466556E2L,
+ /*
+ * Coefficients for approximation to erfc in [1.25,1/0.35]
+ */
+ /* erfc(1/x) = x exp (-1/x^2 - 0.5625 + ra(x^2)/sa(x^2))
+ 1/2.85711669921875 < 1/x < 1/1.25
+ Peak relative error 3.1e-21 */
+ ra[] =
+ {
+ 1.363566591833846324191000679620738857234E-1L,
+ 1.018203167219873573808450274314658434507E1L,
+ 1.862359362334248675526472871224778045594E2L,
+ 1.411622588180721285284945138667933330348E3L,
+ 5.088538459741511988784440103218342840478E3L,
+ 8.928251553922176506858267311750789273656E3L,
+ 7.264436000148052545243018622742770549982E3L,
+ 2.387492459664548651671894725748959751119E3L,
+ 2.220916652813908085449221282808458466556E2L,
},
-sa[] = {
- -1.382234625202480685182526402169222331847E1L,
- -3.315638835627950255832519203687435946482E2L,
- -2.949124863912936259747237164260785326692E3L,
- -1.246622099070875940506391433635999693661E4L,
- -2.673079795851665428695842853070996219632E4L,
- -2.880269786660559337358397106518918220991E4L,
- -1.450600228493968044773354186390390823713E4L,
- -2.874539731125893533960680525192064277816E3L,
- -1.402241261419067750237395034116942296027E2L,
- /* 1.000000000000000000000000000000000000000E0 */
+ sa[] =
+ {
+ -1.382234625202480685182526402169222331847E1L,
+ -3.315638835627950255832519203687435946482E2L,
+ -2.949124863912936259747237164260785326692E3L,
+ -1.246622099070875940506391433635999693661E4L,
+ -2.673079795851665428695842853070996219632E4L,
+ -2.880269786660559337358397106518918220991E4L,
+ -1.450600228493968044773354186390390823713E4L,
+ -2.874539731125893533960680525192064277816E3L,
+ -1.402241261419067750237395034116942296027E2L,
+ /* 1.000000000000000000000000000000000000000E0 */
},
-/*
- * Coefficients for approximation to erfc in [1/.35,107]
- */
-/* erfc(1/x) = x exp (-1/x^2 - 0.5625 + rb(x^2)/sb(x^2))
- 1/6.6666259765625 < 1/x < 1/2.85711669921875
- Peak relative error 4.2e-22 */
-rb[] = {
- -4.869587348270494309550558460786501252369E-5L,
- -4.030199390527997378549161722412466959403E-3L,
- -9.434425866377037610206443566288917589122E-2L,
- -9.319032754357658601200655161585539404155E-1L,
- -4.273788174307459947350256581445442062291E0L,
- -8.842289940696150508373541814064198259278E0L,
- -7.069215249419887403187988144752613025255E0L,
- -1.401228723639514787920274427443330704764E0L,
+ /*
+ * Coefficients for approximation to erfc in [1/.35,107]
+ */
+ /* erfc(1/x) = x exp (-1/x^2 - 0.5625 + rb(x^2)/sb(x^2))
+ 1/6.6666259765625 < 1/x < 1/2.85711669921875
+ Peak relative error 4.2e-22 */
+ rb[] =
+ {
+ -4.869587348270494309550558460786501252369E-5L,
+ -4.030199390527997378549161722412466959403E-3L,
+ -9.434425866377037610206443566288917589122E-2L,
+ -9.319032754357658601200655161585539404155E-1L,
+ -4.273788174307459947350256581445442062291E0L,
+ -8.842289940696150508373541814064198259278E0L,
+ -7.069215249419887403187988144752613025255E0L,
+ -1.401228723639514787920274427443330704764E0L,
},
-sb[] = {
- 4.936254964107175160157544545879293019085E-3L,
- 1.583457624037795744377163924895349412015E-1L,
- 1.850647991850328356622940552450636420484E0L,
- 9.927611557279019463768050710008450625415E0L,
- 2.531667257649436709617165336779212114570E1L,
- 2.869752886406743386458304052862814690045E1L,
- 1.182059497870819562441683560749192539345E1L,
- /* 1.000000000000000000000000000000000000000E0 */
+ sb[] =
+ {
+ 4.936254964107175160157544545879293019085E-3L,
+ 1.583457624037795744377163924895349412015E-1L,
+ 1.850647991850328356622940552450636420484E0L,
+ 9.927611557279019463768050710008450625415E0L,
+ 2.531667257649436709617165336779212114570E1L,
+ 2.869752886406743386458304052862814690045E1L,
+ 1.182059497870819562441683560749192539345E1L,
+ /* 1.000000000000000000000000000000000000000E0 */
},
-/* erfc(1/x) = x exp (-1/x^2 - 0.5625 + rc(x^2)/sc(x^2))
- 1/107 <= 1/x <= 1/6.6666259765625
- Peak relative error 1.1e-21 */
-rc[] = {
- -8.299617545269701963973537248996670806850E-5L,
- -6.243845685115818513578933902532056244108E-3L,
- -1.141667210620380223113693474478394397230E-1L,
- -7.521343797212024245375240432734425789409E-1L,
- -1.765321928311155824664963633786967602934E0L,
- -1.029403473103215800456761180695263439188E0L,
+ /* erfc(1/x) = x exp (-1/x^2 - 0.5625 + rc(x^2)/sc(x^2))
+ 1/107 <= 1/x <= 1/6.6666259765625
+ Peak relative error 1.1e-21 */
+ rc[] =
+ {
+ -8.299617545269701963973537248996670806850E-5L,
+ -6.243845685115818513578933902532056244108E-3L,
+ -1.141667210620380223113693474478394397230E-1L,
+ -7.521343797212024245375240432734425789409E-1L,
+ -1.765321928311155824664963633786967602934E0L,
+ -1.029403473103215800456761180695263439188E0L,
},
-sc[] = {
- 8.413244363014929493035952542677768808601E-3L,
- 2.065114333816877479753334599639158060979E-1L,
- 1.639064941530797583766364412782135680148E0L,
- 4.936788463787115555582319302981666347450E0L,
- 5.005177727208955487404729933261347679090E0L,
- /* 1.000000000000000000000000000000000000000E0 */
+ sc[] = {
+ 8.413244363014929493035952542677768808601E-3L,
+ 2.065114333816877479753334599639158060979E-1L,
+ 1.639064941530797583766364412782135680148E0L,
+ 4.936788463787115555582319302981666347450E0L,
+ 5.005177727208955487404729933261347679090E0L,
+ /* 1.000000000000000000000000000000000000000E0 */
};
-static long double erfc1(long double x)
-{
- long double s,P,Q;
+static long double erfc1(long double x) {
+ long double s, P, Q;
- s = fabsl(x) - 1;
- P = pa[0] + s * (pa[1] + s * (pa[2] +
- s * (pa[3] + s * (pa[4] + s * (pa[5] + s * (pa[6] + s * pa[7]))))));
- Q = qa[0] + s * (qa[1] + s * (qa[2] +
- s * (qa[3] + s * (qa[4] + s * (qa[5] + s * (qa[6] + s))))));
- return 1 - erx - P / Q;
+ s = fabsl(x) - 1;
+ P = pa[0] +
+ s * (pa[1] +
+ s * (pa[2] +
+ s * (pa[3] +
+ s * (pa[4] + s * (pa[5] + s * (pa[6] + s * pa[7]))))));
+ Q = qa[0] +
+ s * (qa[1] +
+ s * (qa[2] +
+ s * (qa[3] + s * (qa[4] + s * (qa[5] + s * (qa[6] + s))))));
+ return 1 - erx - P / Q;
}
-static long double erfc2(uint32_t ix, long double x)
-{
- union ldshape u;
- long double s,z,R,S;
+static long double erfc2(uint32_t ix, long double x) {
+ union ldshape u;
+ long double s, z, R, S;
- if (ix < 0x3fffa000) /* 0.84375 <= |x| < 1.25 */
- return erfc1(x);
+ if (ix < 0x3fffa000) /* 0.84375 <= |x| < 1.25 */
+ return erfc1(x);
- x = fabsl(x);
- s = 1 / (x * x);
- if (ix < 0x4000b6db) { /* 1.25 <= |x| < 2.857 ~ 1/.35 */
- R = ra[0] + s * (ra[1] + s * (ra[2] + s * (ra[3] + s * (ra[4] +
- s * (ra[5] + s * (ra[6] + s * (ra[7] + s * ra[8])))))));
- S = sa[0] + s * (sa[1] + s * (sa[2] + s * (sa[3] + s * (sa[4] +
- s * (sa[5] + s * (sa[6] + s * (sa[7] + s * (sa[8] + s))))))));
- } else if (ix < 0x4001d555) { /* 2.857 <= |x| < 6.6666259765625 */
- R = rb[0] + s * (rb[1] + s * (rb[2] + s * (rb[3] + s * (rb[4] +
- s * (rb[5] + s * (rb[6] + s * rb[7]))))));
- S = sb[0] + s * (sb[1] + s * (sb[2] + s * (sb[3] + s * (sb[4] +
- s * (sb[5] + s * (sb[6] + s))))));
- } else { /* 6.666 <= |x| < 107 (erfc only) */
- R = rc[0] + s * (rc[1] + s * (rc[2] + s * (rc[3] +
- s * (rc[4] + s * rc[5]))));
- S = sc[0] + s * (sc[1] + s * (sc[2] + s * (sc[3] +
- s * (sc[4] + s))));
- }
- u.f = x;
- u.i.m &= -1ULL << 40;
- z = u.f;
- return expl(-z*z - 0.5625) * expl((z - x) * (z + x) + R / S) / x;
+ x = fabsl(x);
+ s = 1 / (x * x);
+ if (ix < 0x4000b6db) { /* 1.25 <= |x| < 2.857 ~ 1/.35 */
+ R = ra[0] +
+ s * (ra[1] +
+ s * (ra[2] +
+ s * (ra[3] +
+ s * (ra[4] +
+ s * (ra[5] +
+ s * (ra[6] + s * (ra[7] + s * ra[8])))))));
+ S = sa[0] +
+ s * (sa[1] +
+ s * (sa[2] +
+ s * (sa[3] +
+ s * (sa[4] +
+ s * (sa[5] +
+ s * (sa[6] +
+ s * (sa[7] + s * (sa[8] + s))))))));
+ } else if (ix < 0x4001d555) { /* 2.857 <= |x| < 6.6666259765625 */
+ R = rb[0] +
+ s * (rb[1] +
+ s * (rb[2] +
+ s * (rb[3] +
+ s * (rb[4] + s * (rb[5] + s * (rb[6] + s * rb[7]))))));
+ S = sb[0] +
+ s * (sb[1] +
+ s * (sb[2] +
+ s * (sb[3] + s * (sb[4] + s * (sb[5] + s * (sb[6] + s))))));
+ } else { /* 6.666 <= |x| < 107 (erfc only) */
+ R = rc[0] +
+ s * (rc[1] + s * (rc[2] + s * (rc[3] + s * (rc[4] + s * rc[5]))));
+ S = sc[0] + s * (sc[1] + s * (sc[2] + s * (sc[3] + s * (sc[4] + s))));
+ }
+ u.f = x;
+ u.i.m &= -1ULL << 40;
+ z = u.f;
+ return expl(-z * z - 0.5625) * expl((z - x) * (z + x) + R / S) / x;
}
-long double erfl(long double x)
-{
- long double r, s, z, y;
- union ldshape u = {x};
- uint32_t ix = (u.i.se & 0x7fffU)<<16 | u.i.m>>48;
- int sign = u.i.se >> 15;
+long double erfl(long double x) {
+ long double r, s, z, y;
+ union ldshape u = {x};
+ uint32_t ix = (u.i.se & 0x7fffU) << 16 | u.i.m >> 48;
+ int sign = u.i.se >> 15;
- if (ix >= 0x7fff0000)
- /* erf(nan)=nan, erf(+-inf)=+-1 */
- return 1 - 2*sign + 1/x;
- if (ix < 0x3ffed800) { /* |x| < 0.84375 */
- if (ix < 0x3fde8000) { /* |x| < 2**-33 */
- return 0.125 * (8 * x + efx8 * x); /* avoid underflow */
- }
- z = x * x;
- r = pp[0] + z * (pp[1] +
- z * (pp[2] + z * (pp[3] + z * (pp[4] + z * pp[5]))));
- s = qq[0] + z * (qq[1] +
- z * (qq[2] + z * (qq[3] + z * (qq[4] + z * (qq[5] + z)))));
- y = r / s;
- return x + x * y;
- }
- if (ix < 0x4001d555) /* |x| < 6.6666259765625 */
- y = 1 - erfc2(ix,x);
- else
- y = 1 - 0x1p-16382L;
- return sign ? -y : y;
+ if (ix >= 0x7fff0000)
+ /* erf(nan)=nan, erf(+-inf)=+-1 */
+ return 1 - 2 * sign + 1 / x;
+ if (ix < 0x3ffed800) { /* |x| < 0.84375 */
+ if (ix < 0x3fde8000) { /* |x| < 2**-33 */
+ return 0.125 * (8 * x + efx8 * x); /* avoid underflow */
+ }
+ z = x * x;
+ r = pp[0] +
+ z * (pp[1] + z * (pp[2] + z * (pp[3] + z * (pp[4] + z * pp[5]))));
+ s = qq[0] +
+ z * (qq[1] + z * (qq[2] + z * (qq[3] + z * (qq[4] + z * (qq[5] + z)))));
+ y = r / s;
+ return x + x * y;
+ }
+ if (ix < 0x4001d555) /* |x| < 6.6666259765625 */
+ y = 1 - erfc2(ix, x);
+ else
+ y = 1 - 0x1p-16382L;
+ return sign ? -y : y;
}
-long double erfcl(long double x)
-{
- long double r, s, z, y;
- union ldshape u = {x};
- uint32_t ix = (u.i.se & 0x7fffU)<<16 | u.i.m>>48;
- int sign = u.i.se >> 15;
+long double erfcl(long double x) {
+ long double r, s, z, y;
+ union ldshape u = {x};
+ uint32_t ix = (u.i.se & 0x7fffU) << 16 | u.i.m >> 48;
+ int sign = u.i.se >> 15;
- if (ix >= 0x7fff0000)
- /* erfc(nan) = nan, erfc(+-inf) = 0,2 */
- return 2*sign + 1/x;
- if (ix < 0x3ffed800) { /* |x| < 0.84375 */
- if (ix < 0x3fbe0000) /* |x| < 2**-65 */
- return 1.0 - x;
- z = x * x;
- r = pp[0] + z * (pp[1] +
- z * (pp[2] + z * (pp[3] + z * (pp[4] + z * pp[5]))));
- s = qq[0] + z * (qq[1] +
- z * (qq[2] + z * (qq[3] + z * (qq[4] + z * (qq[5] + z)))));
- y = r / s;
- if (ix < 0x3ffd8000) /* x < 1/4 */
- return 1.0 - (x + x * y);
- return 0.5 - (x - 0.5 + x * y);
- }
- if (ix < 0x4005d600) /* |x| < 107 */
- return sign ? 2 - erfc2(ix,x) : erfc2(ix,x);
- y = 0x1p-16382L;
- return sign ? 2 - y : y*y;
+ if (ix >= 0x7fff0000)
+ /* erfc(nan) = nan, erfc(+-inf) = 0,2 */
+ return 2 * sign + 1 / x;
+ if (ix < 0x3ffed800) { /* |x| < 0.84375 */
+ if (ix < 0x3fbe0000) /* |x| < 2**-65 */
+ return 1.0 - x;
+ z = x * x;
+ r = pp[0] +
+ z * (pp[1] + z * (pp[2] + z * (pp[3] + z * (pp[4] + z * pp[5]))));
+ s = qq[0] +
+ z * (qq[1] + z * (qq[2] + z * (qq[3] + z * (qq[4] + z * (qq[5] + z)))));
+ y = r / s;
+ if (ix < 0x3ffd8000) /* x < 1/4 */
+ return 1.0 - (x + x * y);
+ return 0.5 - (x - 0.5 + x * y);
+ }
+ if (ix < 0x4005d600) /* |x| < 107 */
+ return sign ? 2 - erfc2(ix, x) : erfc2(ix, x);
+ y = 0x1p-16382L;
+ return sign ? 2 - y : y * y;
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
// TODO: broken implementation to make things compile
-long double erfl(long double x)
-{
- return erf(x);
+long double erfl(long double x) {
+ return erf(x);
}
-long double erfcl(long double x)
-{
- return erfc(x);
+long double erfcl(long double x) {
+ return erfc(x);
}
#endif
diff --git a/fusl/src/math/exp.c b/fusl/src/math/exp.c
index 9ea672f..d196944 100644
--- a/fusl/src/math/exp.c
+++ b/fusl/src/math/exp.c
@@ -67,68 +67,67 @@
#include "libm.h"
-static const double
-half[2] = {0.5,-0.5},
-ln2hi = 6.93147180369123816490e-01, /* 0x3fe62e42, 0xfee00000 */
-ln2lo = 1.90821492927058770002e-10, /* 0x3dea39ef, 0x35793c76 */
-invln2 = 1.44269504088896338700e+00, /* 0x3ff71547, 0x652b82fe */
-P1 = 1.66666666666666019037e-01, /* 0x3FC55555, 0x5555553E */
-P2 = -2.77777777770155933842e-03, /* 0xBF66C16C, 0x16BEBD93 */
-P3 = 6.61375632143793436117e-05, /* 0x3F11566A, 0xAF25DE2C */
-P4 = -1.65339022054652515390e-06, /* 0xBEBBBD41, 0xC5D26BF1 */
-P5 = 4.13813679705723846039e-08; /* 0x3E663769, 0x72BEA4D0 */
+static const double half[2] = {0.5, -0.5},
+ ln2hi =
+ 6.93147180369123816490e-01, /* 0x3fe62e42, 0xfee00000 */
+ ln2lo = 1.90821492927058770002e-10, /* 0x3dea39ef, 0x35793c76 */
+ invln2 = 1.44269504088896338700e+00, /* 0x3ff71547, 0x652b82fe */
+ P1 = 1.66666666666666019037e-01, /* 0x3FC55555, 0x5555553E */
+ P2 = -2.77777777770155933842e-03, /* 0xBF66C16C, 0x16BEBD93 */
+ P3 = 6.61375632143793436117e-05, /* 0x3F11566A, 0xAF25DE2C */
+ P4 = -1.65339022054652515390e-06, /* 0xBEBBBD41, 0xC5D26BF1 */
+ P5 = 4.13813679705723846039e-08; /* 0x3E663769, 0x72BEA4D0 */
-double exp(double x)
-{
- double_t hi, lo, c, xx, y;
- int k, sign;
- uint32_t hx;
+double exp(double x) {
+ double_t hi, lo, c, xx, y;
+ int k, sign;
+ uint32_t hx;
- GET_HIGH_WORD(hx, x);
- sign = hx>>31;
- hx &= 0x7fffffff; /* high word of |x| */
+ GET_HIGH_WORD(hx, x);
+ sign = hx >> 31;
+ hx &= 0x7fffffff; /* high word of |x| */
- /* special cases */
- if (hx >= 0x4086232b) { /* if |x| >= 708.39... */
- if (isnan(x))
- return x;
- if (x > 709.782712893383973096) {
- /* overflow if x!=inf */
- x *= 0x1p1023;
- return x;
- }
- if (x < -708.39641853226410622) {
- /* underflow if x!=-inf */
- FORCE_EVAL((float)(-0x1p-149/x));
- if (x < -745.13321910194110842)
- return 0;
- }
- }
+ /* special cases */
+ if (hx >= 0x4086232b) { /* if |x| >= 708.39... */
+ if (isnan(x))
+ return x;
+ if (x > 709.782712893383973096) {
+ /* overflow if x!=inf */
+ x *= 0x1p1023;
+ return x;
+ }
+ if (x < -708.39641853226410622) {
+ /* underflow if x!=-inf */
+ FORCE_EVAL((float)(-0x1p-149 / x));
+ if (x < -745.13321910194110842)
+ return 0;
+ }
+ }
- /* argument reduction */
- if (hx > 0x3fd62e42) { /* if |x| > 0.5 ln2 */
- if (hx >= 0x3ff0a2b2) /* if |x| >= 1.5 ln2 */
- k = (int)(invln2*x + half[sign]);
- else
- k = 1 - sign - sign;
- hi = x - k*ln2hi; /* k*ln2hi is exact here */
- lo = k*ln2lo;
- x = hi - lo;
- } else if (hx > 0x3e300000) { /* if |x| > 2**-28 */
- k = 0;
- hi = x;
- lo = 0;
- } else {
- /* inexact if x!=0 */
- FORCE_EVAL(0x1p1023 + x);
- return 1 + x;
- }
+ /* argument reduction */
+ if (hx > 0x3fd62e42) { /* if |x| > 0.5 ln2 */
+ if (hx >= 0x3ff0a2b2) /* if |x| >= 1.5 ln2 */
+ k = (int)(invln2 * x + half[sign]);
+ else
+ k = 1 - sign - sign;
+ hi = x - k * ln2hi; /* k*ln2hi is exact here */
+ lo = k * ln2lo;
+ x = hi - lo;
+ } else if (hx > 0x3e300000) { /* if |x| > 2**-28 */
+ k = 0;
+ hi = x;
+ lo = 0;
+ } else {
+ /* inexact if x!=0 */
+ FORCE_EVAL(0x1p1023 + x);
+ return 1 + x;
+ }
- /* x is now in primary range */
- xx = x*x;
- c = x - xx*(P1+xx*(P2+xx*(P3+xx*(P4+xx*P5))));
- y = 1 + (x*c/(2-c) - lo + hi);
- if (k == 0)
- return y;
- return scalbn(y, k);
+ /* x is now in primary range */
+ xx = x * x;
+ c = x - xx * (P1 + xx * (P2 + xx * (P3 + xx * (P4 + xx * P5))));
+ y = 1 + (x * c / (2 - c) - lo + hi);
+ if (k == 0)
+ return y;
+ return scalbn(y, k);
}
diff --git a/fusl/src/math/exp10.c b/fusl/src/math/exp10.c
index 9f5e3c2..eb926b5 100644
--- a/fusl/src/math/exp10.c
+++ b/fusl/src/math/exp10.c
@@ -3,23 +3,24 @@
#include <stdint.h>
#include "libc.h"
-double exp10(double x)
-{
- static const double p10[] = {
- 1e-15, 1e-14, 1e-13, 1e-12, 1e-11, 1e-10,
- 1e-9, 1e-8, 1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1,
- 1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
- 1e10, 1e11, 1e12, 1e13, 1e14, 1e15
- };
- double n, y = modf(x, &n);
- union {double f; uint64_t i;} u = {n};
- /* fabs(n) < 16 without raising invalid on nan */
- if ((u.i>>52 & 0x7ff) < 0x3ff+4) {
- if (!y) return p10[(int)n+15];
- y = exp2(3.32192809488736234787031942948939 * y);
- return y * p10[(int)n+15];
- }
- return pow(10.0, x);
+double exp10(double x) {
+ static const double p10[] = {
+ 1e-15, 1e-14, 1e-13, 1e-12, 1e-11, 1e-10, 1e-9, 1e-8, 1e-7, 1e-6, 1e-5,
+ 1e-4, 1e-3, 1e-2, 1e-1, 1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6,
+ 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15};
+ double n, y = modf(x, &n);
+ union {
+ double f;
+ uint64_t i;
+ } u = {n};
+ /* fabs(n) < 16 without raising invalid on nan */
+ if ((u.i >> 52 & 0x7ff) < 0x3ff + 4) {
+ if (!y)
+ return p10[(int)n + 15];
+ y = exp2(3.32192809488736234787031942948939 * y);
+ return y * p10[(int)n + 15];
+ }
+ return pow(10.0, x);
}
weak_alias(exp10, pow10);
diff --git a/fusl/src/math/exp10f.c b/fusl/src/math/exp10f.c
index 7a8d447..1a23b74 100644
--- a/fusl/src/math/exp10f.c
+++ b/fusl/src/math/exp10f.c
@@ -3,21 +3,23 @@
#include <stdint.h>
#include "libc.h"
-float exp10f(float x)
-{
- static const float p10[] = {
- 1e-7f, 1e-6f, 1e-5f, 1e-4f, 1e-3f, 1e-2f, 1e-1f,
- 1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7
- };
- float n, y = modff(x, &n);
- union {float f; uint32_t i;} u = {n};
- /* fabsf(n) < 8 without raising invalid on nan */
- if ((u.i>>23 & 0xff) < 0x7f+3) {
- if (!y) return p10[(int)n+7];
- y = exp2f(3.32192809488736234787031942948939f * y);
- return y * p10[(int)n+7];
- }
- return exp2(3.32192809488736234787031942948939 * x);
+float exp10f(float x) {
+ static const float p10[] = {1e-7f, 1e-6f, 1e-5f, 1e-4f, 1e-3f,
+ 1e-2f, 1e-1f, 1, 1e1, 1e2,
+ 1e3, 1e4, 1e5, 1e6, 1e7};
+ float n, y = modff(x, &n);
+ union {
+ float f;
+ uint32_t i;
+ } u = {n};
+ /* fabsf(n) < 8 without raising invalid on nan */
+ if ((u.i >> 23 & 0xff) < 0x7f + 3) {
+ if (!y)
+ return p10[(int)n + 7];
+ y = exp2f(3.32192809488736234787031942948939f * y);
+ return y * p10[(int)n + 7];
+ }
+ return exp2(3.32192809488736234787031942948939 * x);
}
weak_alias(exp10f, pow10f);
diff --git a/fusl/src/math/exp10l.c b/fusl/src/math/exp10l.c
index b758ebf..7805c38 100644
--- a/fusl/src/math/exp10l.c
+++ b/fusl/src/math/exp10l.c
@@ -5,28 +5,26 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double exp10l(long double x)
-{
- return exp10(x);
+long double exp10l(long double x) {
+ return exp10(x);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-long double exp10l(long double x)
-{
- static const long double p10[] = {
- 1e-15L, 1e-14L, 1e-13L, 1e-12L, 1e-11L, 1e-10L,
- 1e-9L, 1e-8L, 1e-7L, 1e-6L, 1e-5L, 1e-4L, 1e-3L, 1e-2L, 1e-1L,
- 1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
- 1e10, 1e11, 1e12, 1e13, 1e14, 1e15
- };
- long double n, y = modfl(x, &n);
- union ldshape u = {n};
- /* fabsl(n) < 16 without raising invalid on nan */
- if ((u.i.se & 0x7fff) < 0x3fff+4) {
- if (!y) return p10[(int)n+15];
- y = exp2l(3.32192809488736234787031942948939L * y);
- return y * p10[(int)n+15];
- }
- return powl(10.0, x);
+long double exp10l(long double x) {
+ static const long double p10[] = {
+ 1e-15L, 1e-14L, 1e-13L, 1e-12L, 1e-11L, 1e-10L, 1e-9L, 1e-8L,
+ 1e-7L, 1e-6L, 1e-5L, 1e-4L, 1e-3L, 1e-2L, 1e-1L, 1,
+ 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8,
+ 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15};
+ long double n, y = modfl(x, &n);
+ union ldshape u = {n};
+ /* fabsl(n) < 16 without raising invalid on nan */
+ if ((u.i.se & 0x7fff) < 0x3fff + 4) {
+ if (!y)
+ return p10[(int)n + 15];
+ y = exp2l(3.32192809488736234787031942948939L * y);
+ return y * p10[(int)n + 15];
+ }
+ return powl(10.0, x);
}
#endif
diff --git a/fusl/src/math/exp2.c b/fusl/src/math/exp2.c
index e14adba..26397bf 100644
--- a/fusl/src/math/exp2.c
+++ b/fusl/src/math/exp2.c
@@ -29,272 +29,140 @@
#define TBLSIZE 256
-static const double
-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 const double 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 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(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,
};
/*
@@ -328,48 +196,53 @@
* 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_t r, t, z;
- uint32_t ix, i0;
- union {double f; uint64_t i;} u = {x};
- union {uint32_t u; int32_t i;} k;
+double exp2(double x) {
+ double_t r, t, z;
+ uint32_t ix, i0;
+ union {
+ double f;
+ uint64_t i;
+ } u = {x};
+ union {
+ uint32_t u;
+ int32_t i;
+ } k;
- /* Filter out exceptional cases. */
- ix = u.i>>32 & 0x7fffffff;
- if (ix >= 0x408ff000) { /* |x| >= 1022 or nan */
- if (ix >= 0x40900000 && u.i>>63 == 0) { /* x >= 1024 or nan */
- /* overflow */
- x *= 0x1p1023;
- return x;
- }
- if (ix >= 0x7ff00000) /* -inf or -nan */
- return -1/x;
- if (u.i>>63) { /* x <= -1022 */
- /* underflow */
- if (x <= -1075 || x - 0x1p52 + 0x1p52 != x)
- FORCE_EVAL((float)(-0x1p-149/x));
- if (x <= -1075)
- return 0;
- }
- } else if (ix < 0x3c900000) { /* |x| < 0x1p-54 */
- return 1.0 + x;
- }
+ /* Filter out exceptional cases. */
+ ix = u.i >> 32 & 0x7fffffff;
+ if (ix >= 0x408ff000) { /* |x| >= 1022 or nan */
+ if (ix >= 0x40900000 && u.i >> 63 == 0) { /* x >= 1024 or nan */
+ /* overflow */
+ x *= 0x1p1023;
+ return x;
+ }
+ if (ix >= 0x7ff00000) /* -inf or -nan */
+ return -1 / x;
+ if (u.i >> 63) { /* x <= -1022 */
+ /* underflow */
+ if (x <= -1075 || x - 0x1p52 + 0x1p52 != x)
+ FORCE_EVAL((float)(-0x1p-149 / x));
+ if (x <= -1075)
+ return 0;
+ }
+ } else if (ix < 0x3c900000) { /* |x| < 0x1p-54 */
+ return 1.0 + x;
+ }
- /* Reduce x, computing z, i0, and k. */
- u.f = x + redux;
- i0 = u.i;
- i0 += TBLSIZE / 2;
- k.u = i0 / TBLSIZE * TBLSIZE;
- k.i /= TBLSIZE;
- i0 %= TBLSIZE;
- u.f -= redux;
- z = x - u.f;
+ /* Reduce x, computing z, i0, and k. */
+ u.f = x + redux;
+ i0 = u.i;
+ i0 += TBLSIZE / 2;
+ k.u = i0 / TBLSIZE * TBLSIZE;
+ k.i /= TBLSIZE;
+ i0 %= TBLSIZE;
+ u.f -= redux;
+ z = x - u.f;
- /* Compute r = exp2(y) = exp2t[i0] * p(z - eps[i]). */
- t = tbl[2*i0]; /* exp2t[i0] */
- z -= tbl[2*i0 + 1]; /* eps[i0] */
- r = t + t * z * (P1 + z * (P2 + z * (P3 + z * (P4 + z * P5))));
+ /* Compute r = exp2(y) = exp2t[i0] * p(z - eps[i]). */
+ t = tbl[2 * i0]; /* exp2t[i0] */
+ z -= tbl[2 * i0 + 1]; /* eps[i0] */
+ r = t + t * z * (P1 + z * (P2 + z * (P3 + z * (P4 + z * P5))));
- return scalbn(r, k.i);
+ return scalbn(r, k.i);
}
diff --git a/fusl/src/math/exp2f.c b/fusl/src/math/exp2f.c
index cf6126e..e88fa69 100644
--- a/fusl/src/math/exp2f.c
+++ b/fusl/src/math/exp2f.c
@@ -29,30 +29,17 @@
#define TBLSIZE 16
-static const float
-redux = 0x1.8p23f / TBLSIZE,
-P1 = 0x1.62e430p-1f,
-P2 = 0x1.ebfbe0p-3f,
-P3 = 0x1.c6b348p-5f,
-P4 = 0x1.3b2c9cp-7f;
+static const float redux = 0x1.8p23f / TBLSIZE, P1 = 0x1.62e430p-1f,
+ P2 = 0x1.ebfbe0p-3f, P3 = 0x1.c6b348p-5f,
+ P4 = 0x1.3b2c9cp-7f;
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,
+ 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,
};
/*
@@ -81,44 +68,49 @@
* 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_t t, r, z;
- union {float f; uint32_t i;} u = {x};
- union {double f; uint64_t i;} uk;
- uint32_t ix, i0, k;
+float exp2f(float x) {
+ double_t t, r, z;
+ union {
+ float f;
+ uint32_t i;
+ } u = {x};
+ union {
+ double f;
+ uint64_t i;
+ } uk;
+ uint32_t ix, i0, k;
- /* Filter out exceptional cases. */
- ix = u.i & 0x7fffffff;
- if (ix > 0x42fc0000) { /* |x| > 126 */
- if (u.i >= 0x43000000 && u.i < 0x80000000) { /* x >= 128 */
- x *= 0x1p127f;
- return x;
- }
- if (u.i >= 0x80000000) { /* x < -126 */
- if (u.i >= 0xc3160000 || (u.i & 0x0000ffff))
- FORCE_EVAL(-0x1p-149f/x);
- if (u.i >= 0xc3160000) /* x <= -150 */
- return 0;
- }
- } else if (ix <= 0x33000000) { /* |x| <= 0x1p-25 */
- return 1.0f + x;
- }
+ /* Filter out exceptional cases. */
+ ix = u.i & 0x7fffffff;
+ if (ix > 0x42fc0000) { /* |x| > 126 */
+ if (u.i >= 0x43000000 && u.i < 0x80000000) { /* x >= 128 */
+ x *= 0x1p127f;
+ return x;
+ }
+ if (u.i >= 0x80000000) { /* x < -126 */
+ if (u.i >= 0xc3160000 || (u.i & 0x0000ffff))
+ FORCE_EVAL(-0x1p-149f / x);
+ if (u.i >= 0xc3160000) /* x <= -150 */
+ return 0;
+ }
+ } else if (ix <= 0x33000000) { /* |x| <= 0x1p-25 */
+ return 1.0f + x;
+ }
- /* Reduce x, computing z, i0, and k. */
- u.f = x + redux;
- i0 = u.i;
- i0 += TBLSIZE / 2;
- k = i0 / TBLSIZE;
- uk.i = (uint64_t)(0x3ff + k)<<52;
- i0 &= TBLSIZE - 1;
- u.f -= redux;
- z = x - u.f;
- /* Compute r = exp2(y) = exp2ft[i0] * p(z). */
- r = exp2ft[i0];
- t = r * z;
- r = r + t * (P1 + z * P2) + t * (z * z) * (P3 + z * P4);
+ /* Reduce x, computing z, i0, and k. */
+ u.f = x + redux;
+ i0 = u.i;
+ i0 += TBLSIZE / 2;
+ k = i0 / TBLSIZE;
+ uk.i = (uint64_t)(0x3ff + k) << 52;
+ i0 &= TBLSIZE - 1;
+ u.f -= redux;
+ z = x - u.f;
+ /* Compute r = exp2(y) = exp2ft[i0] * p(z). */
+ r = exp2ft[i0];
+ t = r * z;
+ r = r + t * (P1 + z * P2) + t * (z * z) * (P3 + z * P4);
- /* Scale by 2**k */
- return r * uk.f;
+ /* Scale by 2**k */
+ return r * uk.f;
}
diff --git a/fusl/src/math/exp2l.c b/fusl/src/math/exp2l.c
index 3565c1e..0528a47 100644
--- a/fusl/src/math/exp2l.c
+++ b/fusl/src/math/exp2l.c
@@ -1,4 +1,5 @@
-/* origin: FreeBSD /usr/src/lib/msun/ld80/s_exp2l.c and /usr/src/lib/msun/ld128/s_exp2l.c */
+/* origin: FreeBSD /usr/src/lib/msun/ld80/s_exp2l.c and
+ * /usr/src/lib/msun/ld128/s_exp2l.c */
/*-
* Copyright (c) 2005-2008 David Schultz <das@FreeBSD.ORG>
* All rights reserved.
@@ -28,152 +29,275 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double exp2l(long double x)
-{
- return exp2(x);
+long double exp2l(long double x) {
+ return exp2(x);
}
#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
#define TBLBITS 7
#define TBLSIZE (1 << TBLBITS)
-static const double
-redux = 0x1.8p63 / TBLSIZE,
-P1 = 0x1.62e42fefa39efp-1,
-P2 = 0x1.ebfbdff82c58fp-3,
-P3 = 0x1.c6b08d7049fap-5,
-P4 = 0x1.3b2ab6fba4da5p-7,
-P5 = 0x1.5d8804780a736p-10,
-P6 = 0x1.430918835e33dp-13;
+static const double redux = 0x1.8p63 / TBLSIZE, P1 = 0x1.62e42fefa39efp-1,
+ P2 = 0x1.ebfbdff82c58fp-3, P3 = 0x1.c6b08d7049fap-5,
+ P4 = 0x1.3b2ab6fba4da5p-7, P5 = 0x1.5d8804780a736p-10,
+ P6 = 0x1.430918835e33dp-13;
static const double tbl[TBLSIZE * 2] = {
- 0x1.6a09e667f3bcdp-1, -0x1.bdd3413b2648p-55,
- 0x1.6c012750bdabfp-1, -0x1.2895667ff0cp-57,
- 0x1.6dfb23c651a2fp-1, -0x1.bbe3a683c88p-58,
- 0x1.6ff7df9519484p-1, -0x1.83c0f25860fp-56,
- 0x1.71f75e8ec5f74p-1, -0x1.16e4786887bp-56,
- 0x1.73f9a48a58174p-1, -0x1.0a8d96c65d5p-55,
- 0x1.75feb564267c9p-1, -0x1.0245957316ep-55,
- 0x1.780694fde5d3fp-1, 0x1.866b80a0216p-55,
- 0x1.7a11473eb0187p-1, -0x1.41577ee0499p-56,
- 0x1.7c1ed0130c132p-1, 0x1.f124cd1164ep-55,
- 0x1.7e2f336cf4e62p-1, 0x1.05d02ba157ap-57,
- 0x1.80427543e1a12p-1, -0x1.27c86626d97p-55,
- 0x1.82589994cce13p-1, -0x1.d4c1dd41533p-55,
- 0x1.8471a4623c7adp-1, -0x1.8d684a341cep-56,
- 0x1.868d99b4492edp-1, -0x1.fc6f89bd4f68p-55,
- 0x1.88ac7d98a6699p-1, 0x1.994c2f37cb5p-55,
- 0x1.8ace5422aa0dbp-1, 0x1.6e9f156864bp-55,
- 0x1.8cf3216b5448cp-1, -0x1.0d55e32e9e4p-57,
- 0x1.8f1ae99157736p-1, 0x1.5cc13a2e397p-56,
- 0x1.9145b0b91ffc6p-1, -0x1.dd6792e5825p-55,
- 0x1.93737b0cdc5e5p-1, -0x1.75fc781b58p-58,
- 0x1.95a44cbc8520fp-1, -0x1.64b7c96a5fp-57,
- 0x1.97d829fde4e5p-1, -0x1.d185b7c1b86p-55,
- 0x1.9a0f170ca07bap-1, -0x1.173bd91cee6p-55,
- 0x1.9c49182a3f09p-1, 0x1.c7c46b071f2p-57,
- 0x1.9e86319e32323p-1, 0x1.824ca78e64cp-57,
- 0x1.a0c667b5de565p-1, -0x1.359495d1cd5p-55,
- 0x1.a309bec4a2d33p-1, 0x1.6305c7ddc368p-55,
- 0x1.a5503b23e255dp-1, -0x1.d2f6edb8d42p-55,
- 0x1.a799e1330b358p-1, 0x1.bcb7ecac564p-55,
- 0x1.a9e6b5579fdbfp-1, 0x1.0fac90ef7fdp-55,
- 0x1.ac36bbfd3f37ap-1, -0x1.f9234cae76dp-56,
- 0x1.ae89f995ad3adp-1, 0x1.7a1cd345dcc8p-55,
- 0x1.b0e07298db666p-1, -0x1.bdef54c80e4p-55,
- 0x1.b33a2b84f15fbp-1, -0x1.2805e3084d8p-58,
- 0x1.b59728de5593ap-1, -0x1.c71dfbbba6ep-55,
- 0x1.b7f76f2fb5e47p-1, -0x1.5584f7e54acp-57,
- 0x1.ba5b030a1064ap-1, -0x1.efcd30e5429p-55,
- 0x1.bcc1e904bc1d2p-1, 0x1.23dd07a2d9fp-56,
- 0x1.bf2c25bd71e09p-1, -0x1.efdca3f6b9c8p-55,
- 0x1.c199bdd85529cp-1, 0x1.11065895049p-56,
- 0x1.c40ab5fffd07ap-1, 0x1.b4537e083c6p-55,
- 0x1.c67f12e57d14bp-1, 0x1.2884dff483c8p-55,
- 0x1.c8f6d9406e7b5p-1, 0x1.1acbc48805cp-57,
- 0x1.cb720dcef9069p-1, 0x1.503cbd1e94ap-57,
- 0x1.cdf0b555dc3fap-1, -0x1.dd83b53829dp-56,
- 0x1.d072d4a07897cp-1, -0x1.cbc3743797a8p-55,
- 0x1.d2f87080d89f2p-1, -0x1.d487b719d858p-55,
- 0x1.d5818dcfba487p-1, 0x1.2ed02d75b37p-56,
- 0x1.d80e316c98398p-1, -0x1.11ec18bedep-55,
- 0x1.da9e603db3285p-1, 0x1.c2300696db5p-55,
- 0x1.dd321f301b46p-1, 0x1.2da5778f019p-55,
- 0x1.dfc97337b9b5fp-1, -0x1.1a5cd4f184b8p-55,
- 0x1.e264614f5a129p-1, -0x1.7b627817a148p-55,
- 0x1.e502ee78b3ff6p-1, 0x1.39e8980a9cdp-56,
- 0x1.e7a51fbc74c83p-1, 0x1.2d522ca0c8ep-55,
- 0x1.ea4afa2a490dap-1, -0x1.e9c23179c288p-55,
- 0x1.ecf482d8e67f1p-1, -0x1.c93f3b411ad8p-55,
- 0x1.efa1bee615a27p-1, 0x1.dc7f486a4b68p-55,
- 0x1.f252b376bba97p-1, 0x1.3a1a5bf0d8e8p-55,
- 0x1.f50765b6e454p-1, 0x1.9d3e12dd8a18p-55,
- 0x1.f7bfdad9cbe14p-1, -0x1.dbb12d00635p-55,
- 0x1.fa7c1819e90d8p-1, 0x1.74853f3a593p-56,
- 0x1.fd3c22b8f71f1p-1, 0x1.2eb74966578p-58,
- 0x1p+0, 0x0p+0,
- 0x1.0163da9fb3335p+0, 0x1.b61299ab8cd8p-54,
- 0x1.02c9a3e778061p+0, -0x1.19083535b08p-56,
- 0x1.04315e86e7f85p+0, -0x1.0a31c1977c98p-54,
- 0x1.059b0d3158574p+0, 0x1.d73e2a475b4p-55,
- 0x1.0706b29ddf6dep+0, -0x1.c91dfe2b13cp-55,
- 0x1.0874518759bc8p+0, 0x1.186be4bb284p-57,
- 0x1.09e3ecac6f383p+0, 0x1.14878183161p-54,
- 0x1.0b5586cf9890fp+0, 0x1.8a62e4adc61p-54,
- 0x1.0cc922b7247f7p+0, 0x1.01edc16e24f8p-54,
- 0x1.0e3ec32d3d1a2p+0, 0x1.03a1727c58p-59,
- 0x1.0fb66affed31bp+0, -0x1.b9bedc44ebcp-57,
- 0x1.11301d0125b51p+0, -0x1.6c51039449bp-54,
- 0x1.12abdc06c31ccp+0, -0x1.1b514b36ca8p-58,
- 0x1.1429aaea92dep+0, -0x1.32fbf9af1368p-54,
- 0x1.15a98c8a58e51p+0, 0x1.2406ab9eeabp-55,
- 0x1.172b83c7d517bp+0, -0x1.19041b9d78ap-55,
- 0x1.18af9388c8deap+0, -0x1.11023d1970f8p-54,
- 0x1.1a35beb6fcb75p+0, 0x1.e5b4c7b4969p-55,
- 0x1.1bbe084045cd4p+0, -0x1.95386352ef6p-54,
- 0x1.1d4873168b9aap+0, 0x1.e016e00a264p-54,
- 0x1.1ed5022fcd91dp+0, -0x1.1df98027bb78p-54,
- 0x1.2063b88628cd6p+0, 0x1.dc775814a85p-55,
- 0x1.21f49917ddc96p+0, 0x1.2a97e9494a6p-55,
- 0x1.2387a6e756238p+0, 0x1.9b07eb6c7058p-54,
- 0x1.251ce4fb2a63fp+0, 0x1.ac155bef4f5p-55,
- 0x1.26b4565e27cddp+0, 0x1.2bd339940eap-55,
- 0x1.284dfe1f56381p+0, -0x1.a4c3a8c3f0d8p-54,
- 0x1.29e9df51fdee1p+0, 0x1.612e8afad12p-55,
- 0x1.2b87fd0dad99p+0, -0x1.10adcd6382p-59,
- 0x1.2d285a6e4030bp+0, 0x1.0024754db42p-54,
- 0x1.2ecafa93e2f56p+0, 0x1.1ca0f45d524p-56,
- 0x1.306fe0a31b715p+0, 0x1.6f46ad23183p-55,
- 0x1.32170fc4cd831p+0, 0x1.a9ce78e1804p-55,
- 0x1.33c08b26416ffp+0, 0x1.327218436598p-54,
- 0x1.356c55f929ff1p+0, -0x1.b5cee5c4e46p-55,
- 0x1.371a7373aa9cbp+0, -0x1.63aeabf42ebp-54,
- 0x1.38cae6d05d866p+0, -0x1.e958d3c99048p-54,
- 0x1.3a7db34e59ff7p+0, -0x1.5e436d661f6p-56,
- 0x1.3c32dc313a8e5p+0, -0x1.efff8375d2ap-54,
- 0x1.3dea64c123422p+0, 0x1.ada0911f09fp-55,
- 0x1.3fa4504ac801cp+0, -0x1.7d023f956fap-54,
- 0x1.4160a21f72e2ap+0, -0x1.ef3691c309p-58,
- 0x1.431f5d950a897p+0, -0x1.1c7dde35f7ap-55,
- 0x1.44e086061892dp+0, 0x1.89b7a04ef8p-59,
- 0x1.46a41ed1d0057p+0, 0x1.c944bd1648a8p-54,
- 0x1.486a2b5c13cdp+0, 0x1.3c1a3b69062p-56,
- 0x1.4a32af0d7d3dep+0, 0x1.9cb62f3d1be8p-54,
- 0x1.4bfdad5362a27p+0, 0x1.d4397afec42p-56,
- 0x1.4dcb299fddd0dp+0, 0x1.8ecdbbc6a78p-54,
- 0x1.4f9b2769d2ca7p+0, -0x1.4b309d25958p-54,
- 0x1.516daa2cf6642p+0, -0x1.f768569bd94p-55,
- 0x1.5342b569d4f82p+0, -0x1.07abe1db13dp-55,
- 0x1.551a4ca5d920fp+0, -0x1.d689cefede6p-55,
- 0x1.56f4736b527dap+0, 0x1.9bb2c011d938p-54,
- 0x1.58d12d497c7fdp+0, 0x1.295e15b9a1ep-55,
- 0x1.5ab07dd485429p+0, 0x1.6324c0546478p-54,
- 0x1.5c9268a5946b7p+0, 0x1.c4b1b81698p-60,
- 0x1.5e76f15ad2148p+0, 0x1.ba6f93080e68p-54,
- 0x1.605e1b976dc09p+0, -0x1.3e2429b56de8p-54,
- 0x1.6247eb03a5585p+0, -0x1.383c17e40b48p-54,
- 0x1.6434634ccc32p+0, -0x1.c483c759d89p-55,
- 0x1.6623882552225p+0, -0x1.bb60987591cp-54,
- 0x1.68155d44ca973p+0, 0x1.038ae44f74p-57,
+ 0x1.6a09e667f3bcdp-1,
+ -0x1.bdd3413b2648p-55,
+ 0x1.6c012750bdabfp-1,
+ -0x1.2895667ff0cp-57,
+ 0x1.6dfb23c651a2fp-1,
+ -0x1.bbe3a683c88p-58,
+ 0x1.6ff7df9519484p-1,
+ -0x1.83c0f25860fp-56,
+ 0x1.71f75e8ec5f74p-1,
+ -0x1.16e4786887bp-56,
+ 0x1.73f9a48a58174p-1,
+ -0x1.0a8d96c65d5p-55,
+ 0x1.75feb564267c9p-1,
+ -0x1.0245957316ep-55,
+ 0x1.780694fde5d3fp-1,
+ 0x1.866b80a0216p-55,
+ 0x1.7a11473eb0187p-1,
+ -0x1.41577ee0499p-56,
+ 0x1.7c1ed0130c132p-1,
+ 0x1.f124cd1164ep-55,
+ 0x1.7e2f336cf4e62p-1,
+ 0x1.05d02ba157ap-57,
+ 0x1.80427543e1a12p-1,
+ -0x1.27c86626d97p-55,
+ 0x1.82589994cce13p-1,
+ -0x1.d4c1dd41533p-55,
+ 0x1.8471a4623c7adp-1,
+ -0x1.8d684a341cep-56,
+ 0x1.868d99b4492edp-1,
+ -0x1.fc6f89bd4f68p-55,
+ 0x1.88ac7d98a6699p-1,
+ 0x1.994c2f37cb5p-55,
+ 0x1.8ace5422aa0dbp-1,
+ 0x1.6e9f156864bp-55,
+ 0x1.8cf3216b5448cp-1,
+ -0x1.0d55e32e9e4p-57,
+ 0x1.8f1ae99157736p-1,
+ 0x1.5cc13a2e397p-56,
+ 0x1.9145b0b91ffc6p-1,
+ -0x1.dd6792e5825p-55,
+ 0x1.93737b0cdc5e5p-1,
+ -0x1.75fc781b58p-58,
+ 0x1.95a44cbc8520fp-1,
+ -0x1.64b7c96a5fp-57,
+ 0x1.97d829fde4e5p-1,
+ -0x1.d185b7c1b86p-55,
+ 0x1.9a0f170ca07bap-1,
+ -0x1.173bd91cee6p-55,
+ 0x1.9c49182a3f09p-1,
+ 0x1.c7c46b071f2p-57,
+ 0x1.9e86319e32323p-1,
+ 0x1.824ca78e64cp-57,
+ 0x1.a0c667b5de565p-1,
+ -0x1.359495d1cd5p-55,
+ 0x1.a309bec4a2d33p-1,
+ 0x1.6305c7ddc368p-55,
+ 0x1.a5503b23e255dp-1,
+ -0x1.d2f6edb8d42p-55,
+ 0x1.a799e1330b358p-1,
+ 0x1.bcb7ecac564p-55,
+ 0x1.a9e6b5579fdbfp-1,
+ 0x1.0fac90ef7fdp-55,
+ 0x1.ac36bbfd3f37ap-1,
+ -0x1.f9234cae76dp-56,
+ 0x1.ae89f995ad3adp-1,
+ 0x1.7a1cd345dcc8p-55,
+ 0x1.b0e07298db666p-1,
+ -0x1.bdef54c80e4p-55,
+ 0x1.b33a2b84f15fbp-1,
+ -0x1.2805e3084d8p-58,
+ 0x1.b59728de5593ap-1,
+ -0x1.c71dfbbba6ep-55,
+ 0x1.b7f76f2fb5e47p-1,
+ -0x1.5584f7e54acp-57,
+ 0x1.ba5b030a1064ap-1,
+ -0x1.efcd30e5429p-55,
+ 0x1.bcc1e904bc1d2p-1,
+ 0x1.23dd07a2d9fp-56,
+ 0x1.bf2c25bd71e09p-1,
+ -0x1.efdca3f6b9c8p-55,
+ 0x1.c199bdd85529cp-1,
+ 0x1.11065895049p-56,
+ 0x1.c40ab5fffd07ap-1,
+ 0x1.b4537e083c6p-55,
+ 0x1.c67f12e57d14bp-1,
+ 0x1.2884dff483c8p-55,
+ 0x1.c8f6d9406e7b5p-1,
+ 0x1.1acbc48805cp-57,
+ 0x1.cb720dcef9069p-1,
+ 0x1.503cbd1e94ap-57,
+ 0x1.cdf0b555dc3fap-1,
+ -0x1.dd83b53829dp-56,
+ 0x1.d072d4a07897cp-1,
+ -0x1.cbc3743797a8p-55,
+ 0x1.d2f87080d89f2p-1,
+ -0x1.d487b719d858p-55,
+ 0x1.d5818dcfba487p-1,
+ 0x1.2ed02d75b37p-56,
+ 0x1.d80e316c98398p-1,
+ -0x1.11ec18bedep-55,
+ 0x1.da9e603db3285p-1,
+ 0x1.c2300696db5p-55,
+ 0x1.dd321f301b46p-1,
+ 0x1.2da5778f019p-55,
+ 0x1.dfc97337b9b5fp-1,
+ -0x1.1a5cd4f184b8p-55,
+ 0x1.e264614f5a129p-1,
+ -0x1.7b627817a148p-55,
+ 0x1.e502ee78b3ff6p-1,
+ 0x1.39e8980a9cdp-56,
+ 0x1.e7a51fbc74c83p-1,
+ 0x1.2d522ca0c8ep-55,
+ 0x1.ea4afa2a490dap-1,
+ -0x1.e9c23179c288p-55,
+ 0x1.ecf482d8e67f1p-1,
+ -0x1.c93f3b411ad8p-55,
+ 0x1.efa1bee615a27p-1,
+ 0x1.dc7f486a4b68p-55,
+ 0x1.f252b376bba97p-1,
+ 0x1.3a1a5bf0d8e8p-55,
+ 0x1.f50765b6e454p-1,
+ 0x1.9d3e12dd8a18p-55,
+ 0x1.f7bfdad9cbe14p-1,
+ -0x1.dbb12d00635p-55,
+ 0x1.fa7c1819e90d8p-1,
+ 0x1.74853f3a593p-56,
+ 0x1.fd3c22b8f71f1p-1,
+ 0x1.2eb74966578p-58,
+ 0x1p+0,
+ 0x0p+0,
+ 0x1.0163da9fb3335p+0,
+ 0x1.b61299ab8cd8p-54,
+ 0x1.02c9a3e778061p+0,
+ -0x1.19083535b08p-56,
+ 0x1.04315e86e7f85p+0,
+ -0x1.0a31c1977c98p-54,
+ 0x1.059b0d3158574p+0,
+ 0x1.d73e2a475b4p-55,
+ 0x1.0706b29ddf6dep+0,
+ -0x1.c91dfe2b13cp-55,
+ 0x1.0874518759bc8p+0,
+ 0x1.186be4bb284p-57,
+ 0x1.09e3ecac6f383p+0,
+ 0x1.14878183161p-54,
+ 0x1.0b5586cf9890fp+0,
+ 0x1.8a62e4adc61p-54,
+ 0x1.0cc922b7247f7p+0,
+ 0x1.01edc16e24f8p-54,
+ 0x1.0e3ec32d3d1a2p+0,
+ 0x1.03a1727c58p-59,
+ 0x1.0fb66affed31bp+0,
+ -0x1.b9bedc44ebcp-57,
+ 0x1.11301d0125b51p+0,
+ -0x1.6c51039449bp-54,
+ 0x1.12abdc06c31ccp+0,
+ -0x1.1b514b36ca8p-58,
+ 0x1.1429aaea92dep+0,
+ -0x1.32fbf9af1368p-54,
+ 0x1.15a98c8a58e51p+0,
+ 0x1.2406ab9eeabp-55,
+ 0x1.172b83c7d517bp+0,
+ -0x1.19041b9d78ap-55,
+ 0x1.18af9388c8deap+0,
+ -0x1.11023d1970f8p-54,
+ 0x1.1a35beb6fcb75p+0,
+ 0x1.e5b4c7b4969p-55,
+ 0x1.1bbe084045cd4p+0,
+ -0x1.95386352ef6p-54,
+ 0x1.1d4873168b9aap+0,
+ 0x1.e016e00a264p-54,
+ 0x1.1ed5022fcd91dp+0,
+ -0x1.1df98027bb78p-54,
+ 0x1.2063b88628cd6p+0,
+ 0x1.dc775814a85p-55,
+ 0x1.21f49917ddc96p+0,
+ 0x1.2a97e9494a6p-55,
+ 0x1.2387a6e756238p+0,
+ 0x1.9b07eb6c7058p-54,
+ 0x1.251ce4fb2a63fp+0,
+ 0x1.ac155bef4f5p-55,
+ 0x1.26b4565e27cddp+0,
+ 0x1.2bd339940eap-55,
+ 0x1.284dfe1f56381p+0,
+ -0x1.a4c3a8c3f0d8p-54,
+ 0x1.29e9df51fdee1p+0,
+ 0x1.612e8afad12p-55,
+ 0x1.2b87fd0dad99p+0,
+ -0x1.10adcd6382p-59,
+ 0x1.2d285a6e4030bp+0,
+ 0x1.0024754db42p-54,
+ 0x1.2ecafa93e2f56p+0,
+ 0x1.1ca0f45d524p-56,
+ 0x1.306fe0a31b715p+0,
+ 0x1.6f46ad23183p-55,
+ 0x1.32170fc4cd831p+0,
+ 0x1.a9ce78e1804p-55,
+ 0x1.33c08b26416ffp+0,
+ 0x1.327218436598p-54,
+ 0x1.356c55f929ff1p+0,
+ -0x1.b5cee5c4e46p-55,
+ 0x1.371a7373aa9cbp+0,
+ -0x1.63aeabf42ebp-54,
+ 0x1.38cae6d05d866p+0,
+ -0x1.e958d3c99048p-54,
+ 0x1.3a7db34e59ff7p+0,
+ -0x1.5e436d661f6p-56,
+ 0x1.3c32dc313a8e5p+0,
+ -0x1.efff8375d2ap-54,
+ 0x1.3dea64c123422p+0,
+ 0x1.ada0911f09fp-55,
+ 0x1.3fa4504ac801cp+0,
+ -0x1.7d023f956fap-54,
+ 0x1.4160a21f72e2ap+0,
+ -0x1.ef3691c309p-58,
+ 0x1.431f5d950a897p+0,
+ -0x1.1c7dde35f7ap-55,
+ 0x1.44e086061892dp+0,
+ 0x1.89b7a04ef8p-59,
+ 0x1.46a41ed1d0057p+0,
+ 0x1.c944bd1648a8p-54,
+ 0x1.486a2b5c13cdp+0,
+ 0x1.3c1a3b69062p-56,
+ 0x1.4a32af0d7d3dep+0,
+ 0x1.9cb62f3d1be8p-54,
+ 0x1.4bfdad5362a27p+0,
+ 0x1.d4397afec42p-56,
+ 0x1.4dcb299fddd0dp+0,
+ 0x1.8ecdbbc6a78p-54,
+ 0x1.4f9b2769d2ca7p+0,
+ -0x1.4b309d25958p-54,
+ 0x1.516daa2cf6642p+0,
+ -0x1.f768569bd94p-55,
+ 0x1.5342b569d4f82p+0,
+ -0x1.07abe1db13dp-55,
+ 0x1.551a4ca5d920fp+0,
+ -0x1.d689cefede6p-55,
+ 0x1.56f4736b527dap+0,
+ 0x1.9bb2c011d938p-54,
+ 0x1.58d12d497c7fdp+0,
+ 0x1.295e15b9a1ep-55,
+ 0x1.5ab07dd485429p+0,
+ 0x1.6324c0546478p-54,
+ 0x1.5c9268a5946b7p+0,
+ 0x1.c4b1b81698p-60,
+ 0x1.5e76f15ad2148p+0,
+ 0x1.ba6f93080e68p-54,
+ 0x1.605e1b976dc09p+0,
+ -0x1.3e2429b56de8p-54,
+ 0x1.6247eb03a5585p+0,
+ -0x1.383c17e40b48p-54,
+ 0x1.6434634ccc32p+0,
+ -0x1.c483c759d89p-55,
+ 0x1.6623882552225p+0,
+ -0x1.bb60987591cp-54,
+ 0x1.68155d44ca973p+0,
+ 0x1.038ae44f74p-57,
};
/*
@@ -197,339 +321,179 @@
* The table entries each have 104 bits of accuracy, encoded as
* a pair of double precision values.
*/
-long double exp2l(long double x)
-{
- union ldshape u = {x};
- int e = u.i.se & 0x7fff;
- long double r, z;
- uint32_t i0;
- union {uint32_t u; int32_t i;} k;
+long double exp2l(long double x) {
+ union ldshape u = {x};
+ int e = u.i.se & 0x7fff;
+ long double r, z;
+ uint32_t i0;
+ union {
+ uint32_t u;
+ int32_t i;
+ } k;
- /* Filter out exceptional cases. */
- if (e >= 0x3fff + 13) { /* |x| >= 8192 or x is NaN */
- if (u.i.se >= 0x3fff + 14 && u.i.se >> 15 == 0)
- /* overflow */
- return x * 0x1p16383L;
- if (e == 0x7fff) /* -inf or -nan */
- return -1/x;
- if (x < -16382) {
- if (x <= -16446 || x - 0x1p63 + 0x1p63 != x)
- /* underflow */
- FORCE_EVAL((float)(-0x1p-149/x));
- if (x <= -16446)
- return 0;
- }
- } else if (e < 0x3fff - 64) {
- return 1 + x;
- }
+ /* Filter out exceptional cases. */
+ if (e >= 0x3fff + 13) { /* |x| >= 8192 or x is NaN */
+ if (u.i.se >= 0x3fff + 14 && u.i.se >> 15 == 0)
+ /* overflow */
+ return x * 0x1p16383L;
+ if (e == 0x7fff) /* -inf or -nan */
+ return -1 / x;
+ if (x < -16382) {
+ if (x <= -16446 || x - 0x1p63 + 0x1p63 != x)
+ /* underflow */
+ FORCE_EVAL((float)(-0x1p-149 / x));
+ if (x <= -16446)
+ return 0;
+ }
+ } else if (e < 0x3fff - 64) {
+ return 1 + x;
+ }
- /*
- * Reduce x, computing z, i0, and k. The low bits of x + redux
- * contain the 16-bit integer part of the exponent (k) followed by
- * TBLBITS fractional bits (i0). We use bit tricks to extract these
- * as integers, then set z to the remainder.
- *
- * Example: Suppose x is 0xabc.123456p0 and TBLBITS is 8.
- * Then the low-order word of x + redux is 0x000abc12,
- * We split this into k = 0xabc and i0 = 0x12 (adjusted to
- * index into the table), then we compute z = 0x0.003456p0.
- */
- u.f = x + redux;
- i0 = u.i.m + TBLSIZE / 2;
- k.u = i0 / TBLSIZE * TBLSIZE;
- k.i /= TBLSIZE;
- i0 %= TBLSIZE;
- u.f -= redux;
- z = x - u.f;
+ /*
+ * Reduce x, computing z, i0, and k. The low bits of x + redux
+ * contain the 16-bit integer part of the exponent (k) followed by
+ * TBLBITS fractional bits (i0). We use bit tricks to extract these
+ * as integers, then set z to the remainder.
+ *
+ * Example: Suppose x is 0xabc.123456p0 and TBLBITS is 8.
+ * Then the low-order word of x + redux is 0x000abc12,
+ * We split this into k = 0xabc and i0 = 0x12 (adjusted to
+ * index into the table), then we compute z = 0x0.003456p0.
+ */
+ u.f = x + redux;
+ i0 = u.i.m + TBLSIZE / 2;
+ k.u = i0 / TBLSIZE * TBLSIZE;
+ k.i /= TBLSIZE;
+ i0 %= TBLSIZE;
+ u.f -= redux;
+ z = x - u.f;
- /* Compute r = exp2l(y) = exp2lt[i0] * p(z). */
- long double t_hi = tbl[2*i0];
- long double t_lo = tbl[2*i0 + 1];
- /* XXX This gives > 1 ulp errors outside of FE_TONEAREST mode */
- r = t_lo + (t_hi + t_lo) * z * (P1 + z * (P2 + z * (P3 + z * (P4
- + z * (P5 + z * P6))))) + t_hi;
+ /* Compute r = exp2l(y) = exp2lt[i0] * p(z). */
+ long double t_hi = tbl[2 * i0];
+ long double t_lo = tbl[2 * i0 + 1];
+ /* XXX This gives > 1 ulp errors outside of FE_TONEAREST mode */
+ r = t_lo +
+ (t_hi + t_lo) * z *
+ (P1 + z * (P2 + z * (P3 + z * (P4 + z * (P5 + z * P6))))) +
+ t_hi;
- return scalbnl(r, k.i);
+ return scalbnl(r, k.i);
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
#define TBLBITS 7
#define TBLSIZE (1 << TBLBITS)
-static const long double
- P1 = 0x1.62e42fefa39ef35793c7673007e6p-1L,
- P2 = 0x1.ebfbdff82c58ea86f16b06ec9736p-3L,
- P3 = 0x1.c6b08d704a0bf8b33a762bad3459p-5L,
- P4 = 0x1.3b2ab6fba4e7729ccbbe0b4f3fc2p-7L,
- P5 = 0x1.5d87fe78a67311071dee13fd11d9p-10L,
- P6 = 0x1.430912f86c7876f4b663b23c5fe5p-13L;
+static const long double P1 = 0x1.62e42fefa39ef35793c7673007e6p-1L,
+ P2 = 0x1.ebfbdff82c58ea86f16b06ec9736p-3L,
+ P3 = 0x1.c6b08d704a0bf8b33a762bad3459p-5L,
+ P4 = 0x1.3b2ab6fba4e7729ccbbe0b4f3fc2p-7L,
+ P5 = 0x1.5d87fe78a67311071dee13fd11d9p-10L,
+ P6 = 0x1.430912f86c7876f4b663b23c5fe5p-13L;
-static const double
- P7 = 0x1.ffcbfc588b041p-17,
- P8 = 0x1.62c0223a5c7c7p-20,
- P9 = 0x1.b52541ff59713p-24,
- P10 = 0x1.e4cf56a391e22p-28,
- redux = 0x1.8p112 / TBLSIZE;
+static const double P7 = 0x1.ffcbfc588b041p-17, P8 = 0x1.62c0223a5c7c7p-20,
+ P9 = 0x1.b52541ff59713p-24, P10 = 0x1.e4cf56a391e22p-28,
+ redux = 0x1.8p112 / TBLSIZE;
static const long double tbl[TBLSIZE] = {
- 0x1.6a09e667f3bcc908b2fb1366dfeap-1L,
- 0x1.6c012750bdabeed76a99800f4edep-1L,
- 0x1.6dfb23c651a2ef220e2cbe1bc0d4p-1L,
- 0x1.6ff7df9519483cf87e1b4f3e1e98p-1L,
- 0x1.71f75e8ec5f73dd2370f2ef0b148p-1L,
- 0x1.73f9a48a58173bd5c9a4e68ab074p-1L,
- 0x1.75feb564267c8bf6e9aa33a489a8p-1L,
- 0x1.780694fde5d3f619ae02808592a4p-1L,
- 0x1.7a11473eb0186d7d51023f6ccb1ap-1L,
- 0x1.7c1ed0130c1327c49334459378dep-1L,
- 0x1.7e2f336cf4e62105d02ba1579756p-1L,
- 0x1.80427543e1a11b60de67649a3842p-1L,
- 0x1.82589994cce128acf88afab34928p-1L,
- 0x1.8471a4623c7acce52f6b97c6444cp-1L,
- 0x1.868d99b4492ec80e41d90ac2556ap-1L,
- 0x1.88ac7d98a669966530bcdf2d4cc0p-1L,
- 0x1.8ace5422aa0db5ba7c55a192c648p-1L,
- 0x1.8cf3216b5448bef2aa1cd161c57ap-1L,
- 0x1.8f1ae991577362b982745c72eddap-1L,
- 0x1.9145b0b91ffc588a61b469f6b6a0p-1L,
- 0x1.93737b0cdc5e4f4501c3f2540ae8p-1L,
- 0x1.95a44cbc8520ee9b483695a0e7fep-1L,
- 0x1.97d829fde4e4f8b9e920f91e8eb6p-1L,
- 0x1.9a0f170ca07b9ba3109b8c467844p-1L,
- 0x1.9c49182a3f0901c7c46b071f28dep-1L,
- 0x1.9e86319e323231824ca78e64c462p-1L,
- 0x1.a0c667b5de564b29ada8b8cabbacp-1L,
- 0x1.a309bec4a2d3358c171f770db1f4p-1L,
- 0x1.a5503b23e255c8b424491caf88ccp-1L,
- 0x1.a799e1330b3586f2dfb2b158f31ep-1L,
- 0x1.a9e6b5579fdbf43eb243bdff53a2p-1L,
- 0x1.ac36bbfd3f379c0db966a3126988p-1L,
- 0x1.ae89f995ad3ad5e8734d17731c80p-1L,
- 0x1.b0e07298db66590842acdfc6fb4ep-1L,
- 0x1.b33a2b84f15faf6bfd0e7bd941b0p-1L,
- 0x1.b59728de559398e3881111648738p-1L,
- 0x1.b7f76f2fb5e46eaa7b081ab53ff6p-1L,
- 0x1.ba5b030a10649840cb3c6af5b74cp-1L,
- 0x1.bcc1e904bc1d2247ba0f45b3d06cp-1L,
- 0x1.bf2c25bd71e088408d7025190cd0p-1L,
- 0x1.c199bdd85529c2220cb12a0916bap-1L,
- 0x1.c40ab5fffd07a6d14df820f17deap-1L,
- 0x1.c67f12e57d14b4a2137fd20f2a26p-1L,
- 0x1.c8f6d9406e7b511acbc48805c3f6p-1L,
- 0x1.cb720dcef90691503cbd1e949d0ap-1L,
- 0x1.cdf0b555dc3f9c44f8958fac4f12p-1L,
- 0x1.d072d4a07897b8d0f22f21a13792p-1L,
- 0x1.d2f87080d89f18ade123989ea50ep-1L,
- 0x1.d5818dcfba48725da05aeb66dff8p-1L,
- 0x1.d80e316c98397bb84f9d048807a0p-1L,
- 0x1.da9e603db3285708c01a5b6d480cp-1L,
- 0x1.dd321f301b4604b695de3c0630c0p-1L,
- 0x1.dfc97337b9b5eb968cac39ed284cp-1L,
- 0x1.e264614f5a128a12761fa17adc74p-1L,
- 0x1.e502ee78b3ff6273d130153992d0p-1L,
- 0x1.e7a51fbc74c834b548b2832378a4p-1L,
- 0x1.ea4afa2a490d9858f73a18f5dab4p-1L,
- 0x1.ecf482d8e67f08db0312fb949d50p-1L,
- 0x1.efa1bee615a27771fd21a92dabb6p-1L,
- 0x1.f252b376bba974e8696fc3638f24p-1L,
- 0x1.f50765b6e4540674f84b762861a6p-1L,
- 0x1.f7bfdad9cbe138913b4bfe72bd78p-1L,
- 0x1.fa7c1819e90d82e90a7e74b26360p-1L,
- 0x1.fd3c22b8f71f10975ba4b32bd006p-1L,
- 0x1.0000000000000000000000000000p+0L,
- 0x1.0163da9fb33356d84a66ae336e98p+0L,
- 0x1.02c9a3e778060ee6f7caca4f7a18p+0L,
- 0x1.04315e86e7f84bd738f9a20da442p+0L,
- 0x1.059b0d31585743ae7c548eb68c6ap+0L,
- 0x1.0706b29ddf6ddc6dc403a9d87b1ep+0L,
- 0x1.0874518759bc808c35f25d942856p+0L,
- 0x1.09e3ecac6f3834521e060c584d5cp+0L,
- 0x1.0b5586cf9890f6298b92b7184200p+0L,
- 0x1.0cc922b7247f7407b705b893dbdep+0L,
- 0x1.0e3ec32d3d1a2020742e4f8af794p+0L,
- 0x1.0fb66affed31af232091dd8a169ep+0L,
- 0x1.11301d0125b50a4ebbf1aed9321cp+0L,
- 0x1.12abdc06c31cbfb92bad324d6f84p+0L,
- 0x1.1429aaea92ddfb34101943b2588ep+0L,
- 0x1.15a98c8a58e512480d573dd562aep+0L,
- 0x1.172b83c7d517adcdf7c8c50eb162p+0L,
- 0x1.18af9388c8de9bbbf70b9a3c269cp+0L,
- 0x1.1a35beb6fcb753cb698f692d2038p+0L,
- 0x1.1bbe084045cd39ab1e72b442810ep+0L,
- 0x1.1d4873168b9aa7805b8028990be8p+0L,
- 0x1.1ed5022fcd91cb8819ff61121fbep+0L,
- 0x1.2063b88628cd63b8eeb0295093f6p+0L,
- 0x1.21f49917ddc962552fd29294bc20p+0L,
- 0x1.2387a6e75623866c1fadb1c159c0p+0L,
- 0x1.251ce4fb2a63f3582ab7de9e9562p+0L,
- 0x1.26b4565e27cdd257a673281d3068p+0L,
- 0x1.284dfe1f5638096cf15cf03c9fa0p+0L,
- 0x1.29e9df51fdee12c25d15f5a25022p+0L,
- 0x1.2b87fd0dad98ffddea46538fca24p+0L,
- 0x1.2d285a6e4030b40091d536d0733ep+0L,
- 0x1.2ecafa93e2f5611ca0f45d5239a4p+0L,
- 0x1.306fe0a31b7152de8d5a463063bep+0L,
- 0x1.32170fc4cd8313539cf1c3009330p+0L,
- 0x1.33c08b26416ff4c9c8610d96680ep+0L,
- 0x1.356c55f929ff0c94623476373be4p+0L,
- 0x1.371a7373aa9caa7145502f45452ap+0L,
- 0x1.38cae6d05d86585a9cb0d9bed530p+0L,
- 0x1.3a7db34e59ff6ea1bc9299e0a1fep+0L,
- 0x1.3c32dc313a8e484001f228b58cf0p+0L,
- 0x1.3dea64c12342235b41223e13d7eep+0L,
- 0x1.3fa4504ac801ba0bf701aa417b9cp+0L,
- 0x1.4160a21f72e29f84325b8f3dbacap+0L,
- 0x1.431f5d950a896dc704439410b628p+0L,
- 0x1.44e086061892d03136f409df0724p+0L,
- 0x1.46a41ed1d005772512f459229f0ap+0L,
- 0x1.486a2b5c13cd013c1a3b69062f26p+0L,
- 0x1.4a32af0d7d3de672d8bcf46f99b4p+0L,
- 0x1.4bfdad5362a271d4397afec42e36p+0L,
- 0x1.4dcb299fddd0d63b36ef1a9e19dep+0L,
- 0x1.4f9b2769d2ca6ad33d8b69aa0b8cp+0L,
- 0x1.516daa2cf6641c112f52c84d6066p+0L,
- 0x1.5342b569d4f81df0a83c49d86bf4p+0L,
- 0x1.551a4ca5d920ec52ec620243540cp+0L,
- 0x1.56f4736b527da66ecb004764e61ep+0L,
- 0x1.58d12d497c7fd252bc2b7343d554p+0L,
- 0x1.5ab07dd48542958c93015191e9a8p+0L,
- 0x1.5c9268a5946b701c4b1b81697ed4p+0L,
- 0x1.5e76f15ad21486e9be4c20399d12p+0L,
- 0x1.605e1b976dc08b076f592a487066p+0L,
- 0x1.6247eb03a5584b1f0fa06fd2d9eap+0L,
- 0x1.6434634ccc31fc76f8714c4ee122p+0L,
- 0x1.66238825522249127d9e29b92ea2p+0L,
- 0x1.68155d44ca973081c57227b9f69ep+0L,
+ 0x1.6a09e667f3bcc908b2fb1366dfeap-1L, 0x1.6c012750bdabeed76a99800f4edep-1L,
+ 0x1.6dfb23c651a2ef220e2cbe1bc0d4p-1L, 0x1.6ff7df9519483cf87e1b4f3e1e98p-1L,
+ 0x1.71f75e8ec5f73dd2370f2ef0b148p-1L, 0x1.73f9a48a58173bd5c9a4e68ab074p-1L,
+ 0x1.75feb564267c8bf6e9aa33a489a8p-1L, 0x1.780694fde5d3f619ae02808592a4p-1L,
+ 0x1.7a11473eb0186d7d51023f6ccb1ap-1L, 0x1.7c1ed0130c1327c49334459378dep-1L,
+ 0x1.7e2f336cf4e62105d02ba1579756p-1L, 0x1.80427543e1a11b60de67649a3842p-1L,
+ 0x1.82589994cce128acf88afab34928p-1L, 0x1.8471a4623c7acce52f6b97c6444cp-1L,
+ 0x1.868d99b4492ec80e41d90ac2556ap-1L, 0x1.88ac7d98a669966530bcdf2d4cc0p-1L,
+ 0x1.8ace5422aa0db5ba7c55a192c648p-1L, 0x1.8cf3216b5448bef2aa1cd161c57ap-1L,
+ 0x1.8f1ae991577362b982745c72eddap-1L, 0x1.9145b0b91ffc588a61b469f6b6a0p-1L,
+ 0x1.93737b0cdc5e4f4501c3f2540ae8p-1L, 0x1.95a44cbc8520ee9b483695a0e7fep-1L,
+ 0x1.97d829fde4e4f8b9e920f91e8eb6p-1L, 0x1.9a0f170ca07b9ba3109b8c467844p-1L,
+ 0x1.9c49182a3f0901c7c46b071f28dep-1L, 0x1.9e86319e323231824ca78e64c462p-1L,
+ 0x1.a0c667b5de564b29ada8b8cabbacp-1L, 0x1.a309bec4a2d3358c171f770db1f4p-1L,
+ 0x1.a5503b23e255c8b424491caf88ccp-1L, 0x1.a799e1330b3586f2dfb2b158f31ep-1L,
+ 0x1.a9e6b5579fdbf43eb243bdff53a2p-1L, 0x1.ac36bbfd3f379c0db966a3126988p-1L,
+ 0x1.ae89f995ad3ad5e8734d17731c80p-1L, 0x1.b0e07298db66590842acdfc6fb4ep-1L,
+ 0x1.b33a2b84f15faf6bfd0e7bd941b0p-1L, 0x1.b59728de559398e3881111648738p-1L,
+ 0x1.b7f76f2fb5e46eaa7b081ab53ff6p-1L, 0x1.ba5b030a10649840cb3c6af5b74cp-1L,
+ 0x1.bcc1e904bc1d2247ba0f45b3d06cp-1L, 0x1.bf2c25bd71e088408d7025190cd0p-1L,
+ 0x1.c199bdd85529c2220cb12a0916bap-1L, 0x1.c40ab5fffd07a6d14df820f17deap-1L,
+ 0x1.c67f12e57d14b4a2137fd20f2a26p-1L, 0x1.c8f6d9406e7b511acbc48805c3f6p-1L,
+ 0x1.cb720dcef90691503cbd1e949d0ap-1L, 0x1.cdf0b555dc3f9c44f8958fac4f12p-1L,
+ 0x1.d072d4a07897b8d0f22f21a13792p-1L, 0x1.d2f87080d89f18ade123989ea50ep-1L,
+ 0x1.d5818dcfba48725da05aeb66dff8p-1L, 0x1.d80e316c98397bb84f9d048807a0p-1L,
+ 0x1.da9e603db3285708c01a5b6d480cp-1L, 0x1.dd321f301b4604b695de3c0630c0p-1L,
+ 0x1.dfc97337b9b5eb968cac39ed284cp-1L, 0x1.e264614f5a128a12761fa17adc74p-1L,
+ 0x1.e502ee78b3ff6273d130153992d0p-1L, 0x1.e7a51fbc74c834b548b2832378a4p-1L,
+ 0x1.ea4afa2a490d9858f73a18f5dab4p-1L, 0x1.ecf482d8e67f08db0312fb949d50p-1L,
+ 0x1.efa1bee615a27771fd21a92dabb6p-1L, 0x1.f252b376bba974e8696fc3638f24p-1L,
+ 0x1.f50765b6e4540674f84b762861a6p-1L, 0x1.f7bfdad9cbe138913b4bfe72bd78p-1L,
+ 0x1.fa7c1819e90d82e90a7e74b26360p-1L, 0x1.fd3c22b8f71f10975ba4b32bd006p-1L,
+ 0x1.0000000000000000000000000000p+0L, 0x1.0163da9fb33356d84a66ae336e98p+0L,
+ 0x1.02c9a3e778060ee6f7caca4f7a18p+0L, 0x1.04315e86e7f84bd738f9a20da442p+0L,
+ 0x1.059b0d31585743ae7c548eb68c6ap+0L, 0x1.0706b29ddf6ddc6dc403a9d87b1ep+0L,
+ 0x1.0874518759bc808c35f25d942856p+0L, 0x1.09e3ecac6f3834521e060c584d5cp+0L,
+ 0x1.0b5586cf9890f6298b92b7184200p+0L, 0x1.0cc922b7247f7407b705b893dbdep+0L,
+ 0x1.0e3ec32d3d1a2020742e4f8af794p+0L, 0x1.0fb66affed31af232091dd8a169ep+0L,
+ 0x1.11301d0125b50a4ebbf1aed9321cp+0L, 0x1.12abdc06c31cbfb92bad324d6f84p+0L,
+ 0x1.1429aaea92ddfb34101943b2588ep+0L, 0x1.15a98c8a58e512480d573dd562aep+0L,
+ 0x1.172b83c7d517adcdf7c8c50eb162p+0L, 0x1.18af9388c8de9bbbf70b9a3c269cp+0L,
+ 0x1.1a35beb6fcb753cb698f692d2038p+0L, 0x1.1bbe084045cd39ab1e72b442810ep+0L,
+ 0x1.1d4873168b9aa7805b8028990be8p+0L, 0x1.1ed5022fcd91cb8819ff61121fbep+0L,
+ 0x1.2063b88628cd63b8eeb0295093f6p+0L, 0x1.21f49917ddc962552fd29294bc20p+0L,
+ 0x1.2387a6e75623866c1fadb1c159c0p+0L, 0x1.251ce4fb2a63f3582ab7de9e9562p+0L,
+ 0x1.26b4565e27cdd257a673281d3068p+0L, 0x1.284dfe1f5638096cf15cf03c9fa0p+0L,
+ 0x1.29e9df51fdee12c25d15f5a25022p+0L, 0x1.2b87fd0dad98ffddea46538fca24p+0L,
+ 0x1.2d285a6e4030b40091d536d0733ep+0L, 0x1.2ecafa93e2f5611ca0f45d5239a4p+0L,
+ 0x1.306fe0a31b7152de8d5a463063bep+0L, 0x1.32170fc4cd8313539cf1c3009330p+0L,
+ 0x1.33c08b26416ff4c9c8610d96680ep+0L, 0x1.356c55f929ff0c94623476373be4p+0L,
+ 0x1.371a7373aa9caa7145502f45452ap+0L, 0x1.38cae6d05d86585a9cb0d9bed530p+0L,
+ 0x1.3a7db34e59ff6ea1bc9299e0a1fep+0L, 0x1.3c32dc313a8e484001f228b58cf0p+0L,
+ 0x1.3dea64c12342235b41223e13d7eep+0L, 0x1.3fa4504ac801ba0bf701aa417b9cp+0L,
+ 0x1.4160a21f72e29f84325b8f3dbacap+0L, 0x1.431f5d950a896dc704439410b628p+0L,
+ 0x1.44e086061892d03136f409df0724p+0L, 0x1.46a41ed1d005772512f459229f0ap+0L,
+ 0x1.486a2b5c13cd013c1a3b69062f26p+0L, 0x1.4a32af0d7d3de672d8bcf46f99b4p+0L,
+ 0x1.4bfdad5362a271d4397afec42e36p+0L, 0x1.4dcb299fddd0d63b36ef1a9e19dep+0L,
+ 0x1.4f9b2769d2ca6ad33d8b69aa0b8cp+0L, 0x1.516daa2cf6641c112f52c84d6066p+0L,
+ 0x1.5342b569d4f81df0a83c49d86bf4p+0L, 0x1.551a4ca5d920ec52ec620243540cp+0L,
+ 0x1.56f4736b527da66ecb004764e61ep+0L, 0x1.58d12d497c7fd252bc2b7343d554p+0L,
+ 0x1.5ab07dd48542958c93015191e9a8p+0L, 0x1.5c9268a5946b701c4b1b81697ed4p+0L,
+ 0x1.5e76f15ad21486e9be4c20399d12p+0L, 0x1.605e1b976dc08b076f592a487066p+0L,
+ 0x1.6247eb03a5584b1f0fa06fd2d9eap+0L, 0x1.6434634ccc31fc76f8714c4ee122p+0L,
+ 0x1.66238825522249127d9e29b92ea2p+0L, 0x1.68155d44ca973081c57227b9f69ep+0L,
};
static const float eps[TBLSIZE] = {
- -0x1.5c50p-101,
- -0x1.5d00p-106,
- 0x1.8e90p-102,
- -0x1.5340p-103,
- 0x1.1bd0p-102,
- -0x1.4600p-105,
- -0x1.7a40p-104,
- 0x1.d590p-102,
- -0x1.d590p-101,
- 0x1.b100p-103,
- -0x1.0d80p-105,
- 0x1.6b00p-103,
- -0x1.9f00p-105,
- 0x1.c400p-103,
- 0x1.e120p-103,
- -0x1.c100p-104,
- -0x1.9d20p-103,
- 0x1.a800p-108,
- 0x1.4c00p-106,
- -0x1.9500p-106,
- 0x1.6900p-105,
- -0x1.29d0p-100,
- 0x1.4c60p-103,
- 0x1.13a0p-102,
- -0x1.5b60p-103,
- -0x1.1c40p-103,
- 0x1.db80p-102,
- 0x1.91a0p-102,
- 0x1.dc00p-105,
- 0x1.44c0p-104,
- 0x1.9710p-102,
- 0x1.8760p-103,
- -0x1.a720p-103,
- 0x1.ed20p-103,
- -0x1.49c0p-102,
- -0x1.e000p-111,
- 0x1.86a0p-103,
- 0x1.2b40p-103,
- -0x1.b400p-108,
- 0x1.1280p-99,
- -0x1.02d8p-102,
- -0x1.e3d0p-103,
- -0x1.b080p-105,
- -0x1.f100p-107,
- -0x1.16c0p-105,
- -0x1.1190p-103,
- -0x1.a7d2p-100,
- 0x1.3450p-103,
- -0x1.67c0p-105,
- 0x1.4b80p-104,
- -0x1.c4e0p-103,
- 0x1.6000p-108,
- -0x1.3f60p-105,
- 0x1.93f0p-104,
- 0x1.5fe0p-105,
- 0x1.6f80p-107,
- -0x1.7600p-106,
- 0x1.21e0p-106,
- -0x1.3a40p-106,
- -0x1.40c0p-104,
- -0x1.9860p-105,
- -0x1.5d40p-108,
- -0x1.1d70p-106,
- 0x1.2760p-105,
- 0x0.0000p+0,
- 0x1.21e2p-104,
- -0x1.9520p-108,
- -0x1.5720p-106,
- -0x1.4810p-106,
- -0x1.be00p-109,
- 0x1.0080p-105,
- -0x1.5780p-108,
- -0x1.d460p-105,
- -0x1.6140p-105,
- 0x1.4630p-104,
- 0x1.ad50p-103,
- 0x1.82e0p-105,
- 0x1.1d3cp-101,
- 0x1.6100p-107,
- 0x1.ec30p-104,
- 0x1.f200p-108,
- 0x1.0b40p-103,
- 0x1.3660p-102,
- 0x1.d9d0p-103,
- -0x1.02d0p-102,
- 0x1.b070p-103,
- 0x1.b9c0p-104,
- -0x1.01c0p-103,
- -0x1.dfe0p-103,
- 0x1.1b60p-104,
- -0x1.ae94p-101,
- -0x1.3340p-104,
- 0x1.b3d8p-102,
- -0x1.6e40p-105,
- -0x1.3670p-103,
- 0x1.c140p-104,
- 0x1.1840p-101,
- 0x1.1ab0p-102,
- -0x1.a400p-104,
- 0x1.1f00p-104,
- -0x1.7180p-103,
- 0x1.4ce0p-102,
- 0x1.9200p-107,
- -0x1.54c0p-103,
- 0x1.1b80p-105,
- -0x1.1828p-101,
- 0x1.5720p-102,
- -0x1.a060p-100,
- 0x1.9160p-102,
- 0x1.a280p-104,
- 0x1.3400p-107,
- 0x1.2b20p-102,
- 0x1.7800p-108,
- 0x1.cfd0p-101,
- 0x1.2ef0p-102,
- -0x1.2760p-99,
- 0x1.b380p-104,
- 0x1.0048p-101,
- -0x1.60b0p-102,
- 0x1.a1ccp-100,
- -0x1.a640p-104,
- -0x1.08a0p-101,
- 0x1.7e60p-102,
- 0x1.22c0p-103,
- -0x1.7200p-106,
- 0x1.f0f0p-102,
- 0x1.eb4ep-99,
- 0x1.c6e0p-103,
+ -0x1.5c50p-101, -0x1.5d00p-106, 0x1.8e90p-102, -0x1.5340p-103,
+ 0x1.1bd0p-102, -0x1.4600p-105, -0x1.7a40p-104, 0x1.d590p-102,
+ -0x1.d590p-101, 0x1.b100p-103, -0x1.0d80p-105, 0x1.6b00p-103,
+ -0x1.9f00p-105, 0x1.c400p-103, 0x1.e120p-103, -0x1.c100p-104,
+ -0x1.9d20p-103, 0x1.a800p-108, 0x1.4c00p-106, -0x1.9500p-106,
+ 0x1.6900p-105, -0x1.29d0p-100, 0x1.4c60p-103, 0x1.13a0p-102,
+ -0x1.5b60p-103, -0x1.1c40p-103, 0x1.db80p-102, 0x1.91a0p-102,
+ 0x1.dc00p-105, 0x1.44c0p-104, 0x1.9710p-102, 0x1.8760p-103,
+ -0x1.a720p-103, 0x1.ed20p-103, -0x1.49c0p-102, -0x1.e000p-111,
+ 0x1.86a0p-103, 0x1.2b40p-103, -0x1.b400p-108, 0x1.1280p-99,
+ -0x1.02d8p-102, -0x1.e3d0p-103, -0x1.b080p-105, -0x1.f100p-107,
+ -0x1.16c0p-105, -0x1.1190p-103, -0x1.a7d2p-100, 0x1.3450p-103,
+ -0x1.67c0p-105, 0x1.4b80p-104, -0x1.c4e0p-103, 0x1.6000p-108,
+ -0x1.3f60p-105, 0x1.93f0p-104, 0x1.5fe0p-105, 0x1.6f80p-107,
+ -0x1.7600p-106, 0x1.21e0p-106, -0x1.3a40p-106, -0x1.40c0p-104,
+ -0x1.9860p-105, -0x1.5d40p-108, -0x1.1d70p-106, 0x1.2760p-105,
+ 0x0.0000p+0, 0x1.21e2p-104, -0x1.9520p-108, -0x1.5720p-106,
+ -0x1.4810p-106, -0x1.be00p-109, 0x1.0080p-105, -0x1.5780p-108,
+ -0x1.d460p-105, -0x1.6140p-105, 0x1.4630p-104, 0x1.ad50p-103,
+ 0x1.82e0p-105, 0x1.1d3cp-101, 0x1.6100p-107, 0x1.ec30p-104,
+ 0x1.f200p-108, 0x1.0b40p-103, 0x1.3660p-102, 0x1.d9d0p-103,
+ -0x1.02d0p-102, 0x1.b070p-103, 0x1.b9c0p-104, -0x1.01c0p-103,
+ -0x1.dfe0p-103, 0x1.1b60p-104, -0x1.ae94p-101, -0x1.3340p-104,
+ 0x1.b3d8p-102, -0x1.6e40p-105, -0x1.3670p-103, 0x1.c140p-104,
+ 0x1.1840p-101, 0x1.1ab0p-102, -0x1.a400p-104, 0x1.1f00p-104,
+ -0x1.7180p-103, 0x1.4ce0p-102, 0x1.9200p-107, -0x1.54c0p-103,
+ 0x1.1b80p-105, -0x1.1828p-101, 0x1.5720p-102, -0x1.a060p-100,
+ 0x1.9160p-102, 0x1.a280p-104, 0x1.3400p-107, 0x1.2b20p-102,
+ 0x1.7800p-108, 0x1.cfd0p-101, 0x1.2ef0p-102, -0x1.2760p-99,
+ 0x1.b380p-104, 0x1.0048p-101, -0x1.60b0p-102, 0x1.a1ccp-100,
+ -0x1.a640p-104, -0x1.08a0p-101, 0x1.7e60p-102, 0x1.22c0p-103,
+ -0x1.7200p-106, 0x1.f0f0p-102, 0x1.eb4ep-99, 0x1.c6e0p-103,
};
/*
@@ -562,58 +526,67 @@
* Gal, S. and Bachelis, B. An Accurate Elementary Mathematical Library
* for the IEEE Floating Point Standard. TOMS 17(1), 26-46 (1991).
*/
-long double
-exp2l(long double x)
-{
- union ldshape u = {x};
- int e = u.i.se & 0x7fff;
- long double r, z, t;
- uint32_t i0;
- union {uint32_t u; int32_t i;} k;
+long double exp2l(long double x) {
+ union ldshape u = {x};
+ int e = u.i.se & 0x7fff;
+ long double r, z, t;
+ uint32_t i0;
+ union {
+ uint32_t u;
+ int32_t i;
+ } k;
- /* Filter out exceptional cases. */
- if (e >= 0x3fff + 14) { /* |x| >= 16384 or x is NaN */
- if (u.i.se >= 0x3fff + 15 && u.i.se >> 15 == 0)
- /* overflow */
- return x * 0x1p16383L;
- if (e == 0x7fff) /* -inf or -nan */
- return -1/x;
- if (x < -16382) {
- if (x <= -16495 || x - 0x1p112 + 0x1p112 != x)
- /* underflow */
- FORCE_EVAL((float)(-0x1p-149/x));
- if (x <= -16446)
- return 0;
- }
- } else if (e < 0x3fff - 114) {
- return 1 + x;
- }
+ /* Filter out exceptional cases. */
+ if (e >= 0x3fff + 14) { /* |x| >= 16384 or x is NaN */
+ if (u.i.se >= 0x3fff + 15 && u.i.se >> 15 == 0)
+ /* overflow */
+ return x * 0x1p16383L;
+ if (e == 0x7fff) /* -inf or -nan */
+ return -1 / x;
+ if (x < -16382) {
+ if (x <= -16495 || x - 0x1p112 + 0x1p112 != x)
+ /* underflow */
+ FORCE_EVAL((float)(-0x1p-149 / x));
+ if (x <= -16446)
+ return 0;
+ }
+ } else if (e < 0x3fff - 114) {
+ return 1 + x;
+ }
- /*
- * Reduce x, computing z, i0, and k. The low bits of x + redux
- * contain the 16-bit integer part of the exponent (k) followed by
- * TBLBITS fractional bits (i0). We use bit tricks to extract these
- * as integers, then set z to the remainder.
- *
- * Example: Suppose x is 0xabc.123456p0 and TBLBITS is 8.
- * Then the low-order word of x + redux is 0x000abc12,
- * We split this into k = 0xabc and i0 = 0x12 (adjusted to
- * index into the table), then we compute z = 0x0.003456p0.
- */
- u.f = x + redux;
- i0 = u.i2.lo + TBLSIZE / 2;
- k.u = i0 / TBLSIZE * TBLSIZE;
- k.i /= TBLSIZE;
- i0 %= TBLSIZE;
- u.f -= redux;
- z = x - u.f;
+ /*
+ * Reduce x, computing z, i0, and k. The low bits of x + redux
+ * contain the 16-bit integer part of the exponent (k) followed by
+ * TBLBITS fractional bits (i0). We use bit tricks to extract these
+ * as integers, then set z to the remainder.
+ *
+ * Example: Suppose x is 0xabc.123456p0 and TBLBITS is 8.
+ * Then the low-order word of x + redux is 0x000abc12,
+ * We split this into k = 0xabc and i0 = 0x12 (adjusted to
+ * index into the table), then we compute z = 0x0.003456p0.
+ */
+ u.f = x + redux;
+ i0 = u.i2.lo + TBLSIZE / 2;
+ k.u = i0 / TBLSIZE * TBLSIZE;
+ k.i /= TBLSIZE;
+ i0 %= TBLSIZE;
+ u.f -= redux;
+ z = x - u.f;
- /* Compute r = exp2(y) = exp2t[i0] * p(z - eps[i]). */
- t = tbl[i0];
- z -= eps[i0];
- r = t + t * z * (P1 + z * (P2 + z * (P3 + z * (P4 + z * (P5 + z * (P6
- + z * (P7 + z * (P8 + z * (P9 + z * P10)))))))));
+ /* Compute r = exp2(y) = exp2t[i0] * p(z - eps[i]). */
+ t = tbl[i0];
+ z -= eps[i0];
+ r = t +
+ t * z *
+ (P1 +
+ z * (P2 +
+ z * (P3 +
+ z * (P4 +
+ z * (P5 +
+ z * (P6 +
+ z * (P7 +
+ z * (P8 + z * (P9 + z * P10)))))))));
- return scalbnl(r, k.i);
+ return scalbnl(r, k.i);
}
#endif
diff --git a/fusl/src/math/expf.c b/fusl/src/math/expf.c
index 16e9afe..34ccafa 100644
--- a/fusl/src/math/expf.c
+++ b/fusl/src/math/expf.c
@@ -15,67 +15,65 @@
#include "libm.h"
-static const float
-half[2] = {0.5,-0.5},
-ln2hi = 6.9314575195e-1f, /* 0x3f317200 */
-ln2lo = 1.4286067653e-6f, /* 0x35bfbe8e */
-invln2 = 1.4426950216e+0f, /* 0x3fb8aa3b */
-/*
- * Domain [-0.34568, 0.34568], range ~[-4.278e-9, 4.447e-9]:
- * |x*(exp(x)+1)/(exp(x)-1) - p(x)| < 2**-27.74
- */
-P1 = 1.6666625440e-1f, /* 0xaaaa8f.0p-26 */
-P2 = -2.7667332906e-3f; /* -0xb55215.0p-32 */
+static const float half[2] = {0.5, -0.5},
+ ln2hi = 6.9314575195e-1f, /* 0x3f317200 */
+ ln2lo = 1.4286067653e-6f, /* 0x35bfbe8e */
+ invln2 = 1.4426950216e+0f, /* 0x3fb8aa3b */
+ /*
+ * Domain [-0.34568, 0.34568], range ~[-4.278e-9, 4.447e-9]:
+ * |x*(exp(x)+1)/(exp(x)-1) - p(x)| < 2**-27.74
+ */
+ P1 = 1.6666625440e-1f, /* 0xaaaa8f.0p-26 */
+ P2 = -2.7667332906e-3f; /* -0xb55215.0p-32 */
-float expf(float x)
-{
- float_t hi, lo, c, xx, y;
- int k, sign;
- uint32_t hx;
+float expf(float x) {
+ float_t hi, lo, c, xx, y;
+ int k, sign;
+ uint32_t hx;
- GET_FLOAT_WORD(hx, x);
- sign = hx >> 31; /* sign bit of x */
- hx &= 0x7fffffff; /* high word of |x| */
+ GET_FLOAT_WORD(hx, x);
+ sign = hx >> 31; /* sign bit of x */
+ hx &= 0x7fffffff; /* high word of |x| */
- /* special cases */
- if (hx >= 0x42aeac50) { /* if |x| >= -87.33655f or NaN */
- if (hx >= 0x42b17218 && !sign) { /* x >= 88.722839f */
- /* overflow */
- x *= 0x1p127f;
- return x;
- }
- if (sign) {
- /* underflow */
- FORCE_EVAL(-0x1p-149f/x);
- if (hx >= 0x42cff1b5) /* x <= -103.972084f */
- return 0;
- }
- }
+ /* special cases */
+ if (hx >= 0x42aeac50) { /* if |x| >= -87.33655f or NaN */
+ if (hx >= 0x42b17218 && !sign) { /* x >= 88.722839f */
+ /* overflow */
+ x *= 0x1p127f;
+ return x;
+ }
+ if (sign) {
+ /* underflow */
+ FORCE_EVAL(-0x1p-149f / x);
+ if (hx >= 0x42cff1b5) /* x <= -103.972084f */
+ return 0;
+ }
+ }
- /* argument reduction */
- if (hx > 0x3eb17218) { /* if |x| > 0.5 ln2 */
- if (hx > 0x3f851592) /* if |x| > 1.5 ln2 */
- k = invln2*x + half[sign];
- else
- k = 1 - sign - sign;
- hi = x - k*ln2hi; /* k*ln2hi is exact here */
- lo = k*ln2lo;
- x = hi - lo;
- } else if (hx > 0x39000000) { /* |x| > 2**-14 */
- k = 0;
- hi = x;
- lo = 0;
- } else {
- /* raise inexact */
- FORCE_EVAL(0x1p127f + x);
- return 1 + x;
- }
+ /* argument reduction */
+ if (hx > 0x3eb17218) { /* if |x| > 0.5 ln2 */
+ if (hx > 0x3f851592) /* if |x| > 1.5 ln2 */
+ k = invln2 * x + half[sign];
+ else
+ k = 1 - sign - sign;
+ hi = x - k * ln2hi; /* k*ln2hi is exact here */
+ lo = k * ln2lo;
+ x = hi - lo;
+ } else if (hx > 0x39000000) { /* |x| > 2**-14 */
+ k = 0;
+ hi = x;
+ lo = 0;
+ } else {
+ /* raise inexact */
+ FORCE_EVAL(0x1p127f + x);
+ return 1 + x;
+ }
- /* x is now in primary range */
- xx = x*x;
- c = x - xx*(P1+xx*P2);
- y = 1 + (x*c/(2-c) - lo + hi);
- if (k == 0)
- return y;
- return scalbnf(y, k);
+ /* x is now in primary range */
+ xx = x * x;
+ c = x - xx * (P1 + xx * P2);
+ y = 1 + (x * c / (2 - c) - lo + hi);
+ if (k == 0)
+ return y;
+ return scalbnf(y, k);
}
diff --git a/fusl/src/math/expl.c b/fusl/src/math/expl.c
index 0a7f44f..c677267 100644
--- a/fusl/src/math/expl.c
+++ b/fusl/src/math/expl.c
@@ -68,61 +68,54 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double expl(long double x)
-{
- return exp(x);
+long double expl(long double x) {
+ return exp(x);
}
#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
static const long double P[3] = {
- 1.2617719307481059087798E-4L,
- 3.0299440770744196129956E-2L,
- 9.9999999999999999991025E-1L,
+ 1.2617719307481059087798E-4L, 3.0299440770744196129956E-2L,
+ 9.9999999999999999991025E-1L,
};
static const long double Q[4] = {
- 3.0019850513866445504159E-6L,
- 2.5244834034968410419224E-3L,
- 2.2726554820815502876593E-1L,
- 2.0000000000000000000897E0L,
+ 3.0019850513866445504159E-6L, 2.5244834034968410419224E-3L,
+ 2.2726554820815502876593E-1L, 2.0000000000000000000897E0L,
};
-static const long double
-LN2HI = 6.9314575195312500000000E-1L,
-LN2LO = 1.4286068203094172321215E-6L,
-LOG2E = 1.4426950408889634073599E0L;
+static const long double LN2HI = 6.9314575195312500000000E-1L,
+ LN2LO = 1.4286068203094172321215E-6L,
+ LOG2E = 1.4426950408889634073599E0L;
-long double expl(long double x)
-{
- long double px, xx;
- int k;
+long double expl(long double x) {
+ long double px, xx;
+ int k;
- if (isnan(x))
- return x;
- if (x > 11356.5234062941439488L) /* x > ln(2^16384 - 0.5) */
- return x * 0x1p16383L;
- if (x < -11399.4985314888605581L) /* x < ln(2^-16446) */
- return -0x1p-16445L/x;
+ if (isnan(x))
+ return x;
+ if (x > 11356.5234062941439488L) /* x > ln(2^16384 - 0.5) */
+ return x * 0x1p16383L;
+ if (x < -11399.4985314888605581L) /* x < ln(2^-16446) */
+ return -0x1p-16445L / x;
- /* Express e**x = e**f 2**k
- * = e**(f + k ln(2))
- */
- px = floorl(LOG2E * x + 0.5);
- k = px;
- x -= px * LN2HI;
- x -= px * LN2LO;
+ /* Express e**x = e**f 2**k
+ * = e**(f + k ln(2))
+ */
+ px = floorl(LOG2E * x + 0.5);
+ k = px;
+ x -= px * LN2HI;
+ x -= px * LN2LO;
- /* rational approximation of the fractional part:
- * e**x = 1 + 2x P(x**2)/(Q(x**2) - x P(x**2))
- */
- xx = x * x;
- px = x * __polevll(xx, P, 2);
- x = px/(__polevll(xx, Q, 3) - px);
- x = 1.0 + 2.0 * x;
- return scalbnl(x, k);
+ /* rational approximation of the fractional part:
+ * e**x = 1 + 2x P(x**2)/(Q(x**2) - x P(x**2))
+ */
+ xx = x * x;
+ px = x * __polevll(xx, P, 2);
+ x = px / (__polevll(xx, Q, 3) - px);
+ x = 1.0 + 2.0 * x;
+ return scalbnl(x, k);
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
// TODO: broken implementation to make things compile
-long double expl(long double x)
-{
- return exp(x);
+long double expl(long double x) {
+ return exp(x);
}
#endif
diff --git a/fusl/src/math/expm1.c b/fusl/src/math/expm1.c
index ac1e61e..52cfc25 100644
--- a/fusl/src/math/expm1.c
+++ b/fusl/src/math/expm1.c
@@ -106,96 +106,99 @@
#include "libm.h"
-static const double
-o_threshold = 7.09782712893383973096e+02, /* 0x40862E42, 0xFEFA39EF */
-ln2_hi = 6.93147180369123816490e-01, /* 0x3fe62e42, 0xfee00000 */
-ln2_lo = 1.90821492927058770002e-10, /* 0x3dea39ef, 0x35793c76 */
-invln2 = 1.44269504088896338700e+00, /* 0x3ff71547, 0x652b82fe */
-/* Scaled Q's: Qn_here = 2**n * Qn_above, for R(2*z) where z = hxs = x*x/2: */
-Q1 = -3.33333333333331316428e-02, /* BFA11111 111110F4 */
-Q2 = 1.58730158725481460165e-03, /* 3F5A01A0 19FE5585 */
-Q3 = -7.93650757867487942473e-05, /* BF14CE19 9EAADBB7 */
-Q4 = 4.00821782732936239552e-06, /* 3ED0CFCA 86E65239 */
-Q5 = -2.01099218183624371326e-07; /* BE8AFDB7 6E09C32D */
+static const double o_threshold =
+ 7.09782712893383973096e+02, /* 0x40862E42, 0xFEFA39EF */
+ ln2_hi = 6.93147180369123816490e-01, /* 0x3fe62e42, 0xfee00000 */
+ ln2_lo = 1.90821492927058770002e-10, /* 0x3dea39ef, 0x35793c76 */
+ invln2 = 1.44269504088896338700e+00, /* 0x3ff71547, 0x652b82fe */
+ /* Scaled Q's: Qn_here = 2**n * Qn_above, for R(2*z) where z = hxs = x*x/2:
+ */
+ Q1 = -3.33333333333331316428e-02, /* BFA11111 111110F4 */
+ Q2 = 1.58730158725481460165e-03, /* 3F5A01A0 19FE5585 */
+ Q3 = -7.93650757867487942473e-05, /* BF14CE19 9EAADBB7 */
+ Q4 = 4.00821782732936239552e-06, /* 3ED0CFCA 86E65239 */
+ Q5 = -2.01099218183624371326e-07; /* BE8AFDB7 6E09C32D */
-double expm1(double x)
-{
- double_t y,hi,lo,c,t,e,hxs,hfx,r1,twopk;
- union {double f; uint64_t i;} u = {x};
- uint32_t hx = u.i>>32 & 0x7fffffff;
- int k, sign = u.i>>63;
+double expm1(double x) {
+ double_t y, hi, lo, c, t, e, hxs, hfx, r1, twopk;
+ union {
+ double f;
+ uint64_t i;
+ } u = {x};
+ uint32_t hx = u.i >> 32 & 0x7fffffff;
+ int k, sign = u.i >> 63;
- /* filter out huge and non-finite argument */
- if (hx >= 0x4043687A) { /* if |x|>=56*ln2 */
- if (isnan(x))
- return x;
- if (sign)
- return -1;
- if (x > o_threshold) {
- x *= 0x1p1023;
- return x;
- }
- }
+ /* filter out huge and non-finite argument */
+ if (hx >= 0x4043687A) { /* if |x|>=56*ln2 */
+ if (isnan(x))
+ return x;
+ if (sign)
+ return -1;
+ if (x > o_threshold) {
+ x *= 0x1p1023;
+ return x;
+ }
+ }
- /* argument reduction */
- if (hx > 0x3fd62e42) { /* if |x| > 0.5 ln2 */
- if (hx < 0x3FF0A2B2) { /* and |x| < 1.5 ln2 */
- if (!sign) {
- hi = x - ln2_hi;
- lo = ln2_lo;
- k = 1;
- } else {
- hi = x + ln2_hi;
- lo = -ln2_lo;
- k = -1;
- }
- } else {
- k = invln2*x + (sign ? -0.5 : 0.5);
- t = k;
- hi = x - t*ln2_hi; /* t*ln2_hi is exact here */
- lo = t*ln2_lo;
- }
- x = hi-lo;
- c = (hi-x)-lo;
- } else if (hx < 0x3c900000) { /* |x| < 2**-54, return x */
- if (hx < 0x00100000)
- FORCE_EVAL((float)x);
- return x;
- } else
- k = 0;
+ /* argument reduction */
+ if (hx > 0x3fd62e42) { /* if |x| > 0.5 ln2 */
+ if (hx < 0x3FF0A2B2) { /* and |x| < 1.5 ln2 */
+ if (!sign) {
+ hi = x - ln2_hi;
+ lo = ln2_lo;
+ k = 1;
+ } else {
+ hi = x + ln2_hi;
+ lo = -ln2_lo;
+ k = -1;
+ }
+ } else {
+ k = invln2 * x + (sign ? -0.5 : 0.5);
+ t = k;
+ hi = x - t * ln2_hi; /* t*ln2_hi is exact here */
+ lo = t * ln2_lo;
+ }
+ x = hi - lo;
+ c = (hi - x) - lo;
+ } else if (hx < 0x3c900000) { /* |x| < 2**-54, return x */
+ if (hx < 0x00100000)
+ FORCE_EVAL((float)x);
+ return x;
+ } else
+ k = 0;
- /* x is now in primary range */
- hfx = 0.5*x;
- hxs = x*hfx;
- r1 = 1.0+hxs*(Q1+hxs*(Q2+hxs*(Q3+hxs*(Q4+hxs*Q5))));
- t = 3.0-r1*hfx;
- e = hxs*((r1-t)/(6.0 - x*t));
- if (k == 0) /* c is 0 */
- return x - (x*e-hxs);
- e = x*(e-c) - c;
- e -= hxs;
- /* exp(x) ~ 2^k (x_reduced - e + 1) */
- if (k == -1)
- return 0.5*(x-e) - 0.5;
- if (k == 1) {
- if (x < -0.25)
- return -2.0*(e-(x+0.5));
- return 1.0+2.0*(x-e);
- }
- u.i = (uint64_t)(0x3ff + k)<<52; /* 2^k */
- twopk = u.f;
- if (k < 0 || k > 56) { /* suffice to return exp(x)-1 */
- y = x - e + 1.0;
- if (k == 1024)
- y = y*2.0*0x1p1023;
- else
- y = y*twopk;
- return y - 1.0;
- }
- u.i = (uint64_t)(0x3ff - k)<<52; /* 2^-k */
- if (k < 20)
- y = (x-e+(1-u.f))*twopk;
- else
- y = (x-(e+u.f)+1)*twopk;
- return y;
+ /* x is now in primary range */
+ hfx = 0.5 * x;
+ hxs = x * hfx;
+ r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));
+ t = 3.0 - r1 * hfx;
+ e = hxs * ((r1 - t) / (6.0 - x * t));
+ if (k == 0) /* c is 0 */
+ return x - (x * e - hxs);
+ e = x * (e - c) - c;
+ e -= hxs;
+ /* exp(x) ~ 2^k (x_reduced - e + 1) */
+ if (k == -1)
+ return 0.5 * (x - e) - 0.5;
+ if (k == 1) {
+ if (x < -0.25)
+ return -2.0 * (e - (x + 0.5));
+ return 1.0 + 2.0 * (x - e);
+ }
+ u.i = (uint64_t)(0x3ff + k) << 52; /* 2^k */
+ twopk = u.f;
+ if (k < 0 || k > 56) { /* suffice to return exp(x)-1 */
+ y = x - e + 1.0;
+ if (k == 1024)
+ y = y * 2.0 * 0x1p1023;
+ else
+ y = y * twopk;
+ return y - 1.0;
+ }
+ u.i = (uint64_t)(0x3ff - k) << 52; /* 2^-k */
+ if (k < 20)
+ y = (x - e + (1 - u.f)) * twopk;
+ else
+ y = (x - (e + u.f) + 1) * twopk;
+ return y;
}
diff --git a/fusl/src/math/expm1f.c b/fusl/src/math/expm1f.c
index 297e0b4..3ea476e 100644
--- a/fusl/src/math/expm1f.c
+++ b/fusl/src/math/expm1f.c
@@ -15,97 +15,98 @@
#include "libm.h"
-static const float
-o_threshold = 8.8721679688e+01, /* 0x42b17180 */
-ln2_hi = 6.9313812256e-01, /* 0x3f317180 */
-ln2_lo = 9.0580006145e-06, /* 0x3717f7d1 */
-invln2 = 1.4426950216e+00, /* 0x3fb8aa3b */
-/*
- * Domain [-0.34568, 0.34568], range ~[-6.694e-10, 6.696e-10]:
- * |6 / x * (1 + 2 * (1 / (exp(x) - 1) - 1 / x)) - q(x)| < 2**-30.04
- * Scaled coefficients: Qn_here = 2**n * Qn_for_q (see s_expm1.c):
- */
-Q1 = -3.3333212137e-2, /* -0x888868.0p-28 */
-Q2 = 1.5807170421e-3; /* 0xcf3010.0p-33 */
+static const float o_threshold = 8.8721679688e+01, /* 0x42b17180 */
+ ln2_hi = 6.9313812256e-01, /* 0x3f317180 */
+ ln2_lo = 9.0580006145e-06, /* 0x3717f7d1 */
+ invln2 = 1.4426950216e+00, /* 0x3fb8aa3b */
+ /*
+ * Domain [-0.34568, 0.34568], range ~[-6.694e-10, 6.696e-10]:
+ * |6 / x * (1 + 2 * (1 / (exp(x) - 1) - 1 / x)) - q(x)| < 2**-30.04
+ * Scaled coefficients: Qn_here = 2**n * Qn_for_q (see s_expm1.c):
+ */
+ Q1 = -3.3333212137e-2, /* -0x888868.0p-28 */
+ Q2 = 1.5807170421e-3; /* 0xcf3010.0p-33 */
-float expm1f(float x)
-{
- float_t y,hi,lo,c,t,e,hxs,hfx,r1,twopk;
- union {float f; uint32_t i;} u = {x};
- uint32_t hx = u.i & 0x7fffffff;
- int k, sign = u.i >> 31;
+float expm1f(float x) {
+ float_t y, hi, lo, c, t, e, hxs, hfx, r1, twopk;
+ union {
+ float f;
+ uint32_t i;
+ } u = {x};
+ uint32_t hx = u.i & 0x7fffffff;
+ int k, sign = u.i >> 31;
- /* filter out huge and non-finite argument */
- if (hx >= 0x4195b844) { /* if |x|>=27*ln2 */
- if (hx > 0x7f800000) /* NaN */
- return x;
- if (sign)
- return -1;
- if (x > o_threshold) {
- x *= 0x1p127f;
- return x;
- }
- }
+ /* filter out huge and non-finite argument */
+ if (hx >= 0x4195b844) { /* if |x|>=27*ln2 */
+ if (hx > 0x7f800000) /* NaN */
+ return x;
+ if (sign)
+ return -1;
+ if (x > o_threshold) {
+ x *= 0x1p127f;
+ return x;
+ }
+ }
- /* argument reduction */
- if (hx > 0x3eb17218) { /* if |x| > 0.5 ln2 */
- if (hx < 0x3F851592) { /* and |x| < 1.5 ln2 */
- if (!sign) {
- hi = x - ln2_hi;
- lo = ln2_lo;
- k = 1;
- } else {
- hi = x + ln2_hi;
- lo = -ln2_lo;
- k = -1;
- }
- } else {
- k = invln2*x + (sign ? -0.5f : 0.5f);
- t = k;
- hi = x - t*ln2_hi; /* t*ln2_hi is exact here */
- lo = t*ln2_lo;
- }
- x = hi-lo;
- c = (hi-x)-lo;
- } else if (hx < 0x33000000) { /* when |x|<2**-25, return x */
- if (hx < 0x00800000)
- FORCE_EVAL(x*x);
- return x;
- } else
- k = 0;
+ /* argument reduction */
+ if (hx > 0x3eb17218) { /* if |x| > 0.5 ln2 */
+ if (hx < 0x3F851592) { /* and |x| < 1.5 ln2 */
+ if (!sign) {
+ hi = x - ln2_hi;
+ lo = ln2_lo;
+ k = 1;
+ } else {
+ hi = x + ln2_hi;
+ lo = -ln2_lo;
+ k = -1;
+ }
+ } else {
+ k = invln2 * x + (sign ? -0.5f : 0.5f);
+ t = k;
+ hi = x - t * ln2_hi; /* t*ln2_hi is exact here */
+ lo = t * ln2_lo;
+ }
+ x = hi - lo;
+ c = (hi - x) - lo;
+ } else if (hx < 0x33000000) { /* when |x|<2**-25, return x */
+ if (hx < 0x00800000)
+ FORCE_EVAL(x * x);
+ return x;
+ } else
+ k = 0;
- /* x is now in primary range */
- hfx = 0.5f*x;
- hxs = x*hfx;
- r1 = 1.0f+hxs*(Q1+hxs*Q2);
- t = 3.0f - r1*hfx;
- e = hxs*((r1-t)/(6.0f - x*t));
- if (k == 0) /* c is 0 */
- return x - (x*e-hxs);
- e = x*(e-c) - c;
- e -= hxs;
- /* exp(x) ~ 2^k (x_reduced - e + 1) */
- if (k == -1)
- return 0.5f*(x-e) - 0.5f;
- if (k == 1) {
- if (x < -0.25f)
- return -2.0f*(e-(x+0.5f));
- return 1.0f + 2.0f*(x-e);
- }
- u.i = (0x7f+k)<<23; /* 2^k */
- twopk = u.f;
- if (k < 0 || k > 56) { /* suffice to return exp(x)-1 */
- y = x - e + 1.0f;
- if (k == 128)
- y = y*2.0f*0x1p127f;
- else
- y = y*twopk;
- return y - 1.0f;
- }
- u.i = (0x7f-k)<<23; /* 2^-k */
- if (k < 23)
- y = (x-e+(1-u.f))*twopk;
- else
- y = (x-(e+u.f)+1)*twopk;
- return y;
+ /* x is now in primary range */
+ hfx = 0.5f * x;
+ hxs = x * hfx;
+ r1 = 1.0f + hxs * (Q1 + hxs * Q2);
+ t = 3.0f - r1 * hfx;
+ e = hxs * ((r1 - t) / (6.0f - x * t));
+ if (k == 0) /* c is 0 */
+ return x - (x * e - hxs);
+ e = x * (e - c) - c;
+ e -= hxs;
+ /* exp(x) ~ 2^k (x_reduced - e + 1) */
+ if (k == -1)
+ return 0.5f * (x - e) - 0.5f;
+ if (k == 1) {
+ if (x < -0.25f)
+ return -2.0f * (e - (x + 0.5f));
+ return 1.0f + 2.0f * (x - e);
+ }
+ u.i = (0x7f + k) << 23; /* 2^k */
+ twopk = u.f;
+ if (k < 0 || k > 56) { /* suffice to return exp(x)-1 */
+ y = x - e + 1.0f;
+ if (k == 128)
+ y = y * 2.0f * 0x1p127f;
+ else
+ y = y * twopk;
+ return y - 1.0f;
+ }
+ u.i = (0x7f - k) << 23; /* 2^-k */
+ if (k < 23)
+ y = (x - e + (1 - u.f)) * twopk;
+ else
+ y = (x - (e + u.f) + 1) * twopk;
+ return y;
}
diff --git a/fusl/src/math/expm1l.c b/fusl/src/math/expm1l.c
index d171507..c7149a8 100644
--- a/fusl/src/math/expm1l.c
+++ b/fusl/src/math/expm1l.c
@@ -50,74 +50,70 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double expm1l(long double x)
-{
- return expm1(x);
+long double expm1l(long double x) {
+ return expm1(x);
}
#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
/* 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 = 3.4e-22 */
-static const long double
-P0 = -1.586135578666346600772998894928250240826E4L,
-P1 = 2.642771505685952966904660652518429479531E3L,
-P2 = -3.423199068835684263987132888286791620673E2L,
-P3 = 1.800826371455042224581246202420972737840E1L,
-P4 = -5.238523121205561042771939008061958820811E-1L,
-Q0 = -9.516813471998079611319047060563358064497E4L,
-Q1 = 3.964866271411091674556850458227710004570E4L,
-Q2 = -7.207678383830091850230366618190187434796E3L,
-Q3 = 7.206038318724600171970199625081491823079E2L,
-Q4 = -4.002027679107076077238836622982900945173E1L,
-/* Q5 = 1.000000000000000000000000000000000000000E0 */
-/* C1 + C2 = ln 2 */
-C1 = 6.93145751953125E-1L,
-C2 = 1.428606820309417232121458176568075500134E-6L,
-/* ln 2^-65 */
-minarg = -4.5054566736396445112120088E1L,
-/* ln 2^16384 */
-maxarg = 1.1356523406294143949492E4L;
+static const long double P0 = -1.586135578666346600772998894928250240826E4L,
+ P1 = 2.642771505685952966904660652518429479531E3L,
+ P2 = -3.423199068835684263987132888286791620673E2L,
+ P3 = 1.800826371455042224581246202420972737840E1L,
+ P4 = -5.238523121205561042771939008061958820811E-1L,
+ Q0 = -9.516813471998079611319047060563358064497E4L,
+ Q1 = 3.964866271411091674556850458227710004570E4L,
+ Q2 = -7.207678383830091850230366618190187434796E3L,
+ Q3 = 7.206038318724600171970199625081491823079E2L,
+ Q4 = -4.002027679107076077238836622982900945173E1L,
+ /* Q5 = 1.000000000000000000000000000000000000000E0 */
+ /* C1 + C2 = ln 2 */
+ C1 = 6.93145751953125E-1L,
+ C2 = 1.428606820309417232121458176568075500134E-6L,
+ /* ln 2^-65 */
+ minarg = -4.5054566736396445112120088E1L,
+ /* ln 2^16384 */
+ maxarg = 1.1356523406294143949492E4L;
-long double expm1l(long double x)
-{
- long double px, qx, xx;
- int k;
+long double expm1l(long double x) {
+ long double px, qx, xx;
+ int k;
- if (isnan(x))
- return x;
- if (x > maxarg)
- return x*0x1p16383L; /* overflow, unless x==inf */
- if (x == 0.0)
- return x;
- if (x < minarg)
- return -1.0;
+ if (isnan(x))
+ return x;
+ if (x > maxarg)
+ return x * 0x1p16383L; /* overflow, unless x==inf */
+ if (x == 0.0)
+ return x;
+ if (x < minarg)
+ return -1.0;
- xx = C1 + C2;
- /* Express x = ln 2 (k + remainder), remainder not exceeding 1/2. */
- px = floorl(0.5 + x / xx);
- k = px;
- /* remainder times ln 2 */
- x -= px * C1;
- x -= px * C2;
+ xx = C1 + C2;
+ /* Express x = ln 2 (k + remainder), remainder not exceeding 1/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 = (((( P4 * x + P3) * x + P2) * x + P1) * x + P0) * x;
- qx = (((( x + Q4) * x + Q3) * x + Q2) * x + Q1) * x + Q0;
- xx = x * x;
- qx = x + (0.5 * xx + xx * px / qx);
+ /* Approximate exp(remainder ln 2).*/
+ px = ((((P4 * x + P3) * x + P2) * x + P1) * x + P0) * x;
+ qx = ((((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 = scalbnl(1.0, k);
- x = px * qx + (px - 1.0);
- return x;
+ /* 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 = scalbnl(1.0, k);
+ x = px * qx + (px - 1.0);
+ return x;
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
// TODO: broken implementation to make things compile
-long double expm1l(long double x)
-{
- return expm1(x);
+long double expm1l(long double x) {
+ return expm1(x);
}
#endif
diff --git a/fusl/src/math/fabs.c b/fusl/src/math/fabs.c
index e8258cf..0e1a570 100644
--- a/fusl/src/math/fabs.c
+++ b/fusl/src/math/fabs.c
@@ -1,9 +1,11 @@
#include <math.h>
#include <stdint.h>
-double fabs(double x)
-{
- union {double f; uint64_t i;} u = {x};
- u.i &= -1ULL/2;
- return u.f;
+double fabs(double x) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {x};
+ u.i &= -1ULL / 2;
+ return u.f;
}
diff --git a/fusl/src/math/fabsf.c b/fusl/src/math/fabsf.c
index 4efc8d6..55c8b29 100644
--- a/fusl/src/math/fabsf.c
+++ b/fusl/src/math/fabsf.c
@@ -1,9 +1,11 @@
#include <math.h>
#include <stdint.h>
-float fabsf(float x)
-{
- union {float f; uint32_t i;} u = {x};
- u.i &= 0x7fffffff;
- return u.f;
+float fabsf(float x) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {x};
+ u.i &= 0x7fffffff;
+ return u.f;
}
diff --git a/fusl/src/math/fabsl.c b/fusl/src/math/fabsl.c
index c4f36ec..2af6eb9 100644
--- a/fusl/src/math/fabsl.c
+++ b/fusl/src/math/fabsl.c
@@ -1,15 +1,13 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double fabsl(long double x)
-{
- return fabs(x);
+long double fabsl(long double x) {
+ return fabs(x);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-long double fabsl(long double x)
-{
- union ldshape u = {x};
+long double fabsl(long double x) {
+ union ldshape u = {x};
- u.i.se &= 0x7fff;
- return u.f;
+ u.i.se &= 0x7fff;
+ return u.f;
}
#endif
diff --git a/fusl/src/math/fdim.c b/fusl/src/math/fdim.c
index 9585460..1eb169e 100644
--- a/fusl/src/math/fdim.c
+++ b/fusl/src/math/fdim.c
@@ -1,10 +1,9 @@
#include <math.h>
-double fdim(double x, double y)
-{
- if (isnan(x))
- return x;
- if (isnan(y))
- return y;
- return x > y ? x - y : 0;
+double fdim(double x, double y) {
+ if (isnan(x))
+ return x;
+ if (isnan(y))
+ return y;
+ return x > y ? x - y : 0;
}
diff --git a/fusl/src/math/fdimf.c b/fusl/src/math/fdimf.c
index 543c364..454768b 100644
--- a/fusl/src/math/fdimf.c
+++ b/fusl/src/math/fdimf.c
@@ -1,10 +1,9 @@
#include <math.h>
-float fdimf(float x, float y)
-{
- if (isnan(x))
- return x;
- if (isnan(y))
- return y;
- return x > y ? x - y : 0;
+float fdimf(float x, float y) {
+ if (isnan(x))
+ return x;
+ if (isnan(y))
+ return y;
+ return x > y ? x - y : 0;
}
diff --git a/fusl/src/math/fdiml.c b/fusl/src/math/fdiml.c
index 62e29b7..c77ec63 100644
--- a/fusl/src/math/fdiml.c
+++ b/fusl/src/math/fdiml.c
@@ -2,17 +2,15 @@
#include <float.h>
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double fdiml(long double x, long double y)
-{
- return fdim(x, y);
+long double fdiml(long double x, long double y) {
+ return fdim(x, y);
}
#else
-long double fdiml(long double x, long double y)
-{
- if (isnan(x))
- return x;
- if (isnan(y))
- return y;
- return x > y ? x - y : 0;
+long double fdiml(long double x, long double y) {
+ if (isnan(x))
+ return x;
+ if (isnan(y))
+ return y;
+ return x > y ? x - y : 0;
}
#endif
diff --git a/fusl/src/math/finite.c b/fusl/src/math/finite.c
index 25a0575..98d3bd9 100644
--- a/fusl/src/math/finite.c
+++ b/fusl/src/math/finite.c
@@ -1,7 +1,6 @@
#define _GNU_SOURCE
#include <math.h>
-int finite(double x)
-{
- return isfinite(x);
+int finite(double x) {
+ return isfinite(x);
}
diff --git a/fusl/src/math/finitef.c b/fusl/src/math/finitef.c
index 2c4c771..9c6da62 100644
--- a/fusl/src/math/finitef.c
+++ b/fusl/src/math/finitef.c
@@ -1,7 +1,6 @@
#define _GNU_SOURCE
#include <math.h>
-int finitef(float x)
-{
- return isfinite(x);
+int finitef(float x) {
+ return isfinite(x);
}
diff --git a/fusl/src/math/floor.c b/fusl/src/math/floor.c
index 14a31cd..53d0ace 100644
--- a/fusl/src/math/floor.c
+++ b/fusl/src/math/floor.c
@@ -1,31 +1,33 @@
#include "libm.h"
-#if FLT_EVAL_METHOD==0 || FLT_EVAL_METHOD==1
+#if FLT_EVAL_METHOD == 0 || FLT_EVAL_METHOD == 1
#define EPS DBL_EPSILON
-#elif FLT_EVAL_METHOD==2
+#elif FLT_EVAL_METHOD == 2
#define EPS LDBL_EPSILON
#endif
-static const double_t toint = 1/EPS;
+static const double_t toint = 1 / EPS;
-double floor(double x)
-{
- union {double f; uint64_t i;} u = {x};
- int e = u.i >> 52 & 0x7ff;
- double_t y;
+double floor(double x) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {x};
+ int e = u.i >> 52 & 0x7ff;
+ double_t y;
- if (e >= 0x3ff+52 || x == 0)
- return x;
- /* y = int(x) - x, where int(x) is an integer neighbor of x */
- if (u.i >> 63)
- y = x - toint + toint - x;
- else
- y = x + toint - toint - x;
- /* special case because of non-nearest rounding modes */
- if (e <= 0x3ff-1) {
- FORCE_EVAL(y);
- return u.i >> 63 ? -1 : 0;
- }
- if (y > 0)
- return x + y - 1;
- return x + y;
+ if (e >= 0x3ff + 52 || x == 0)
+ return x;
+ /* y = int(x) - x, where int(x) is an integer neighbor of x */
+ if (u.i >> 63)
+ y = x - toint + toint - x;
+ else
+ y = x + toint - toint - x;
+ /* special case because of non-nearest rounding modes */
+ if (e <= 0x3ff - 1) {
+ FORCE_EVAL(y);
+ return u.i >> 63 ? -1 : 0;
+ }
+ if (y > 0)
+ return x + y - 1;
+ return x + y;
}
diff --git a/fusl/src/math/floorf.c b/fusl/src/math/floorf.c
index dceec73..fd40863 100644
--- a/fusl/src/math/floorf.c
+++ b/fusl/src/math/floorf.c
@@ -1,27 +1,29 @@
#include "libm.h"
-float floorf(float x)
-{
- union {float f; uint32_t i;} u = {x};
- int e = (int)(u.i >> 23 & 0xff) - 0x7f;
- uint32_t m;
+float floorf(float x) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {x};
+ int e = (int)(u.i >> 23 & 0xff) - 0x7f;
+ uint32_t m;
- if (e >= 23)
- return x;
- if (e >= 0) {
- m = 0x007fffff >> e;
- if ((u.i & m) == 0)
- return x;
- FORCE_EVAL(x + 0x1p120f);
- if (u.i >> 31)
- u.i += m;
- u.i &= ~m;
- } else {
- FORCE_EVAL(x + 0x1p120f);
- if (u.i >> 31 == 0)
- u.i = 0;
- else if (u.i << 1)
- u.f = -1.0;
- }
- return u.f;
+ if (e >= 23)
+ return x;
+ if (e >= 0) {
+ m = 0x007fffff >> e;
+ if ((u.i & m) == 0)
+ return x;
+ FORCE_EVAL(x + 0x1p120f);
+ if (u.i >> 31)
+ u.i += m;
+ u.i &= ~m;
+ } else {
+ FORCE_EVAL(x + 0x1p120f);
+ if (u.i >> 31 == 0)
+ u.i = 0;
+ else if (u.i << 1)
+ u.f = -1.0;
+ }
+ return u.f;
}
diff --git a/fusl/src/math/floorl.c b/fusl/src/math/floorl.c
index 16aaec4..9a7703c 100644
--- a/fusl/src/math/floorl.c
+++ b/fusl/src/math/floorl.c
@@ -1,34 +1,32 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double floorl(long double x)
-{
- return floor(x);
+long double floorl(long double x) {
+ return floor(x);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-static const long double toint = 1/LDBL_EPSILON;
+static const long double toint = 1 / LDBL_EPSILON;
-long double floorl(long double x)
-{
- union ldshape u = {x};
- int e = u.i.se & 0x7fff;
- long double y;
+long double floorl(long double x) {
+ union ldshape u = {x};
+ int e = u.i.se & 0x7fff;
+ long double y;
- 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;
- }
- if (y > 0)
- return x + y - 1;
- return x + y;
+ 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;
+ }
+ if (y > 0)
+ return x + y - 1;
+ return x + y;
}
#endif
diff --git a/fusl/src/math/fma.c b/fusl/src/math/fma.c
index b4e685b..cec9e3b 100644
--- a/fusl/src/math/fma.c
+++ b/fusl/src/math/fma.c
@@ -1,168 +1,170 @@
#include <fenv.h>
#include "libm.h"
-#if LDBL_MANT_DIG==64 && LDBL_MAX_EXP==16384
+#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;
+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;
+ 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;
+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;
+ 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
+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;
+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;
+ 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 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);
+/* 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;
+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;
+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;
- }
+ /* 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
+ /* 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)
+ 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 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 {
+ 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);
+ int e = fetestexcept(FE_INEXACT);
+ feclearexcept(FE_INEXACT);
#endif
- z = hi + (lo1 + lo2);
+ 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);
+ if (getexp(z) < 0x3fff - 1022 && fetestexcept(FE_INEXACT))
+ feraiseexcept(FE_UNDERFLOW);
+ else if (e)
+ feraiseexcept(FE_INEXACT);
#endif
- }
- return z;
+ }
+ return z;
}
#else
/* origin: FreeBSD /usr/src/lib/msun/src/s_fma.c */
@@ -198,8 +200,8 @@
* bits of the result.
*/
struct dd {
- double hi;
- double lo;
+ double hi;
+ double lo;
};
/*
@@ -207,15 +209,14 @@
* 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;
+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);
+ ret.hi = a + b;
+ s = ret.hi - a;
+ ret.lo = (a - (ret.hi - s)) + (b - s);
+ return (ret);
}
/*
@@ -229,22 +230,24 @@
* 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;
+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);
+ 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);
}
/*
@@ -252,35 +255,37 @@
* 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;
+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);
+ 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);
+ /*
+ * 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);
}
/*
@@ -288,28 +293,27 @@
* 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;
+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 = a * split;
+ ha = a - p;
+ ha += p;
+ la = a - ha;
- p = b * split;
- hb = b - p;
- hb += p;
- lb = b - hb;
+ p = b * split;
+ hb = b - p;
+ hb += p;
+ lb = b - hb;
- p = ha * hb;
- q = ha * lb + la * hb;
+ p = ha * hb;
+ q = ha * lb + la * hb;
- ret.hi = p + q;
- ret.lo = p - ret.hi + q + la * lb;
- return (ret);
+ ret.hi = p + q;
+ ret.lo = p - ret.hi + q + la * lb;
+ return (ret);
}
/*
@@ -329,132 +333,131 @@
* 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;
+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);
+ /*
+ * 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;
+ 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) {
+ /*
+ * 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);
+ feraiseexcept(FE_INEXACT);
#endif
#ifdef FE_UNDERFLOW
- if (!isnormal(z))
- feraiseexcept(FE_UNDERFLOW);
+ if (!isnormal(z))
+ feraiseexcept(FE_UNDERFLOW);
#endif
- switch (oround) {
- default: /* FE_TONEAREST */
- return (z);
+ 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));
+ 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));
+ 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);
+ 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);
+ }
+ }
+ if (spread <= DBL_MANT_DIG * 2)
+ zs = scalbn(zs, -spread);
+ else
+ zs = copysign(DBL_MIN, zs);
- fesetround(FE_TONEAREST);
+ 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);
+ /*
+ * 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;
+ 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 (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 (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);
+ int e = fetestexcept(FE_INEXACT);
+ feclearexcept(FE_INEXACT);
#endif
- fesetround(oround);
- adj = r.lo + xy.lo;
- ret = scalbn(r.hi + adj, spread);
+ 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);
+ if (ilogb(ret) < -1022 && fetestexcept(FE_INEXACT))
+ feraiseexcept(FE_UNDERFLOW);
+ else if (e)
+ feraiseexcept(FE_INEXACT);
#endif
- return ret;
- }
+ 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);
+ 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
diff --git a/fusl/src/math/fmaf.c b/fusl/src/math/fmaf.c
index 4ebe855..b3ecd37 100644
--- a/fusl/src/math/fmaf.c
+++ b/fusl/src/math/fmaf.c
@@ -37,58 +37,60 @@
* direct double-precision arithmetic suffices, except where double
* rounding occurs.
*/
-float fmaf(float x, float y, float z)
-{
- PRAGMA_STDC_FENV_ACCESS_ON
- double xy, result;
- union {double f; uint64_t i;} u;
- int e;
+float fmaf(float x, float y, float z) {
+ PRAGMA_STDC_FENV_ACCESS_ON
+ double xy, result;
+ union {
+ double f;
+ uint64_t i;
+ } u;
+ int e;
- xy = (double)x * y;
- result = xy + z;
- u.f = result;
- e = u.i>>52 & 0x7ff;
- /* Common case: The double precision result is fine. */
- if ((u.i & 0x1fffffff) != 0x10000000 || /* not a halfway case */
- e == 0x7ff || /* NaN */
- result - xy == z || /* exact */
- fegetround() != FE_TONEAREST) /* not round-to-nearest */
- {
- /*
- underflow may not be raised correctly, example:
- fmaf(0x1p-120f, 0x1p-120f, 0x1p-149f)
- */
+ xy = (double)x * y;
+ result = xy + z;
+ u.f = result;
+ e = u.i >> 52 & 0x7ff;
+ /* Common case: The double precision result is fine. */
+ if ((u.i & 0x1fffffff) != 0x10000000 || /* not a halfway case */
+ e == 0x7ff || /* NaN */
+ result - xy == z || /* exact */
+ fegetround() != FE_TONEAREST) /* not round-to-nearest */
+ {
+/*
+underflow may not be raised correctly, example:
+fmaf(0x1p-120f, 0x1p-120f, 0x1p-149f)
+*/
#if defined(FE_INEXACT) && defined(FE_UNDERFLOW)
- if (e < 0x3ff-126 && e >= 0x3ff-149 && fetestexcept(FE_INEXACT)) {
- feclearexcept(FE_INEXACT);
- /* TODO: gcc and clang bug workaround */
- volatile float vz = z;
- result = xy + vz;
- if (fetestexcept(FE_INEXACT))
- feraiseexcept(FE_UNDERFLOW);
- else
- feraiseexcept(FE_INEXACT);
- }
+ if (e < 0x3ff - 126 && e >= 0x3ff - 149 && fetestexcept(FE_INEXACT)) {
+ feclearexcept(FE_INEXACT);
+ /* TODO: gcc and clang bug workaround */
+ volatile float vz = z;
+ result = xy + vz;
+ if (fetestexcept(FE_INEXACT))
+ feraiseexcept(FE_UNDERFLOW);
+ else
+ feraiseexcept(FE_INEXACT);
+ }
#endif
- z = result;
- return z;
- }
+ z = result;
+ return z;
+ }
- /*
- * If result is inexact, and exactly halfway between two float values,
- * we need to adjust the low-order bit in the direction of the error.
- */
+/*
+ * If result is inexact, and exactly halfway between two float values,
+ * we need to adjust the low-order bit in the direction of the error.
+ */
#ifdef FE_TOWARDZERO
- fesetround(FE_TOWARDZERO);
+ fesetround(FE_TOWARDZERO);
#endif
- volatile double vxy = xy; /* XXX work around gcc CSE bug */
- double adjusted_result = vxy + z;
- fesetround(FE_TONEAREST);
- if (result == adjusted_result) {
- u.f = adjusted_result;
- u.i++;
- adjusted_result = u.f;
- }
- z = adjusted_result;
- return z;
+ volatile double vxy = xy; /* XXX work around gcc CSE bug */
+ double adjusted_result = vxy + z;
+ fesetround(FE_TONEAREST);
+ if (result == adjusted_result) {
+ u.f = adjusted_result;
+ u.i++;
+ adjusted_result = u.f;
+ }
+ z = adjusted_result;
+ return z;
}
diff --git a/fusl/src/math/fmal.c b/fusl/src/math/fmal.c
index 41cf4c1..f82f43f 100644
--- a/fusl/src/math/fmal.c
+++ b/fusl/src/math/fmal.c
@@ -25,12 +25,10 @@
* SUCH DAMAGE.
*/
-
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double fmal(long double x, long double y, long double z)
-{
- return fma(x, y, z);
+long double fmal(long double x, long double y, long double z) {
+ return fma(x, y, z);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
#include <fenv.h>
@@ -48,8 +46,8 @@
* bits of the result.
*/
struct dd {
- long double hi;
- long double lo;
+ long double hi;
+ long double lo;
};
/*
@@ -57,15 +55,14 @@
* that both a and b are finite, but make no assumptions about their relative
* magnitudes.
*/
-static inline struct dd dd_add(long double a, long double b)
-{
- struct dd ret;
- long double s;
+static inline struct dd dd_add(long double a, long double b) {
+ struct dd ret;
+ long double s;
- ret.hi = a + b;
- s = ret.hi - a;
- ret.lo = (a - (ret.hi - s)) + (b - s);
- return (ret);
+ ret.hi = a + b;
+ s = ret.hi - a;
+ ret.lo = (a - (ret.hi - s)) + (b - s);
+ return (ret);
}
/*
@@ -79,18 +76,17 @@
* J. Coonen. An Implementation Guide to a Proposed Standard for
* Floating-Point Arithmetic. Computer, vol. 13, no. 1, Jan 1980.
*/
-static inline long double add_adjusted(long double a, long double b)
-{
- struct dd sum;
- union ldshape u;
+static inline long double add_adjusted(long double a, long double b) {
+ struct dd sum;
+ union ldshape u;
- sum = dd_add(a, b);
- if (sum.lo != 0) {
- u.f = sum.hi;
- if (!LASTBIT(u))
- sum.hi = nextafterl(sum.hi, INFINITY * sum.lo);
- }
- return (sum.hi);
+ sum = dd_add(a, b);
+ if (sum.lo != 0) {
+ u.f = sum.hi;
+ if (!LASTBIT(u))
+ sum.hi = nextafterl(sum.hi, INFINITY * sum.lo);
+ }
+ return (sum.hi);
}
/*
@@ -98,31 +94,32 @@
* that the result will be subnormal, and care is taken to ensure that
* double rounding does not occur.
*/
-static inline long double add_and_denormalize(long double a, long double b, int scale)
-{
- struct dd sum;
- int bits_lost;
- union ldshape u;
+static inline long double add_and_denormalize(long double a,
+ long double b,
+ int scale) {
+ struct dd sum;
+ int bits_lost;
+ union ldshape u;
- sum = dd_add(a, b);
+ 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) {
- u.f = sum.hi;
- bits_lost = -u.i.se - scale + 1;
- if ((bits_lost != 1) ^ LASTBIT(u))
- sum.hi = nextafterl(sum.hi, INFINITY * sum.lo);
- }
- return scalbnl(sum.hi, scale);
+ /*
+ * 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) {
+ u.f = sum.hi;
+ bits_lost = -u.i.se - scale + 1;
+ if ((bits_lost != 1) ^ LASTBIT(u))
+ sum.hi = nextafterl(sum.hi, INFINITY * sum.lo);
+ }
+ return scalbnl(sum.hi, scale);
}
/*
@@ -130,27 +127,26 @@
* 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(long double a, long double b)
-{
- struct dd ret;
- long double ha, hb, la, lb, p, q;
+static inline struct dd dd_mul(long double a, long double b) {
+ struct dd ret;
+ long double ha, hb, la, lb, p, q;
- p = a * SPLIT;
- ha = a - p;
- ha += p;
- la = a - ha;
+ p = a * SPLIT;
+ ha = a - p;
+ ha += p;
+ la = a - ha;
- p = b * SPLIT;
- hb = b - p;
- hb += p;
- lb = b - hb;
+ p = b * SPLIT;
+ hb = b - p;
+ hb += p;
+ lb = b - hb;
- p = ha * hb;
- q = ha * lb + la * hb;
+ p = ha * hb;
+ q = ha * lb + la * hb;
- ret.hi = p + q;
- ret.lo = p - ret.hi + q + la * lb;
- return (ret);
+ ret.hi = p + q;
+ ret.lo = p - ret.hi + q + la * lb;
+ return (ret);
}
/*
@@ -162,132 +158,131 @@
* Dekker, T. A Floating-Point Technique for Extending the
* Available Precision. Numer. Math. 18, 224-242 (1971).
*/
-long double fmal(long double x, long double y, long double z)
-{
- PRAGMA_STDC_FENV_ACCESS_ON
- long double xs, ys, zs, adj;
- struct dd xy, r;
- int oround;
- int ex, ey, ez;
- int spread;
+long double fmal(long double x, long double y, long double z) {
+ PRAGMA_STDC_FENV_ACCESS_ON
+ long 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);
+ /*
+ * 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 = frexpl(x, &ex);
- ys = frexpl(y, &ey);
- zs = frexpl(z, &ez);
- oround = fegetround();
- spread = ex + ey - ez;
+ xs = frexpl(x, &ex);
+ ys = frexpl(y, &ey);
+ zs = frexpl(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 < -LDBL_MANT_DIG) {
+ /*
+ * 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 < -LDBL_MANT_DIG) {
#ifdef FE_INEXACT
- feraiseexcept(FE_INEXACT);
+ feraiseexcept(FE_INEXACT);
#endif
#ifdef FE_UNDERFLOW
- if (!isnormal(z))
- feraiseexcept(FE_UNDERFLOW);
+ if (!isnormal(z))
+ feraiseexcept(FE_UNDERFLOW);
#endif
- switch (oround) {
- default: /* FE_TONEAREST */
- return (z);
+ 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 (nextafterl(z, 0));
+ case FE_TOWARDZERO:
+ if (x > 0.0 ^ y < 0.0 ^ z < 0.0)
+ return (z);
+ else
+ return (nextafterl(z, 0));
#endif
#ifdef FE_DOWNWARD
- case FE_DOWNWARD:
- if (x > 0.0 ^ y < 0.0)
- return (z);
- else
- return (nextafterl(z, -INFINITY));
+ case FE_DOWNWARD:
+ if (x > 0.0 ^ y < 0.0)
+ return (z);
+ else
+ return (nextafterl(z, -INFINITY));
#endif
#ifdef FE_UPWARD
- case FE_UPWARD:
- if (x > 0.0 ^ y < 0.0)
- return (nextafterl(z, INFINITY));
- else
- return (z);
+ case FE_UPWARD:
+ if (x > 0.0 ^ y < 0.0)
+ return (nextafterl(z, INFINITY));
+ else
+ return (z);
#endif
- }
- }
- if (spread <= LDBL_MANT_DIG * 2)
- zs = scalbnl(zs, -spread);
- else
- zs = copysignl(LDBL_MIN, zs);
+ }
+ }
+ if (spread <= LDBL_MANT_DIG * 2)
+ zs = scalbnl(zs, -spread);
+ else
+ zs = copysignl(LDBL_MIN, zs);
- fesetround(FE_TONEAREST);
+ 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);
+ /*
+ * 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;
+ 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 long double vzs = zs; /* XXX gcc CSE bug workaround */
- return xy.hi + vzs + scalbnl(xy.lo, spread);
- }
+ if (r.hi == 0.0) {
+ /*
+ * When the addends cancel to 0, ensure that the result has
+ * the correct sign.
+ */
+ fesetround(oround);
+ volatile long double vzs = zs; /* XXX gcc CSE bug workaround */
+ return xy.hi + vzs + scalbnl(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 correctly, example in downward rounding:
- * fmal(0x1.0000000001p-16000L, 0x1.0000000001p-400L, -0x1p-16440L)
- */
- long double ret;
+ if (oround != FE_TONEAREST) {
+ /*
+ * There is no need to worry about double rounding in directed
+ * rounding modes.
+ * But underflow may not be raised correctly, example in downward rounding:
+ * fmal(0x1.0000000001p-16000L, 0x1.0000000001p-400L, -0x1p-16440L)
+ */
+ long double ret;
#if defined(FE_INEXACT) && defined(FE_UNDERFLOW)
- int e = fetestexcept(FE_INEXACT);
- feclearexcept(FE_INEXACT);
+ int e = fetestexcept(FE_INEXACT);
+ feclearexcept(FE_INEXACT);
#endif
- fesetround(oround);
- adj = r.lo + xy.lo;
- ret = scalbnl(r.hi + adj, spread);
+ fesetround(oround);
+ adj = r.lo + xy.lo;
+ ret = scalbnl(r.hi + adj, spread);
#if defined(FE_INEXACT) && defined(FE_UNDERFLOW)
- if (ilogbl(ret) < -16382 && fetestexcept(FE_INEXACT))
- feraiseexcept(FE_UNDERFLOW);
- else if (e)
- feraiseexcept(FE_INEXACT);
+ if (ilogbl(ret) < -16382 && fetestexcept(FE_INEXACT))
+ feraiseexcept(FE_UNDERFLOW);
+ else if (e)
+ feraiseexcept(FE_INEXACT);
#endif
- return ret;
- }
+ return ret;
+ }
- adj = add_adjusted(r.lo, xy.lo);
- if (spread + ilogbl(r.hi) > -16383)
- return scalbnl(r.hi + adj, spread);
- else
- return add_and_denormalize(r.hi, adj, spread);
+ adj = add_adjusted(r.lo, xy.lo);
+ if (spread + ilogbl(r.hi) > -16383)
+ return scalbnl(r.hi + adj, spread);
+ else
+ return add_and_denormalize(r.hi, adj, spread);
}
#endif
diff --git a/fusl/src/math/fmax.c b/fusl/src/math/fmax.c
index 94f0caa..ff7a232 100644
--- a/fusl/src/math/fmax.c
+++ b/fusl/src/math/fmax.c
@@ -1,13 +1,12 @@
#include <math.h>
-double fmax(double x, double y)
-{
- if (isnan(x))
- return y;
- if (isnan(y))
- return x;
- /* handle signed zeros, see C99 Annex F.9.9.2 */
- if (signbit(x) != signbit(y))
- return signbit(x) ? y : x;
- return x < y ? y : x;
+double fmax(double x, double y) {
+ if (isnan(x))
+ return y;
+ if (isnan(y))
+ return x;
+ /* handle signed zeros, see C99 Annex F.9.9.2 */
+ if (signbit(x) != signbit(y))
+ return signbit(x) ? y : x;
+ return x < y ? y : x;
}
diff --git a/fusl/src/math/fmaxf.c b/fusl/src/math/fmaxf.c
index 695d817..f7abc0b 100644
--- a/fusl/src/math/fmaxf.c
+++ b/fusl/src/math/fmaxf.c
@@ -1,13 +1,12 @@
#include <math.h>
-float fmaxf(float x, float y)
-{
- if (isnan(x))
- return y;
- if (isnan(y))
- return x;
- /* handle signed zeroes, see C99 Annex F.9.9.2 */
- if (signbit(x) != signbit(y))
- return signbit(x) ? y : x;
- return x < y ? y : x;
+float fmaxf(float x, float y) {
+ if (isnan(x))
+ return y;
+ if (isnan(y))
+ return x;
+ /* handle signed zeroes, see C99 Annex F.9.9.2 */
+ if (signbit(x) != signbit(y))
+ return signbit(x) ? y : x;
+ return x < y ? y : x;
}
diff --git a/fusl/src/math/fmaxl.c b/fusl/src/math/fmaxl.c
index 4b03158..b4d672e 100644
--- a/fusl/src/math/fmaxl.c
+++ b/fusl/src/math/fmaxl.c
@@ -2,20 +2,18 @@
#include <float.h>
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double fmaxl(long double x, long double y)
-{
- return fmax(x, y);
+long double fmaxl(long double x, long double y) {
+ return fmax(x, y);
}
#else
-long double fmaxl(long double x, long double y)
-{
- if (isnan(x))
- return y;
- if (isnan(y))
- return x;
- /* handle signed zeros, see C99 Annex F.9.9.2 */
- if (signbit(x) != signbit(y))
- return signbit(x) ? y : x;
- return x < y ? y : x;
+long double fmaxl(long double x, long double y) {
+ if (isnan(x))
+ return y;
+ if (isnan(y))
+ return x;
+ /* handle signed zeros, see C99 Annex F.9.9.2 */
+ if (signbit(x) != signbit(y))
+ return signbit(x) ? y : x;
+ return x < y ? y : x;
}
#endif
diff --git a/fusl/src/math/fmin.c b/fusl/src/math/fmin.c
index 08a8fd1..3d40d3d 100644
--- a/fusl/src/math/fmin.c
+++ b/fusl/src/math/fmin.c
@@ -1,13 +1,12 @@
#include <math.h>
-double fmin(double x, double y)
-{
- if (isnan(x))
- return y;
- if (isnan(y))
- return x;
- /* handle signed zeros, see C99 Annex F.9.9.2 */
- if (signbit(x) != signbit(y))
- return signbit(x) ? x : y;
- return x < y ? x : y;
+double fmin(double x, double y) {
+ if (isnan(x))
+ return y;
+ if (isnan(y))
+ return x;
+ /* handle signed zeros, see C99 Annex F.9.9.2 */
+ if (signbit(x) != signbit(y))
+ return signbit(x) ? x : y;
+ return x < y ? x : y;
}
diff --git a/fusl/src/math/fminf.c b/fusl/src/math/fminf.c
index 3573c7d..7f0eceb 100644
--- a/fusl/src/math/fminf.c
+++ b/fusl/src/math/fminf.c
@@ -1,13 +1,12 @@
#include <math.h>
-float fminf(float x, float y)
-{
- if (isnan(x))
- return y;
- if (isnan(y))
- return x;
- /* handle signed zeros, see C99 Annex F.9.9.2 */
- if (signbit(x) != signbit(y))
- return signbit(x) ? x : y;
- return x < y ? x : y;
+float fminf(float x, float y) {
+ if (isnan(x))
+ return y;
+ if (isnan(y))
+ return x;
+ /* handle signed zeros, see C99 Annex F.9.9.2 */
+ if (signbit(x) != signbit(y))
+ return signbit(x) ? x : y;
+ return x < y ? x : y;
}
diff --git a/fusl/src/math/fminl.c b/fusl/src/math/fminl.c
index 69bc24a..7b89397 100644
--- a/fusl/src/math/fminl.c
+++ b/fusl/src/math/fminl.c
@@ -2,20 +2,18 @@
#include <float.h>
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double fminl(long double x, long double y)
-{
- return fmin(x, y);
+long double fminl(long double x, long double y) {
+ return fmin(x, y);
}
#else
-long double fminl(long double x, long double y)
-{
- if (isnan(x))
- return y;
- if (isnan(y))
- return x;
- /* handle signed zeros, see C99 Annex F.9.9.2 */
- if (signbit(x) != signbit(y))
- return signbit(x) ? x : y;
- return x < y ? x : y;
+long double fminl(long double x, long double y) {
+ if (isnan(x))
+ return y;
+ if (isnan(y))
+ return x;
+ /* handle signed zeros, see C99 Annex F.9.9.2 */
+ if (signbit(x) != signbit(y))
+ return signbit(x) ? x : y;
+ return x < y ? x : y;
}
#endif
diff --git a/fusl/src/math/fmod.c b/fusl/src/math/fmod.c
index 6849722..7caea97 100644
--- a/fusl/src/math/fmod.c
+++ b/fusl/src/math/fmod.c
@@ -1,68 +1,73 @@
#include <math.h>
#include <stdint.h>
-double fmod(double x, double y)
-{
- union {double f; uint64_t i;} ux = {x}, uy = {y};
- int ex = ux.i>>52 & 0x7ff;
- int ey = uy.i>>52 & 0x7ff;
- int sx = ux.i>>63;
- uint64_t i;
+double fmod(double x, double y) {
+ union {
+ double f;
+ uint64_t i;
+ } ux = {x}, uy = {y};
+ int ex = ux.i >> 52 & 0x7ff;
+ int ey = uy.i >> 52 & 0x7ff;
+ int sx = ux.i >> 63;
+ uint64_t i;
- /* in the followings uxi should be ux.i, but then gcc wrongly adds */
- /* float load/store to inner loops ruining performance and code size */
- uint64_t uxi = ux.i;
+ /* in the followings uxi should be ux.i, but then gcc wrongly adds */
+ /* float load/store to inner loops ruining performance and code size */
+ uint64_t uxi = ux.i;
- if (uy.i<<1 == 0 || isnan(y) || ex == 0x7ff)
- return (x*y)/(x*y);
- if (uxi<<1 <= uy.i<<1) {
- if (uxi<<1 == uy.i<<1)
- return 0*x;
- return x;
- }
+ if (uy.i << 1 == 0 || isnan(y) || ex == 0x7ff)
+ return (x * y) / (x * y);
+ if (uxi << 1 <= uy.i << 1) {
+ if (uxi << 1 == uy.i << 1)
+ return 0 * x;
+ return x;
+ }
- /* normalize x and y */
- if (!ex) {
- for (i = uxi<<12; i>>63 == 0; ex--, i <<= 1);
- uxi <<= -ex + 1;
- } else {
- uxi &= -1ULL >> 12;
- uxi |= 1ULL << 52;
- }
- if (!ey) {
- for (i = uy.i<<12; i>>63 == 0; ey--, i <<= 1);
- uy.i <<= -ey + 1;
- } else {
- uy.i &= -1ULL >> 12;
- uy.i |= 1ULL << 52;
- }
+ /* normalize x and y */
+ if (!ex) {
+ for (i = uxi << 12; i >> 63 == 0; ex--, i <<= 1)
+ ;
+ uxi <<= -ex + 1;
+ } else {
+ uxi &= -1ULL >> 12;
+ uxi |= 1ULL << 52;
+ }
+ if (!ey) {
+ for (i = uy.i << 12; i >> 63 == 0; ey--, i <<= 1)
+ ;
+ uy.i <<= -ey + 1;
+ } else {
+ uy.i &= -1ULL >> 12;
+ uy.i |= 1ULL << 52;
+ }
- /* x mod y */
- for (; ex > ey; ex--) {
- i = uxi - uy.i;
- if (i >> 63 == 0) {
- if (i == 0)
- return 0*x;
- uxi = i;
- }
- uxi <<= 1;
- }
- i = uxi - uy.i;
- if (i >> 63 == 0) {
- if (i == 0)
- return 0*x;
- uxi = i;
- }
- for (; uxi>>52 == 0; uxi <<= 1, ex--);
+ /* x mod y */
+ for (; ex > ey; ex--) {
+ i = uxi - uy.i;
+ if (i >> 63 == 0) {
+ if (i == 0)
+ return 0 * x;
+ uxi = i;
+ }
+ uxi <<= 1;
+ }
+ i = uxi - uy.i;
+ if (i >> 63 == 0) {
+ if (i == 0)
+ return 0 * x;
+ uxi = i;
+ }
+ for (; uxi >> 52 == 0; uxi <<= 1, ex--)
+ ;
- /* scale result */
- if (ex > 0) {
- uxi -= 1ULL << 52;
- uxi |= (uint64_t)ex << 52;
- } else {
- uxi >>= -ex + 1;
- }
- uxi |= (uint64_t)sx << 63;
- ux.i = uxi;
- return ux.f;
+ /* scale result */
+ if (ex > 0) {
+ uxi -= 1ULL << 52;
+ uxi |= (uint64_t)ex << 52;
+ } else {
+ uxi >>= -ex + 1;
+ }
+ uxi |= (uint64_t)sx << 63;
+ ux.i = uxi;
+ return ux.f;
}
diff --git a/fusl/src/math/fmodf.c b/fusl/src/math/fmodf.c
index ff58f93..4fe65af 100644
--- a/fusl/src/math/fmodf.c
+++ b/fusl/src/math/fmodf.c
@@ -1,65 +1,70 @@
#include <math.h>
#include <stdint.h>
-float fmodf(float x, float y)
-{
- union {float f; uint32_t i;} ux = {x}, uy = {y};
- int ex = ux.i>>23 & 0xff;
- int ey = uy.i>>23 & 0xff;
- uint32_t sx = ux.i & 0x80000000;
- uint32_t i;
- uint32_t uxi = ux.i;
+float fmodf(float x, float y) {
+ union {
+ float f;
+ uint32_t i;
+ } ux = {x}, uy = {y};
+ int ex = ux.i >> 23 & 0xff;
+ int ey = uy.i >> 23 & 0xff;
+ uint32_t sx = ux.i & 0x80000000;
+ uint32_t i;
+ uint32_t uxi = ux.i;
- if (uy.i<<1 == 0 || isnan(y) || ex == 0xff)
- return (x*y)/(x*y);
- if (uxi<<1 <= uy.i<<1) {
- if (uxi<<1 == uy.i<<1)
- return 0*x;
- return x;
- }
+ if (uy.i << 1 == 0 || isnan(y) || ex == 0xff)
+ return (x * y) / (x * y);
+ if (uxi << 1 <= uy.i << 1) {
+ if (uxi << 1 == uy.i << 1)
+ return 0 * x;
+ return x;
+ }
- /* normalize x and y */
- if (!ex) {
- for (i = uxi<<9; i>>31 == 0; ex--, i <<= 1);
- uxi <<= -ex + 1;
- } else {
- uxi &= -1U >> 9;
- uxi |= 1U << 23;
- }
- if (!ey) {
- for (i = uy.i<<9; i>>31 == 0; ey--, i <<= 1);
- uy.i <<= -ey + 1;
- } else {
- uy.i &= -1U >> 9;
- uy.i |= 1U << 23;
- }
+ /* normalize x and y */
+ if (!ex) {
+ for (i = uxi << 9; i >> 31 == 0; ex--, i <<= 1)
+ ;
+ uxi <<= -ex + 1;
+ } else {
+ uxi &= -1U >> 9;
+ uxi |= 1U << 23;
+ }
+ if (!ey) {
+ for (i = uy.i << 9; i >> 31 == 0; ey--, i <<= 1)
+ ;
+ uy.i <<= -ey + 1;
+ } else {
+ uy.i &= -1U >> 9;
+ uy.i |= 1U << 23;
+ }
- /* x mod y */
- for (; ex > ey; ex--) {
- i = uxi - uy.i;
- if (i >> 31 == 0) {
- if (i == 0)
- return 0*x;
- uxi = i;
- }
- uxi <<= 1;
- }
- i = uxi - uy.i;
- if (i >> 31 == 0) {
- if (i == 0)
- return 0*x;
- uxi = i;
- }
- for (; uxi>>23 == 0; uxi <<= 1, ex--);
+ /* x mod y */
+ for (; ex > ey; ex--) {
+ i = uxi - uy.i;
+ if (i >> 31 == 0) {
+ if (i == 0)
+ return 0 * x;
+ uxi = i;
+ }
+ uxi <<= 1;
+ }
+ i = uxi - uy.i;
+ if (i >> 31 == 0) {
+ if (i == 0)
+ return 0 * x;
+ uxi = i;
+ }
+ for (; uxi >> 23 == 0; uxi <<= 1, ex--)
+ ;
- /* scale result up */
- if (ex > 0) {
- uxi -= 1U << 23;
- uxi |= (uint32_t)ex << 23;
- } else {
- uxi >>= -ex + 1;
- }
- uxi |= sx;
- ux.i = uxi;
- return ux.f;
+ /* scale result up */
+ if (ex > 0) {
+ uxi -= 1U << 23;
+ uxi |= (uint32_t)ex << 23;
+ } else {
+ uxi >>= -ex + 1;
+ }
+ uxi |= sx;
+ ux.i = uxi;
+ return ux.f;
}
diff --git a/fusl/src/math/fmodl.c b/fusl/src/math/fmodl.c
index 9f5b873..8c8b420 100644
--- a/fusl/src/math/fmodl.c
+++ b/fusl/src/math/fmodl.c
@@ -1,105 +1,105 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double fmodl(long double x, long double y)
-{
- return fmod(x, y);
+long double fmodl(long double x, long double y) {
+ return fmod(x, y);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-long double fmodl(long double x, long double y)
-{
- union ldshape ux = {x}, uy = {y};
- int ex = ux.i.se & 0x7fff;
- int ey = uy.i.se & 0x7fff;
- int sx = ux.i.se & 0x8000;
+long double fmodl(long double x, long double y) {
+ union ldshape ux = {x}, uy = {y};
+ int ex = ux.i.se & 0x7fff;
+ int ey = uy.i.se & 0x7fff;
+ int sx = ux.i.se & 0x8000;
- if (y == 0 || isnan(y) || ex == 0x7fff)
- return (x*y)/(x*y);
- ux.i.se = ex;
- uy.i.se = ey;
- if (ux.f <= uy.f) {
- if (ux.f == uy.f)
- return 0*x;
- return x;
- }
+ if (y == 0 || isnan(y) || ex == 0x7fff)
+ return (x * y) / (x * y);
+ ux.i.se = ex;
+ uy.i.se = ey;
+ if (ux.f <= uy.f) {
+ if (ux.f == uy.f)
+ return 0 * x;
+ return x;
+ }
- /* normalize x and y */
- if (!ex) {
- ux.f *= 0x1p120f;
- ex = ux.i.se - 120;
- }
- if (!ey) {
- uy.f *= 0x1p120f;
- ey = uy.i.se - 120;
- }
+ /* normalize x and y */
+ if (!ex) {
+ ux.f *= 0x1p120f;
+ ex = ux.i.se - 120;
+ }
+ if (!ey) {
+ uy.f *= 0x1p120f;
+ ey = uy.i.se - 120;
+ }
- /* x mod y */
+/* x mod y */
#if LDBL_MANT_DIG == 64
- uint64_t i, mx, my;
- mx = ux.i.m;
- my = uy.i.m;
- for (; ex > ey; ex--) {
- i = mx - my;
- if (mx >= my) {
- if (i == 0)
- return 0*x;
- mx = 2*i;
- } else if (2*mx < mx) {
- mx = 2*mx - my;
- } else {
- mx = 2*mx;
- }
- }
- i = mx - my;
- if (mx >= my) {
- if (i == 0)
- return 0*x;
- mx = i;
- }
- for (; mx >> 63 == 0; mx *= 2, ex--);
- ux.i.m = mx;
+ uint64_t i, mx, my;
+ mx = ux.i.m;
+ my = uy.i.m;
+ for (; ex > ey; ex--) {
+ i = mx - my;
+ if (mx >= my) {
+ if (i == 0)
+ return 0 * x;
+ mx = 2 * i;
+ } else if (2 * mx < mx) {
+ mx = 2 * mx - my;
+ } else {
+ mx = 2 * mx;
+ }
+ }
+ i = mx - my;
+ if (mx >= my) {
+ if (i == 0)
+ return 0 * x;
+ mx = i;
+ }
+ for (; mx >> 63 == 0; mx *= 2, ex--)
+ ;
+ ux.i.m = mx;
#elif LDBL_MANT_DIG == 113
- uint64_t hi, lo, xhi, xlo, yhi, ylo;
- xhi = (ux.i2.hi & -1ULL>>16) | 1ULL<<48;
- yhi = (uy.i2.hi & -1ULL>>16) | 1ULL<<48;
- xlo = ux.i2.lo;
- ylo = uy.i2.lo;
- for (; ex > ey; ex--) {
- hi = xhi - yhi;
- lo = xlo - ylo;
- if (xlo < ylo)
- hi -= 1;
- if (hi >> 63 == 0) {
- if ((hi|lo) == 0)
- return 0*x;
- xhi = 2*hi + (lo>>63);
- xlo = 2*lo;
- } else {
- xhi = 2*xhi + (xlo>>63);
- xlo = 2*xlo;
- }
- }
- hi = xhi - yhi;
- lo = xlo - ylo;
- if (xlo < ylo)
- hi -= 1;
- if (hi >> 63 == 0) {
- if ((hi|lo) == 0)
- return 0*x;
- xhi = hi;
- xlo = lo;
- }
- for (; xhi >> 48 == 0; xhi = 2*xhi + (xlo>>63), xlo = 2*xlo, ex--);
- ux.i2.hi = xhi;
- ux.i2.lo = xlo;
+ uint64_t hi, lo, xhi, xlo, yhi, ylo;
+ xhi = (ux.i2.hi & -1ULL >> 16) | 1ULL << 48;
+ yhi = (uy.i2.hi & -1ULL >> 16) | 1ULL << 48;
+ xlo = ux.i2.lo;
+ ylo = uy.i2.lo;
+ for (; ex > ey; ex--) {
+ hi = xhi - yhi;
+ lo = xlo - ylo;
+ if (xlo < ylo)
+ hi -= 1;
+ if (hi >> 63 == 0) {
+ if ((hi | lo) == 0)
+ return 0 * x;
+ xhi = 2 * hi + (lo >> 63);
+ xlo = 2 * lo;
+ } else {
+ xhi = 2 * xhi + (xlo >> 63);
+ xlo = 2 * xlo;
+ }
+ }
+ hi = xhi - yhi;
+ lo = xlo - ylo;
+ if (xlo < ylo)
+ hi -= 1;
+ if (hi >> 63 == 0) {
+ if ((hi | lo) == 0)
+ return 0 * x;
+ xhi = hi;
+ xlo = lo;
+ }
+ for (; xhi >> 48 == 0; xhi = 2 * xhi + (xlo >> 63), xlo = 2 * xlo, ex--)
+ ;
+ ux.i2.hi = xhi;
+ ux.i2.lo = xlo;
#endif
- /* scale result */
- if (ex <= 0) {
- ux.i.se = (ex+120)|sx;
- ux.f *= 0x1p-120f;
- } else
- ux.i.se = ex|sx;
- return ux.f;
+ /* scale result */
+ if (ex <= 0) {
+ ux.i.se = (ex + 120) | sx;
+ ux.f *= 0x1p-120f;
+ } else
+ ux.i.se = ex | sx;
+ return ux.f;
}
#endif
diff --git a/fusl/src/math/frexp.c b/fusl/src/math/frexp.c
index 27b6266..594c37b 100644
--- a/fusl/src/math/frexp.c
+++ b/fusl/src/math/frexp.c
@@ -1,23 +1,26 @@
#include <math.h>
#include <stdint.h>
-double frexp(double x, int *e)
-{
- union { double d; uint64_t i; } y = { x };
- int ee = y.i>>52 & 0x7ff;
+double frexp(double x, int* e) {
+ union {
+ double d;
+ uint64_t i;
+ } y = {x};
+ int ee = y.i >> 52 & 0x7ff;
- if (!ee) {
- if (x) {
- x = frexp(x*0x1p64, e);
- *e -= 64;
- } else *e = 0;
- return x;
- } else if (ee == 0x7ff) {
- return x;
- }
+ if (!ee) {
+ if (x) {
+ x = frexp(x * 0x1p64, e);
+ *e -= 64;
+ } else
+ *e = 0;
+ return x;
+ } else if (ee == 0x7ff) {
+ return x;
+ }
- *e = ee - 0x3fe;
- y.i &= 0x800fffffffffffffull;
- y.i |= 0x3fe0000000000000ull;
- return y.d;
+ *e = ee - 0x3fe;
+ y.i &= 0x800fffffffffffffull;
+ y.i |= 0x3fe0000000000000ull;
+ return y.d;
}
diff --git a/fusl/src/math/frexpf.c b/fusl/src/math/frexpf.c
index 0787097..63ac662 100644
--- a/fusl/src/math/frexpf.c
+++ b/fusl/src/math/frexpf.c
@@ -1,23 +1,26 @@
#include <math.h>
#include <stdint.h>
-float frexpf(float x, int *e)
-{
- union { float f; uint32_t i; } y = { x };
- int ee = y.i>>23 & 0xff;
+float frexpf(float x, int* e) {
+ union {
+ float f;
+ uint32_t i;
+ } y = {x};
+ int ee = y.i >> 23 & 0xff;
- if (!ee) {
- if (x) {
- x = frexpf(x*0x1p64, e);
- *e -= 64;
- } else *e = 0;
- return x;
- } else if (ee == 0xff) {
- return x;
- }
+ if (!ee) {
+ if (x) {
+ x = frexpf(x * 0x1p64, e);
+ *e -= 64;
+ } else
+ *e = 0;
+ return x;
+ } else if (ee == 0xff) {
+ return x;
+ }
- *e = ee - 0x7e;
- y.i &= 0x807ffffful;
- y.i |= 0x3f000000ul;
- return y.f;
+ *e = ee - 0x7e;
+ y.i &= 0x807ffffful;
+ y.i |= 0x3f000000ul;
+ return y.f;
}
diff --git a/fusl/src/math/frexpl.c b/fusl/src/math/frexpl.c
index 3c1b553..869e962 100644
--- a/fusl/src/math/frexpl.c
+++ b/fusl/src/math/frexpl.c
@@ -1,29 +1,28 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double frexpl(long double x, int *e)
-{
- return frexp(x, e);
+long double frexpl(long double x, int* e) {
+ return frexp(x, e);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-long double frexpl(long double x, int *e)
-{
- union ldshape u = {x};
- int ee = u.i.se & 0x7fff;
+long double frexpl(long double x, int* e) {
+ union ldshape u = {x};
+ int ee = u.i.se & 0x7fff;
- if (!ee) {
- if (x) {
- x = frexpl(x*0x1p120, e);
- *e -= 120;
- } else *e = 0;
- return x;
- } else if (ee == 0x7fff) {
- return x;
- }
+ if (!ee) {
+ if (x) {
+ x = frexpl(x * 0x1p120, e);
+ *e -= 120;
+ } else
+ *e = 0;
+ return x;
+ } else if (ee == 0x7fff) {
+ return x;
+ }
- *e = ee - 0x3ffe;
- u.i.se &= 0x8000;
- u.i.se |= 0x3ffe;
- return u.f;
+ *e = ee - 0x3ffe;
+ u.i.se &= 0x8000;
+ u.i.se |= 0x3ffe;
+ return u.f;
}
#endif
diff --git a/fusl/src/math/hypot.c b/fusl/src/math/hypot.c
index 6071bf1..5f9888d 100644
--- a/fusl/src/math/hypot.c
+++ b/fusl/src/math/hypot.c
@@ -8,60 +8,61 @@
#define SPLIT (0x1p27 + 1)
#endif
-static void sq(double_t *hi, double_t *lo, double x)
-{
- double_t xh, xl, xc;
+static void sq(double_t* hi, double_t* lo, double x) {
+ double_t xh, xl, xc;
- xc = (double_t)x*SPLIT;
- xh = x - xc + xc;
- xl = x - xh;
- *hi = (double_t)x*x;
- *lo = xh*xh - *hi + 2*xh*xl + xl*xl;
+ xc = (double_t)x * SPLIT;
+ xh = x - xc + xc;
+ xl = x - xh;
+ *hi = (double_t)x * x;
+ *lo = xh * xh - *hi + 2 * xh * xl + xl * xl;
}
-double hypot(double x, double y)
-{
- union {double f; uint64_t i;} ux = {x}, uy = {y}, ut;
- int ex, ey;
- double_t hx, lx, hy, ly, z;
+double hypot(double x, double y) {
+ union {
+ double f;
+ uint64_t i;
+ } ux = {x}, uy = {y}, ut;
+ int ex, ey;
+ double_t hx, lx, hy, ly, z;
- /* arrange |x| >= |y| */
- ux.i &= -1ULL>>1;
- uy.i &= -1ULL>>1;
- if (ux.i < uy.i) {
- ut = ux;
- ux = uy;
- uy = ut;
- }
+ /* arrange |x| >= |y| */
+ ux.i &= -1ULL >> 1;
+ uy.i &= -1ULL >> 1;
+ if (ux.i < uy.i) {
+ ut = ux;
+ ux = uy;
+ uy = ut;
+ }
- /* special cases */
- ex = ux.i>>52;
- ey = uy.i>>52;
- x = ux.f;
- y = uy.f;
- /* note: hypot(inf,nan) == inf */
- if (ey == 0x7ff)
- return y;
- if (ex == 0x7ff || uy.i == 0)
- return x;
- /* note: hypot(x,y) ~= x + y*y/x/2 with inexact for small y/x */
- /* 64 difference is enough for ld80 double_t */
- if (ex - ey > 64)
- return x + y;
+ /* special cases */
+ ex = ux.i >> 52;
+ ey = uy.i >> 52;
+ x = ux.f;
+ y = uy.f;
+ /* note: hypot(inf,nan) == inf */
+ if (ey == 0x7ff)
+ return y;
+ if (ex == 0x7ff || uy.i == 0)
+ return x;
+ /* note: hypot(x,y) ~= x + y*y/x/2 with inexact for small y/x */
+ /* 64 difference is enough for ld80 double_t */
+ if (ex - ey > 64)
+ return x + y;
- /* precise sqrt argument in nearest rounding mode without overflow */
- /* xh*xh must not overflow and xl*xl must not underflow in sq */
- z = 1;
- if (ex > 0x3ff+510) {
- z = 0x1p700;
- x *= 0x1p-700;
- y *= 0x1p-700;
- } else if (ey < 0x3ff-450) {
- z = 0x1p-700;
- x *= 0x1p700;
- y *= 0x1p700;
- }
- sq(&hx, &lx, x);
- sq(&hy, &ly, y);
- return z*sqrt(ly+lx+hy+hx);
+ /* precise sqrt argument in nearest rounding mode without overflow */
+ /* xh*xh must not overflow and xl*xl must not underflow in sq */
+ z = 1;
+ if (ex > 0x3ff + 510) {
+ z = 0x1p700;
+ x *= 0x1p-700;
+ y *= 0x1p-700;
+ } else if (ey < 0x3ff - 450) {
+ z = 0x1p-700;
+ x *= 0x1p700;
+ y *= 0x1p700;
+ }
+ sq(&hx, &lx, x);
+ sq(&hy, &ly, y);
+ return z * sqrt(ly + lx + hy + hx);
}
diff --git a/fusl/src/math/hypotf.c b/fusl/src/math/hypotf.c
index 2fc214b..6f4ad03 100644
--- a/fusl/src/math/hypotf.c
+++ b/fusl/src/math/hypotf.c
@@ -1,35 +1,37 @@
#include <math.h>
#include <stdint.h>
-float hypotf(float x, float y)
-{
- union {float f; uint32_t i;} ux = {x}, uy = {y}, ut;
- float_t z;
+float hypotf(float x, float y) {
+ union {
+ float f;
+ uint32_t i;
+ } ux = {x}, uy = {y}, ut;
+ float_t z;
- ux.i &= -1U>>1;
- uy.i &= -1U>>1;
- if (ux.i < uy.i) {
- ut = ux;
- ux = uy;
- uy = ut;
- }
+ ux.i &= -1U >> 1;
+ uy.i &= -1U >> 1;
+ if (ux.i < uy.i) {
+ ut = ux;
+ ux = uy;
+ uy = ut;
+ }
- x = ux.f;
- y = uy.f;
- if (uy.i == 0xff<<23)
- return y;
- if (ux.i >= 0xff<<23 || uy.i == 0 || ux.i - uy.i >= 25<<23)
- return x + y;
+ x = ux.f;
+ y = uy.f;
+ if (uy.i == 0xff << 23)
+ return y;
+ if (ux.i >= 0xff << 23 || uy.i == 0 || ux.i - uy.i >= 25 << 23)
+ return x + y;
- z = 1;
- if (ux.i >= (0x7f+60)<<23) {
- z = 0x1p90f;
- x *= 0x1p-90f;
- y *= 0x1p-90f;
- } else if (uy.i < (0x7f-60)<<23) {
- z = 0x1p-90f;
- x *= 0x1p90f;
- y *= 0x1p90f;
- }
- return z*sqrtf((double)x*x + (double)y*y);
+ z = 1;
+ if (ux.i >= (0x7f + 60) << 23) {
+ z = 0x1p90f;
+ x *= 0x1p-90f;
+ y *= 0x1p-90f;
+ } else if (uy.i < (0x7f - 60) << 23) {
+ z = 0x1p-90f;
+ x *= 0x1p90f;
+ y *= 0x1p90f;
+ }
+ return z * sqrtf((double)x * x + (double)y * y);
}
diff --git a/fusl/src/math/hypotl.c b/fusl/src/math/hypotl.c
index 479aa92..543e1c2 100644
--- a/fusl/src/math/hypotl.c
+++ b/fusl/src/math/hypotl.c
@@ -1,66 +1,63 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double hypotl(long double x, long double y)
-{
- return hypot(x, y);
+long double hypotl(long double x, long double y) {
+ return hypot(x, y);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
#if LDBL_MANT_DIG == 64
-#define SPLIT (0x1p32L+1)
+#define SPLIT (0x1p32L + 1)
#elif LDBL_MANT_DIG == 113
-#define SPLIT (0x1p57L+1)
+#define SPLIT (0x1p57L + 1)
#endif
-static void sq(long double *hi, long double *lo, long double x)
-{
- long double xh, xl, xc;
- xc = x*SPLIT;
- xh = x - xc + xc;
- xl = x - xh;
- *hi = x*x;
- *lo = xh*xh - *hi + 2*xh*xl + xl*xl;
+static void sq(long double* hi, long double* lo, long double x) {
+ long double xh, xl, xc;
+ xc = x * SPLIT;
+ xh = x - xc + xc;
+ xl = x - xh;
+ *hi = x * x;
+ *lo = xh * xh - *hi + 2 * xh * xl + xl * xl;
}
-long double hypotl(long double x, long double y)
-{
- union ldshape ux = {x}, uy = {y};
- int ex, ey;
- long double hx, lx, hy, ly, z;
+long double hypotl(long double x, long double y) {
+ union ldshape ux = {x}, uy = {y};
+ int ex, ey;
+ long double hx, lx, hy, ly, z;
- ux.i.se &= 0x7fff;
- uy.i.se &= 0x7fff;
- if (ux.i.se < uy.i.se) {
- ex = uy.i.se;
- ey = ux.i.se;
- x = uy.f;
- y = ux.f;
- } else {
- ex = ux.i.se;
- ey = uy.i.se;
- x = ux.f;
- y = uy.f;
- }
+ ux.i.se &= 0x7fff;
+ uy.i.se &= 0x7fff;
+ if (ux.i.se < uy.i.se) {
+ ex = uy.i.se;
+ ey = ux.i.se;
+ x = uy.f;
+ y = ux.f;
+ } else {
+ ex = ux.i.se;
+ ey = uy.i.se;
+ x = ux.f;
+ y = uy.f;
+ }
- if (ex == 0x7fff && isinf(y))
- return y;
- if (ex == 0x7fff || y == 0)
- return x;
- if (ex - ey > LDBL_MANT_DIG)
- return x + y;
+ if (ex == 0x7fff && isinf(y))
+ return y;
+ if (ex == 0x7fff || y == 0)
+ return x;
+ if (ex - ey > LDBL_MANT_DIG)
+ return x + y;
- z = 1;
- if (ex > 0x3fff+8000) {
- z = 0x1p10000L;
- x *= 0x1p-10000L;
- y *= 0x1p-10000L;
- } else if (ey < 0x3fff-8000) {
- z = 0x1p-10000L;
- x *= 0x1p10000L;
- y *= 0x1p10000L;
- }
- sq(&hx, &lx, x);
- sq(&hy, &ly, y);
- return z*sqrtl(ly+lx+hy+hx);
+ z = 1;
+ if (ex > 0x3fff + 8000) {
+ z = 0x1p10000L;
+ x *= 0x1p-10000L;
+ y *= 0x1p-10000L;
+ } else if (ey < 0x3fff - 8000) {
+ z = 0x1p-10000L;
+ x *= 0x1p10000L;
+ y *= 0x1p10000L;
+ }
+ sq(&hx, &lx, x);
+ sq(&hy, &ly, y);
+ return z * sqrtl(ly + lx + hy + hx);
}
#endif
diff --git a/fusl/src/math/ilogb.c b/fusl/src/math/ilogb.c
index cd7c89e..de9d8cc 100644
--- a/fusl/src/math/ilogb.c
+++ b/fusl/src/math/ilogb.c
@@ -1,26 +1,29 @@
#include <limits.h>
#include "libm.h"
-int ilogb(double x)
-{
- PRAGMA_STDC_FENV_ACCESS_ON
- union {double f; uint64_t i;} u = {x};
- uint64_t i = u.i;
- int e = i>>52 & 0x7ff;
+int ilogb(double x) {
+ PRAGMA_STDC_FENV_ACCESS_ON
+ union {
+ double f;
+ uint64_t i;
+ } u = {x};
+ uint64_t i = u.i;
+ int e = i >> 52 & 0x7ff;
- if (!e) {
- i <<= 12;
- if (i == 0) {
- FORCE_EVAL(0/0.0f);
- return FP_ILOGB0;
- }
- /* subnormal x */
- for (e = -0x3ff; i>>63 == 0; e--, i<<=1);
- return e;
- }
- if (e == 0x7ff) {
- FORCE_EVAL(0/0.0f);
- return i<<12 ? FP_ILOGBNAN : INT_MAX;
- }
- return e - 0x3ff;
+ if (!e) {
+ i <<= 12;
+ if (i == 0) {
+ FORCE_EVAL(0 / 0.0f);
+ return FP_ILOGB0;
+ }
+ /* subnormal x */
+ for (e = -0x3ff; i >> 63 == 0; e--, i <<= 1)
+ ;
+ return e;
+ }
+ if (e == 0x7ff) {
+ FORCE_EVAL(0 / 0.0f);
+ return i << 12 ? FP_ILOGBNAN : INT_MAX;
+ }
+ return e - 0x3ff;
}
diff --git a/fusl/src/math/ilogbf.c b/fusl/src/math/ilogbf.c
index c15d29d..ff76d6f 100644
--- a/fusl/src/math/ilogbf.c
+++ b/fusl/src/math/ilogbf.c
@@ -1,26 +1,29 @@
#include <limits.h>
#include "libm.h"
-int ilogbf(float x)
-{
- PRAGMA_STDC_FENV_ACCESS_ON
- union {float f; uint32_t i;} u = {x};
- uint32_t i = u.i;
- int e = i>>23 & 0xff;
+int ilogbf(float x) {
+ PRAGMA_STDC_FENV_ACCESS_ON
+ union {
+ float f;
+ uint32_t i;
+ } u = {x};
+ uint32_t i = u.i;
+ int e = i >> 23 & 0xff;
- if (!e) {
- i <<= 9;
- if (i == 0) {
- FORCE_EVAL(0/0.0f);
- return FP_ILOGB0;
- }
- /* subnormal x */
- for (e = -0x7f; i>>31 == 0; e--, i<<=1);
- return e;
- }
- if (e == 0xff) {
- FORCE_EVAL(0/0.0f);
- return i<<9 ? FP_ILOGBNAN : INT_MAX;
- }
- return e - 0x7f;
+ if (!e) {
+ i <<= 9;
+ if (i == 0) {
+ FORCE_EVAL(0 / 0.0f);
+ return FP_ILOGB0;
+ }
+ /* subnormal x */
+ for (e = -0x7f; i >> 31 == 0; e--, i <<= 1)
+ ;
+ return e;
+ }
+ if (e == 0xff) {
+ FORCE_EVAL(0 / 0.0f);
+ return i << 9 ? FP_ILOGBNAN : INT_MAX;
+ }
+ return e - 0x7f;
}
diff --git a/fusl/src/math/ilogbl.c b/fusl/src/math/ilogbl.c
index 467929c..b01a087 100644
--- a/fusl/src/math/ilogbl.c
+++ b/fusl/src/math/ilogbl.c
@@ -2,54 +2,52 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-int ilogbl(long double x)
-{
- return ilogb(x);
+int ilogbl(long double x) {
+ return ilogb(x);
}
#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
-int ilogbl(long double x)
-{
- PRAGMA_STDC_FENV_ACCESS_ON
- union ldshape u = {x};
- uint64_t m = u.i.m;
- int e = u.i.se & 0x7fff;
+int ilogbl(long double x) {
+ PRAGMA_STDC_FENV_ACCESS_ON
+ union ldshape u = {x};
+ uint64_t m = u.i.m;
+ int e = u.i.se & 0x7fff;
- if (!e) {
- if (m == 0) {
- FORCE_EVAL(0/0.0f);
- return FP_ILOGB0;
- }
- /* subnormal x */
- for (e = -0x3fff+1; m>>63 == 0; e--, m<<=1);
- return e;
- }
- if (e == 0x7fff) {
- FORCE_EVAL(0/0.0f);
- return m<<1 ? FP_ILOGBNAN : INT_MAX;
- }
- return e - 0x3fff;
+ if (!e) {
+ if (m == 0) {
+ FORCE_EVAL(0 / 0.0f);
+ return FP_ILOGB0;
+ }
+ /* subnormal x */
+ for (e = -0x3fff + 1; m >> 63 == 0; e--, m <<= 1)
+ ;
+ return e;
+ }
+ if (e == 0x7fff) {
+ FORCE_EVAL(0 / 0.0f);
+ return m << 1 ? FP_ILOGBNAN : INT_MAX;
+ }
+ return e - 0x3fff;
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
-int ilogbl(long double x)
-{
- #pragma STDC FENV_ACCESS ON
- union ldshape u = {x};
- int e = u.i.se & 0x7fff;
+int ilogbl(long double x) {
+#pragma STDC FENV_ACCESS ON
+ union ldshape u = {x};
+ int e = u.i.se & 0x7fff;
- if (!e) {
- if (x == 0) {
- FORCE_EVAL(0/0.0f);
- return FP_ILOGB0;
- }
- /* subnormal x */
- x *= 0x1p120;
- return ilogbl(x) - 120;
- }
- if (e == 0x7fff) {
- FORCE_EVAL(0/0.0f);
- u.i.se = 0;
- return u.f ? FP_ILOGBNAN : INT_MAX;
- }
- return e - 0x3fff;
+ if (!e) {
+ if (x == 0) {
+ FORCE_EVAL(0 / 0.0f);
+ return FP_ILOGB0;
+ }
+ /* subnormal x */
+ x *= 0x1p120;
+ return ilogbl(x) - 120;
+ }
+ if (e == 0x7fff) {
+ FORCE_EVAL(0 / 0.0f);
+ u.i.se = 0;
+ return u.f ? FP_ILOGBNAN : INT_MAX;
+ }
+ return e - 0x3fff;
}
#endif
diff --git a/fusl/src/math/j0.c b/fusl/src/math/j0.c
index d722d94..ea4ad13 100644
--- a/fusl/src/math/j0.c
+++ b/fusl/src/math/j0.c
@@ -58,133 +58,131 @@
static double pzero(double), qzero(double);
-static const double
-invsqrtpi = 5.64189583547756279280e-01, /* 0x3FE20DD7, 0x50429B6D */
-tpi = 6.36619772367581382433e-01; /* 0x3FE45F30, 0x6DC9C883 */
+static const double invsqrtpi =
+ 5.64189583547756279280e-01, /* 0x3FE20DD7, 0x50429B6D */
+ tpi = 6.36619772367581382433e-01; /* 0x3FE45F30, 0x6DC9C883 */
/* common method when |x|>=2 */
-static double common(uint32_t ix, double x, int y0)
-{
- double s,c,ss,cc,z;
+static double common(uint32_t ix, double x, int y0) {
+ double s, c, ss, cc, z;
- /*
- * j0(x) = sqrt(2/(pi*x))*(p0(x)*cos(x-pi/4)-q0(x)*sin(x-pi/4))
- * y0(x) = sqrt(2/(pi*x))*(p0(x)*sin(x-pi/4)+q0(x)*cos(x-pi/4))
- *
- * sin(x-pi/4) = (sin(x) - cos(x))/sqrt(2)
- * cos(x-pi/4) = (sin(x) + cos(x))/sqrt(2)
- * sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x))
- */
- s = sin(x);
- c = cos(x);
- if (y0)
- c = -c;
- cc = s+c;
- /* avoid overflow in 2*x, big ulp error when x>=0x1p1023 */
- if (ix < 0x7fe00000) {
- ss = s-c;
- z = -cos(2*x);
- if (s*c < 0)
- cc = z/ss;
- else
- ss = z/cc;
- if (ix < 0x48000000) {
- if (y0)
- ss = -ss;
- cc = pzero(x)*cc-qzero(x)*ss;
- }
- }
- return invsqrtpi*cc/sqrt(x);
+ /*
+ * j0(x) = sqrt(2/(pi*x))*(p0(x)*cos(x-pi/4)-q0(x)*sin(x-pi/4))
+ * y0(x) = sqrt(2/(pi*x))*(p0(x)*sin(x-pi/4)+q0(x)*cos(x-pi/4))
+ *
+ * sin(x-pi/4) = (sin(x) - cos(x))/sqrt(2)
+ * cos(x-pi/4) = (sin(x) + cos(x))/sqrt(2)
+ * sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x))
+ */
+ s = sin(x);
+ c = cos(x);
+ if (y0)
+ c = -c;
+ cc = s + c;
+ /* avoid overflow in 2*x, big ulp error when x>=0x1p1023 */
+ if (ix < 0x7fe00000) {
+ ss = s - c;
+ z = -cos(2 * x);
+ if (s * c < 0)
+ cc = z / ss;
+ else
+ ss = z / cc;
+ if (ix < 0x48000000) {
+ if (y0)
+ ss = -ss;
+ cc = pzero(x) * cc - qzero(x) * ss;
+ }
+ }
+ return invsqrtpi * cc / sqrt(x);
}
/* R0/S0 on [0, 2.00] */
-static const double
-R02 = 1.56249999999999947958e-02, /* 0x3F8FFFFF, 0xFFFFFFFD */
-R03 = -1.89979294238854721751e-04, /* 0xBF28E6A5, 0xB61AC6E9 */
-R04 = 1.82954049532700665670e-06, /* 0x3EBEB1D1, 0x0C503919 */
-R05 = -4.61832688532103189199e-09, /* 0xBE33D5E7, 0x73D63FCE */
-S01 = 1.56191029464890010492e-02, /* 0x3F8FFCE8, 0x82C8C2A4 */
-S02 = 1.16926784663337450260e-04, /* 0x3F1EA6D2, 0xDD57DBF4 */
-S03 = 5.13546550207318111446e-07, /* 0x3EA13B54, 0xCE84D5A9 */
-S04 = 1.16614003333790000205e-09; /* 0x3E1408BC, 0xF4745D8F */
+static const double R02 =
+ 1.56249999999999947958e-02, /* 0x3F8FFFFF, 0xFFFFFFFD */
+ R03 = -1.89979294238854721751e-04, /* 0xBF28E6A5, 0xB61AC6E9 */
+ R04 = 1.82954049532700665670e-06, /* 0x3EBEB1D1, 0x0C503919 */
+ R05 = -4.61832688532103189199e-09, /* 0xBE33D5E7, 0x73D63FCE */
+ S01 = 1.56191029464890010492e-02, /* 0x3F8FFCE8, 0x82C8C2A4 */
+ S02 = 1.16926784663337450260e-04, /* 0x3F1EA6D2, 0xDD57DBF4 */
+ S03 = 5.13546550207318111446e-07, /* 0x3EA13B54, 0xCE84D5A9 */
+ S04 = 1.16614003333790000205e-09; /* 0x3E1408BC, 0xF4745D8F */
-double j0(double x)
-{
- double z,r,s;
- uint32_t ix;
+double j0(double x) {
+ double z, r, s;
+ uint32_t ix;
- GET_HIGH_WORD(ix, x);
- ix &= 0x7fffffff;
+ GET_HIGH_WORD(ix, x);
+ ix &= 0x7fffffff;
- /* j0(+-inf)=0, j0(nan)=nan */
- if (ix >= 0x7ff00000)
- return 1/(x*x);
- x = fabs(x);
+ /* j0(+-inf)=0, j0(nan)=nan */
+ if (ix >= 0x7ff00000)
+ return 1 / (x * x);
+ x = fabs(x);
- if (ix >= 0x40000000) { /* |x| >= 2 */
- /* large ulp error near zeros: 2.4, 5.52, 8.6537,.. */
- return common(ix,x,0);
- }
+ if (ix >= 0x40000000) { /* |x| >= 2 */
+ /* large ulp error near zeros: 2.4, 5.52, 8.6537,.. */
+ return common(ix, x, 0);
+ }
- /* 1 - x*x/4 + x*x*R(x^2)/S(x^2) */
- if (ix >= 0x3f200000) { /* |x| >= 2**-13 */
- /* up to 4ulp error close to 2 */
- z = x*x;
- r = z*(R02+z*(R03+z*(R04+z*R05)));
- s = 1+z*(S01+z*(S02+z*(S03+z*S04)));
- return (1+x/2)*(1-x/2) + z*(r/s);
- }
+ /* 1 - x*x/4 + x*x*R(x^2)/S(x^2) */
+ if (ix >= 0x3f200000) { /* |x| >= 2**-13 */
+ /* up to 4ulp error close to 2 */
+ z = x * x;
+ r = z * (R02 + z * (R03 + z * (R04 + z * R05)));
+ s = 1 + z * (S01 + z * (S02 + z * (S03 + z * S04)));
+ return (1 + x / 2) * (1 - x / 2) + z * (r / s);
+ }
- /* 1 - x*x/4 */
- /* prevent underflow */
- /* inexact should be raised when x!=0, this is not done correctly */
- if (ix >= 0x38000000) /* |x| >= 2**-127 */
- x = 0.25*x*x;
- return 1 - x;
+ /* 1 - x*x/4 */
+ /* prevent underflow */
+ /* inexact should be raised when x!=0, this is not done correctly */
+ if (ix >= 0x38000000) /* |x| >= 2**-127 */
+ x = 0.25 * x * x;
+ return 1 - x;
}
static const double
-u00 = -7.38042951086872317523e-02, /* 0xBFB2E4D6, 0x99CBD01F */
-u01 = 1.76666452509181115538e-01, /* 0x3FC69D01, 0x9DE9E3FC */
-u02 = -1.38185671945596898896e-02, /* 0xBF8C4CE8, 0xB16CFA97 */
-u03 = 3.47453432093683650238e-04, /* 0x3F36C54D, 0x20B29B6B */
-u04 = -3.81407053724364161125e-06, /* 0xBECFFEA7, 0x73D25CAD */
-u05 = 1.95590137035022920206e-08, /* 0x3E550057, 0x3B4EABD4 */
-u06 = -3.98205194132103398453e-11, /* 0xBDC5E43D, 0x693FB3C8 */
-v01 = 1.27304834834123699328e-02, /* 0x3F8A1270, 0x91C9C71A */
-v02 = 7.60068627350353253702e-05, /* 0x3F13ECBB, 0xF578C6C1 */
-v03 = 2.59150851840457805467e-07, /* 0x3E91642D, 0x7FF202FD */
-v04 = 4.41110311332675467403e-10; /* 0x3DFE5018, 0x3BD6D9EF */
+ u00 = -7.38042951086872317523e-02, /* 0xBFB2E4D6, 0x99CBD01F */
+ u01 = 1.76666452509181115538e-01, /* 0x3FC69D01, 0x9DE9E3FC */
+ u02 = -1.38185671945596898896e-02, /* 0xBF8C4CE8, 0xB16CFA97 */
+ u03 = 3.47453432093683650238e-04, /* 0x3F36C54D, 0x20B29B6B */
+ u04 = -3.81407053724364161125e-06, /* 0xBECFFEA7, 0x73D25CAD */
+ u05 = 1.95590137035022920206e-08, /* 0x3E550057, 0x3B4EABD4 */
+ u06 = -3.98205194132103398453e-11, /* 0xBDC5E43D, 0x693FB3C8 */
+ v01 = 1.27304834834123699328e-02, /* 0x3F8A1270, 0x91C9C71A */
+ v02 = 7.60068627350353253702e-05, /* 0x3F13ECBB, 0xF578C6C1 */
+ v03 = 2.59150851840457805467e-07, /* 0x3E91642D, 0x7FF202FD */
+ v04 = 4.41110311332675467403e-10; /* 0x3DFE5018, 0x3BD6D9EF */
-double y0(double x)
-{
- double z,u,v;
- uint32_t ix,lx;
+double y0(double x) {
+ double z, u, v;
+ uint32_t ix, lx;
- EXTRACT_WORDS(ix, lx, x);
+ EXTRACT_WORDS(ix, lx, x);
- /* y0(nan)=nan, y0(<0)=nan, y0(0)=-inf, y0(inf)=0 */
- if ((ix<<1 | lx) == 0)
- return -1/0.0;
- if (ix>>31)
- return 0/0.0;
- if (ix >= 0x7ff00000)
- return 1/x;
+ /* y0(nan)=nan, y0(<0)=nan, y0(0)=-inf, y0(inf)=0 */
+ if ((ix << 1 | lx) == 0)
+ return -1 / 0.0;
+ if (ix >> 31)
+ return 0 / 0.0;
+ if (ix >= 0x7ff00000)
+ return 1 / x;
- if (ix >= 0x40000000) { /* x >= 2 */
- /* large ulp errors near zeros: 3.958, 7.086,.. */
- return common(ix,x,1);
- }
+ if (ix >= 0x40000000) { /* x >= 2 */
+ /* large ulp errors near zeros: 3.958, 7.086,.. */
+ return common(ix, x, 1);
+ }
- /* U(x^2)/V(x^2) + (2/pi)*j0(x)*log(x) */
- if (ix >= 0x3e400000) { /* x >= 2**-27 */
- /* large ulp error near the first zero, x ~= 0.89 */
- z = x*x;
- u = u00+z*(u01+z*(u02+z*(u03+z*(u04+z*(u05+z*u06)))));
- v = 1.0+z*(v01+z*(v02+z*(v03+z*v04)));
- return u/v + tpi*(j0(x)*log(x));
- }
- return u00 + tpi*log(x);
+ /* U(x^2)/V(x^2) + (2/pi)*j0(x)*log(x) */
+ if (ix >= 0x3e400000) { /* x >= 2**-27 */
+ /* large ulp error near the first zero, x ~= 0.89 */
+ z = x * x;
+ u = u00 +
+ z * (u01 + z * (u02 + z * (u03 + z * (u04 + z * (u05 + z * u06)))));
+ v = 1.0 + z * (v01 + z * (v02 + z * (v03 + z * v04)));
+ return u / v + tpi * (j0(x) * log(x));
+ }
+ return u00 + tpi * log(x);
}
/* The asymptotic expansions of pzero is
@@ -196,89 +194,100 @@
* and
* | pzero(x)-1-R/S | <= 2 ** ( -60.26)
*/
-static const double pR8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
- 0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */
- -7.03124999999900357484e-02, /* 0xBFB1FFFF, 0xFFFFFD32 */
- -8.08167041275349795626e+00, /* 0xC02029D0, 0xB44FA779 */
- -2.57063105679704847262e+02, /* 0xC0701102, 0x7B19E863 */
- -2.48521641009428822144e+03, /* 0xC0A36A6E, 0xCD4DCAFC */
- -5.25304380490729545272e+03, /* 0xC0B4850B, 0x36CC643D */
+static const double pR8[6] = {
+ /* for x in [inf, 8]=1/[0,0.125] */
+ 0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */
+ -7.03124999999900357484e-02, /* 0xBFB1FFFF, 0xFFFFFD32 */
+ -8.08167041275349795626e+00, /* 0xC02029D0, 0xB44FA779 */
+ -2.57063105679704847262e+02, /* 0xC0701102, 0x7B19E863 */
+ -2.48521641009428822144e+03, /* 0xC0A36A6E, 0xCD4DCAFC */
+ -5.25304380490729545272e+03, /* 0xC0B4850B, 0x36CC643D */
};
static const double pS8[5] = {
- 1.16534364619668181717e+02, /* 0x405D2233, 0x07A96751 */
- 3.83374475364121826715e+03, /* 0x40ADF37D, 0x50596938 */
- 4.05978572648472545552e+04, /* 0x40E3D2BB, 0x6EB6B05F */
- 1.16752972564375915681e+05, /* 0x40FC810F, 0x8F9FA9BD */
- 4.76277284146730962675e+04, /* 0x40E74177, 0x4F2C49DC */
+ 1.16534364619668181717e+02, /* 0x405D2233, 0x07A96751 */
+ 3.83374475364121826715e+03, /* 0x40ADF37D, 0x50596938 */
+ 4.05978572648472545552e+04, /* 0x40E3D2BB, 0x6EB6B05F */
+ 1.16752972564375915681e+05, /* 0x40FC810F, 0x8F9FA9BD */
+ 4.76277284146730962675e+04, /* 0x40E74177, 0x4F2C49DC */
};
-static const double pR5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
- -1.14125464691894502584e-11, /* 0xBDA918B1, 0x47E495CC */
- -7.03124940873599280078e-02, /* 0xBFB1FFFF, 0xE69AFBC6 */
- -4.15961064470587782438e+00, /* 0xC010A370, 0xF90C6BBF */
- -6.76747652265167261021e+01, /* 0xC050EB2F, 0x5A7D1783 */
- -3.31231299649172967747e+02, /* 0xC074B3B3, 0x6742CC63 */
- -3.46433388365604912451e+02, /* 0xC075A6EF, 0x28A38BD7 */
+static const double pR5[6] = {
+ /* for x in [8,4.5454]=1/[0.125,0.22001] */
+ -1.14125464691894502584e-11, /* 0xBDA918B1, 0x47E495CC */
+ -7.03124940873599280078e-02, /* 0xBFB1FFFF, 0xE69AFBC6 */
+ -4.15961064470587782438e+00, /* 0xC010A370, 0xF90C6BBF */
+ -6.76747652265167261021e+01, /* 0xC050EB2F, 0x5A7D1783 */
+ -3.31231299649172967747e+02, /* 0xC074B3B3, 0x6742CC63 */
+ -3.46433388365604912451e+02, /* 0xC075A6EF, 0x28A38BD7 */
};
static const double pS5[5] = {
- 6.07539382692300335975e+01, /* 0x404E6081, 0x0C98C5DE */
- 1.05125230595704579173e+03, /* 0x40906D02, 0x5C7E2864 */
- 5.97897094333855784498e+03, /* 0x40B75AF8, 0x8FBE1D60 */
- 9.62544514357774460223e+03, /* 0x40C2CCB8, 0xFA76FA38 */
- 2.40605815922939109441e+03, /* 0x40A2CC1D, 0xC70BE864 */
+ 6.07539382692300335975e+01, /* 0x404E6081, 0x0C98C5DE */
+ 1.05125230595704579173e+03, /* 0x40906D02, 0x5C7E2864 */
+ 5.97897094333855784498e+03, /* 0x40B75AF8, 0x8FBE1D60 */
+ 9.62544514357774460223e+03, /* 0x40C2CCB8, 0xFA76FA38 */
+ 2.40605815922939109441e+03, /* 0x40A2CC1D, 0xC70BE864 */
};
-static const double pR3[6] = {/* for x in [4.547,2.8571]=1/[0.2199,0.35001] */
- -2.54704601771951915620e-09, /* 0xBE25E103, 0x6FE1AA86 */
- -7.03119616381481654654e-02, /* 0xBFB1FFF6, 0xF7C0E24B */
- -2.40903221549529611423e+00, /* 0xC00345B2, 0xAEA48074 */
- -2.19659774734883086467e+01, /* 0xC035F74A, 0x4CB94E14 */
- -5.80791704701737572236e+01, /* 0xC04D0A22, 0x420A1A45 */
- -3.14479470594888503854e+01, /* 0xC03F72AC, 0xA892D80F */
+static const double pR3[6] = {
+ /* for x in [4.547,2.8571]=1/[0.2199,0.35001] */
+ -2.54704601771951915620e-09, /* 0xBE25E103, 0x6FE1AA86 */
+ -7.03119616381481654654e-02, /* 0xBFB1FFF6, 0xF7C0E24B */
+ -2.40903221549529611423e+00, /* 0xC00345B2, 0xAEA48074 */
+ -2.19659774734883086467e+01, /* 0xC035F74A, 0x4CB94E14 */
+ -5.80791704701737572236e+01, /* 0xC04D0A22, 0x420A1A45 */
+ -3.14479470594888503854e+01, /* 0xC03F72AC, 0xA892D80F */
};
static const double pS3[5] = {
- 3.58560338055209726349e+01, /* 0x4041ED92, 0x84077DD3 */
- 3.61513983050303863820e+02, /* 0x40769839, 0x464A7C0E */
- 1.19360783792111533330e+03, /* 0x4092A66E, 0x6D1061D6 */
- 1.12799679856907414432e+03, /* 0x40919FFC, 0xB8C39B7E */
- 1.73580930813335754692e+02, /* 0x4065B296, 0xFC379081 */
+ 3.58560338055209726349e+01, /* 0x4041ED92, 0x84077DD3 */
+ 3.61513983050303863820e+02, /* 0x40769839, 0x464A7C0E */
+ 1.19360783792111533330e+03, /* 0x4092A66E, 0x6D1061D6 */
+ 1.12799679856907414432e+03, /* 0x40919FFC, 0xB8C39B7E */
+ 1.73580930813335754692e+02, /* 0x4065B296, 0xFC379081 */
};
-static const double pR2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
- -8.87534333032526411254e-08, /* 0xBE77D316, 0xE927026D */
- -7.03030995483624743247e-02, /* 0xBFB1FF62, 0x495E1E42 */
- -1.45073846780952986357e+00, /* 0xBFF73639, 0x8A24A843 */
- -7.63569613823527770791e+00, /* 0xC01E8AF3, 0xEDAFA7F3 */
- -1.11931668860356747786e+01, /* 0xC02662E6, 0xC5246303 */
- -3.23364579351335335033e+00, /* 0xC009DE81, 0xAF8FE70F */
+static const double pR2[6] = {
+ /* for x in [2.8570,2]=1/[0.3499,0.5] */
+ -8.87534333032526411254e-08, /* 0xBE77D316, 0xE927026D */
+ -7.03030995483624743247e-02, /* 0xBFB1FF62, 0x495E1E42 */
+ -1.45073846780952986357e+00, /* 0xBFF73639, 0x8A24A843 */
+ -7.63569613823527770791e+00, /* 0xC01E8AF3, 0xEDAFA7F3 */
+ -1.11931668860356747786e+01, /* 0xC02662E6, 0xC5246303 */
+ -3.23364579351335335033e+00, /* 0xC009DE81, 0xAF8FE70F */
};
static const double pS2[5] = {
- 2.22202997532088808441e+01, /* 0x40363865, 0x908B5959 */
- 1.36206794218215208048e+02, /* 0x4061069E, 0x0EE8878F */
- 2.70470278658083486789e+02, /* 0x4070E786, 0x42EA079B */
- 1.53875394208320329881e+02, /* 0x40633C03, 0x3AB6FAFF */
- 1.46576176948256193810e+01, /* 0x402D50B3, 0x44391809 */
+ 2.22202997532088808441e+01, /* 0x40363865, 0x908B5959 */
+ 1.36206794218215208048e+02, /* 0x4061069E, 0x0EE8878F */
+ 2.70470278658083486789e+02, /* 0x4070E786, 0x42EA079B */
+ 1.53875394208320329881e+02, /* 0x40633C03, 0x3AB6FAFF */
+ 1.46576176948256193810e+01, /* 0x402D50B3, 0x44391809 */
};
-static double pzero(double x)
-{
- const double *p,*q;
- double_t z,r,s;
- uint32_t ix;
+static double pzero(double x) {
+ const double *p, *q;
+ double_t z, r, s;
+ uint32_t ix;
- GET_HIGH_WORD(ix, x);
- ix &= 0x7fffffff;
- if (ix >= 0x40200000){p = pR8; q = pS8;}
- else if (ix >= 0x40122E8B){p = pR5; q = pS5;}
- else if (ix >= 0x4006DB6D){p = pR3; q = pS3;}
- else /*ix >= 0x40000000*/ {p = pR2; q = pS2;}
- z = 1.0/(x*x);
- r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
- s = 1.0+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*q[4]))));
- return 1.0 + r/s;
+ GET_HIGH_WORD(ix, x);
+ ix &= 0x7fffffff;
+ if (ix >= 0x40200000) {
+ p = pR8;
+ q = pS8;
+ } else if (ix >= 0x40122E8B) {
+ p = pR5;
+ q = pS5;
+ } else if (ix >= 0x4006DB6D) {
+ p = pR3;
+ q = pS3;
+ } else /*ix >= 0x40000000*/ {
+ p = pR2;
+ q = pS2;
+ }
+ z = 1.0 / (x * x);
+ r = p[0] + z * (p[1] + z * (p[2] + z * (p[3] + z * (p[4] + z * p[5]))));
+ s = 1.0 + z * (q[0] + z * (q[1] + z * (q[2] + z * (q[3] + z * q[4]))));
+ return 1.0 + r / s;
}
-
/* For x >= 8, the asymptotic expansions of qzero is
* -1/8 s + 75/1024 s^3 - ..., where s = 1/x.
* We approximate pzero by
@@ -288,88 +297,101 @@
* and
* | qzero(x)/s +1.25-R/S | <= 2 ** ( -61.22)
*/
-static const double qR8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
- 0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */
- 7.32421874999935051953e-02, /* 0x3FB2BFFF, 0xFFFFFE2C */
- 1.17682064682252693899e+01, /* 0x40278952, 0x5BB334D6 */
- 5.57673380256401856059e+02, /* 0x40816D63, 0x15301825 */
- 8.85919720756468632317e+03, /* 0x40C14D99, 0x3E18F46D */
- 3.70146267776887834771e+04, /* 0x40E212D4, 0x0E901566 */
+static const double qR8[6] = {
+ /* for x in [inf, 8]=1/[0,0.125] */
+ 0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */
+ 7.32421874999935051953e-02, /* 0x3FB2BFFF, 0xFFFFFE2C */
+ 1.17682064682252693899e+01, /* 0x40278952, 0x5BB334D6 */
+ 5.57673380256401856059e+02, /* 0x40816D63, 0x15301825 */
+ 8.85919720756468632317e+03, /* 0x40C14D99, 0x3E18F46D */
+ 3.70146267776887834771e+04, /* 0x40E212D4, 0x0E901566 */
};
static const double qS8[6] = {
- 1.63776026895689824414e+02, /* 0x406478D5, 0x365B39BC */
- 8.09834494656449805916e+03, /* 0x40BFA258, 0x4E6B0563 */
- 1.42538291419120476348e+05, /* 0x41016652, 0x54D38C3F */
- 8.03309257119514397345e+05, /* 0x412883DA, 0x83A52B43 */
- 8.40501579819060512818e+05, /* 0x4129A66B, 0x28DE0B3D */
- -3.43899293537866615225e+05, /* 0xC114FD6D, 0x2C9530C5 */
+ 1.63776026895689824414e+02, /* 0x406478D5, 0x365B39BC */
+ 8.09834494656449805916e+03, /* 0x40BFA258, 0x4E6B0563 */
+ 1.42538291419120476348e+05, /* 0x41016652, 0x54D38C3F */
+ 8.03309257119514397345e+05, /* 0x412883DA, 0x83A52B43 */
+ 8.40501579819060512818e+05, /* 0x4129A66B, 0x28DE0B3D */
+ -3.43899293537866615225e+05, /* 0xC114FD6D, 0x2C9530C5 */
};
-static const double qR5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
- 1.84085963594515531381e-11, /* 0x3DB43D8F, 0x29CC8CD9 */
- 7.32421766612684765896e-02, /* 0x3FB2BFFF, 0xD172B04C */
- 5.83563508962056953777e+00, /* 0x401757B0, 0xB9953DD3 */
- 1.35111577286449829671e+02, /* 0x4060E392, 0x0A8788E9 */
- 1.02724376596164097464e+03, /* 0x40900CF9, 0x9DC8C481 */
- 1.98997785864605384631e+03, /* 0x409F17E9, 0x53C6E3A6 */
+static const double qR5[6] = {
+ /* for x in [8,4.5454]=1/[0.125,0.22001] */
+ 1.84085963594515531381e-11, /* 0x3DB43D8F, 0x29CC8CD9 */
+ 7.32421766612684765896e-02, /* 0x3FB2BFFF, 0xD172B04C */
+ 5.83563508962056953777e+00, /* 0x401757B0, 0xB9953DD3 */
+ 1.35111577286449829671e+02, /* 0x4060E392, 0x0A8788E9 */
+ 1.02724376596164097464e+03, /* 0x40900CF9, 0x9DC8C481 */
+ 1.98997785864605384631e+03, /* 0x409F17E9, 0x53C6E3A6 */
};
static const double qS5[6] = {
- 8.27766102236537761883e+01, /* 0x4054B1B3, 0xFB5E1543 */
- 2.07781416421392987104e+03, /* 0x40A03BA0, 0xDA21C0CE */
- 1.88472887785718085070e+04, /* 0x40D267D2, 0x7B591E6D */
- 5.67511122894947329769e+04, /* 0x40EBB5E3, 0x97E02372 */
- 3.59767538425114471465e+04, /* 0x40E19118, 0x1F7A54A0 */
- -5.35434275601944773371e+03, /* 0xC0B4EA57, 0xBEDBC609 */
+ 8.27766102236537761883e+01, /* 0x4054B1B3, 0xFB5E1543 */
+ 2.07781416421392987104e+03, /* 0x40A03BA0, 0xDA21C0CE */
+ 1.88472887785718085070e+04, /* 0x40D267D2, 0x7B591E6D */
+ 5.67511122894947329769e+04, /* 0x40EBB5E3, 0x97E02372 */
+ 3.59767538425114471465e+04, /* 0x40E19118, 0x1F7A54A0 */
+ -5.35434275601944773371e+03, /* 0xC0B4EA57, 0xBEDBC609 */
};
-static const double qR3[6] = {/* for x in [4.547,2.8571]=1/[0.2199,0.35001] */
- 4.37741014089738620906e-09, /* 0x3E32CD03, 0x6ADECB82 */
- 7.32411180042911447163e-02, /* 0x3FB2BFEE, 0x0E8D0842 */
- 3.34423137516170720929e+00, /* 0x400AC0FC, 0x61149CF5 */
- 4.26218440745412650017e+01, /* 0x40454F98, 0x962DAEDD */
- 1.70808091340565596283e+02, /* 0x406559DB, 0xE25EFD1F */
- 1.66733948696651168575e+02, /* 0x4064D77C, 0x81FA21E0 */
+static const double qR3[6] = {
+ /* for x in [4.547,2.8571]=1/[0.2199,0.35001] */
+ 4.37741014089738620906e-09, /* 0x3E32CD03, 0x6ADECB82 */
+ 7.32411180042911447163e-02, /* 0x3FB2BFEE, 0x0E8D0842 */
+ 3.34423137516170720929e+00, /* 0x400AC0FC, 0x61149CF5 */
+ 4.26218440745412650017e+01, /* 0x40454F98, 0x962DAEDD */
+ 1.70808091340565596283e+02, /* 0x406559DB, 0xE25EFD1F */
+ 1.66733948696651168575e+02, /* 0x4064D77C, 0x81FA21E0 */
};
static const double qS3[6] = {
- 4.87588729724587182091e+01, /* 0x40486122, 0xBFE343A6 */
- 7.09689221056606015736e+02, /* 0x40862D83, 0x86544EB3 */
- 3.70414822620111362994e+03, /* 0x40ACF04B, 0xE44DFC63 */
- 6.46042516752568917582e+03, /* 0x40B93C6C, 0xD7C76A28 */
- 2.51633368920368957333e+03, /* 0x40A3A8AA, 0xD94FB1C0 */
- -1.49247451836156386662e+02, /* 0xC062A7EB, 0x201CF40F */
+ 4.87588729724587182091e+01, /* 0x40486122, 0xBFE343A6 */
+ 7.09689221056606015736e+02, /* 0x40862D83, 0x86544EB3 */
+ 3.70414822620111362994e+03, /* 0x40ACF04B, 0xE44DFC63 */
+ 6.46042516752568917582e+03, /* 0x40B93C6C, 0xD7C76A28 */
+ 2.51633368920368957333e+03, /* 0x40A3A8AA, 0xD94FB1C0 */
+ -1.49247451836156386662e+02, /* 0xC062A7EB, 0x201CF40F */
};
-static const double qR2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
- 1.50444444886983272379e-07, /* 0x3E84313B, 0x54F76BDB */
- 7.32234265963079278272e-02, /* 0x3FB2BEC5, 0x3E883E34 */
- 1.99819174093815998816e+00, /* 0x3FFFF897, 0xE727779C */
- 1.44956029347885735348e+01, /* 0x402CFDBF, 0xAAF96FE5 */
- 3.16662317504781540833e+01, /* 0x403FAA8E, 0x29FBDC4A */
- 1.62527075710929267416e+01, /* 0x403040B1, 0x71814BB4 */
+static const double qR2[6] = {
+ /* for x in [2.8570,2]=1/[0.3499,0.5] */
+ 1.50444444886983272379e-07, /* 0x3E84313B, 0x54F76BDB */
+ 7.32234265963079278272e-02, /* 0x3FB2BEC5, 0x3E883E34 */
+ 1.99819174093815998816e+00, /* 0x3FFFF897, 0xE727779C */
+ 1.44956029347885735348e+01, /* 0x402CFDBF, 0xAAF96FE5 */
+ 3.16662317504781540833e+01, /* 0x403FAA8E, 0x29FBDC4A */
+ 1.62527075710929267416e+01, /* 0x403040B1, 0x71814BB4 */
};
static const double qS2[6] = {
- 3.03655848355219184498e+01, /* 0x403E5D96, 0xF7C07AED */
- 2.69348118608049844624e+02, /* 0x4070D591, 0xE4D14B40 */
- 8.44783757595320139444e+02, /* 0x408A6645, 0x22B3BF22 */
- 8.82935845112488550512e+02, /* 0x408B977C, 0x9C5CC214 */
- 2.12666388511798828631e+02, /* 0x406A9553, 0x0E001365 */
- -5.31095493882666946917e+00, /* 0xC0153E6A, 0xF8B32931 */
+ 3.03655848355219184498e+01, /* 0x403E5D96, 0xF7C07AED */
+ 2.69348118608049844624e+02, /* 0x4070D591, 0xE4D14B40 */
+ 8.44783757595320139444e+02, /* 0x408A6645, 0x22B3BF22 */
+ 8.82935845112488550512e+02, /* 0x408B977C, 0x9C5CC214 */
+ 2.12666388511798828631e+02, /* 0x406A9553, 0x0E001365 */
+ -5.31095493882666946917e+00, /* 0xC0153E6A, 0xF8B32931 */
};
-static double qzero(double x)
-{
- const double *p,*q;
- double_t s,r,z;
- uint32_t ix;
+static double qzero(double x) {
+ const double *p, *q;
+ double_t s, r, z;
+ uint32_t ix;
- GET_HIGH_WORD(ix, x);
- ix &= 0x7fffffff;
- if (ix >= 0x40200000){p = qR8; q = qS8;}
- else if (ix >= 0x40122E8B){p = qR5; q = qS5;}
- else if (ix >= 0x4006DB6D){p = qR3; q = qS3;}
- else /*ix >= 0x40000000*/ {p = qR2; q = qS2;}
- z = 1.0/(x*x);
- r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
- s = 1.0+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*(q[4]+z*q[5])))));
- return (-.125 + r/s)/x;
+ GET_HIGH_WORD(ix, x);
+ ix &= 0x7fffffff;
+ if (ix >= 0x40200000) {
+ p = qR8;
+ q = qS8;
+ } else if (ix >= 0x40122E8B) {
+ p = qR5;
+ q = qS5;
+ } else if (ix >= 0x4006DB6D) {
+ p = qR3;
+ q = qS3;
+ } else /*ix >= 0x40000000*/ {
+ p = qR2;
+ q = qS2;
+ }
+ z = 1.0 / (x * x);
+ r = p[0] + z * (p[1] + z * (p[2] + z * (p[3] + z * (p[4] + z * p[5]))));
+ s = 1.0 +
+ z * (q[0] + z * (q[1] + z * (q[2] + z * (q[3] + z * (q[4] + z * q[5])))));
+ return (-.125 + r / s) / x;
}
diff --git a/fusl/src/math/j0f.c b/fusl/src/math/j0f.c
index 45883dc..6d926d3 100644
--- a/fusl/src/math/j0f.c
+++ b/fusl/src/math/j0f.c
@@ -18,113 +18,108 @@
static float pzerof(float), qzerof(float);
-static const float
-invsqrtpi = 5.6418961287e-01, /* 0x3f106ebb */
-tpi = 6.3661974669e-01; /* 0x3f22f983 */
+static const float invsqrtpi = 5.6418961287e-01, /* 0x3f106ebb */
+ tpi = 6.3661974669e-01; /* 0x3f22f983 */
-static float common(uint32_t ix, float x, int y0)
-{
- float z,s,c,ss,cc;
- /*
- * j0(x) = 1/sqrt(pi) * (P(0,x)*cc - Q(0,x)*ss) / sqrt(x)
- * y0(x) = 1/sqrt(pi) * (P(0,x)*ss + Q(0,x)*cc) / sqrt(x)
- */
- s = sinf(x);
- c = cosf(x);
- if (y0)
- c = -c;
- cc = s+c;
- if (ix < 0x7f000000) {
- ss = s-c;
- z = -cosf(2*x);
- if (s*c < 0)
- cc = z/ss;
- else
- ss = z/cc;
- if (ix < 0x58800000) {
- if (y0)
- ss = -ss;
- cc = pzerof(x)*cc-qzerof(x)*ss;
- }
- }
- return invsqrtpi*cc/sqrtf(x);
+static float common(uint32_t ix, float x, int y0) {
+ float z, s, c, ss, cc;
+ /*
+ * j0(x) = 1/sqrt(pi) * (P(0,x)*cc - Q(0,x)*ss) / sqrt(x)
+ * y0(x) = 1/sqrt(pi) * (P(0,x)*ss + Q(0,x)*cc) / sqrt(x)
+ */
+ s = sinf(x);
+ c = cosf(x);
+ if (y0)
+ c = -c;
+ cc = s + c;
+ if (ix < 0x7f000000) {
+ ss = s - c;
+ z = -cosf(2 * x);
+ if (s * c < 0)
+ cc = z / ss;
+ else
+ ss = z / cc;
+ if (ix < 0x58800000) {
+ if (y0)
+ ss = -ss;
+ cc = pzerof(x) * cc - qzerof(x) * ss;
+ }
+ }
+ return invsqrtpi * cc / sqrtf(x);
}
/* R0/S0 on [0, 2.00] */
-static const float
-R02 = 1.5625000000e-02, /* 0x3c800000 */
-R03 = -1.8997929874e-04, /* 0xb947352e */
-R04 = 1.8295404516e-06, /* 0x35f58e88 */
-R05 = -4.6183270541e-09, /* 0xb19eaf3c */
-S01 = 1.5619102865e-02, /* 0x3c7fe744 */
-S02 = 1.1692678527e-04, /* 0x38f53697 */
-S03 = 5.1354652442e-07, /* 0x3509daa6 */
-S04 = 1.1661400734e-09; /* 0x30a045e8 */
+static const float R02 = 1.5625000000e-02, /* 0x3c800000 */
+ R03 = -1.8997929874e-04, /* 0xb947352e */
+ R04 = 1.8295404516e-06, /* 0x35f58e88 */
+ R05 = -4.6183270541e-09, /* 0xb19eaf3c */
+ S01 = 1.5619102865e-02, /* 0x3c7fe744 */
+ S02 = 1.1692678527e-04, /* 0x38f53697 */
+ S03 = 5.1354652442e-07, /* 0x3509daa6 */
+ S04 = 1.1661400734e-09; /* 0x30a045e8 */
-float j0f(float x)
-{
- float z,r,s;
- uint32_t ix;
+float j0f(float x) {
+ float z, r, s;
+ uint32_t ix;
- GET_FLOAT_WORD(ix, x);
- ix &= 0x7fffffff;
- if (ix >= 0x7f800000)
- return 1/(x*x);
- x = fabsf(x);
+ GET_FLOAT_WORD(ix, x);
+ ix &= 0x7fffffff;
+ if (ix >= 0x7f800000)
+ return 1 / (x * x);
+ x = fabsf(x);
- if (ix >= 0x40000000) { /* |x| >= 2 */
- /* large ulp error near zeros */
- return common(ix, x, 0);
- }
- if (ix >= 0x3a000000) { /* |x| >= 2**-11 */
- /* up to 4ulp error near 2 */
- z = x*x;
- r = z*(R02+z*(R03+z*(R04+z*R05)));
- s = 1+z*(S01+z*(S02+z*(S03+z*S04)));
- return (1+x/2)*(1-x/2) + z*(r/s);
- }
- if (ix >= 0x21800000) /* |x| >= 2**-60 */
- x = 0.25f*x*x;
- return 1 - x;
+ if (ix >= 0x40000000) { /* |x| >= 2 */
+ /* large ulp error near zeros */
+ return common(ix, x, 0);
+ }
+ if (ix >= 0x3a000000) { /* |x| >= 2**-11 */
+ /* up to 4ulp error near 2 */
+ z = x * x;
+ r = z * (R02 + z * (R03 + z * (R04 + z * R05)));
+ s = 1 + z * (S01 + z * (S02 + z * (S03 + z * S04)));
+ return (1 + x / 2) * (1 - x / 2) + z * (r / s);
+ }
+ if (ix >= 0x21800000) /* |x| >= 2**-60 */
+ x = 0.25f * x * x;
+ return 1 - x;
}
-static const float
-u00 = -7.3804296553e-02, /* 0xbd9726b5 */
-u01 = 1.7666645348e-01, /* 0x3e34e80d */
-u02 = -1.3818567619e-02, /* 0xbc626746 */
-u03 = 3.4745343146e-04, /* 0x39b62a69 */
-u04 = -3.8140706238e-06, /* 0xb67ff53c */
-u05 = 1.9559013964e-08, /* 0x32a802ba */
-u06 = -3.9820518410e-11, /* 0xae2f21eb */
-v01 = 1.2730483897e-02, /* 0x3c509385 */
-v02 = 7.6006865129e-05, /* 0x389f65e0 */
-v03 = 2.5915085189e-07, /* 0x348b216c */
-v04 = 4.4111031494e-10; /* 0x2ff280c2 */
+static const float u00 = -7.3804296553e-02, /* 0xbd9726b5 */
+ u01 = 1.7666645348e-01, /* 0x3e34e80d */
+ u02 = -1.3818567619e-02, /* 0xbc626746 */
+ u03 = 3.4745343146e-04, /* 0x39b62a69 */
+ u04 = -3.8140706238e-06, /* 0xb67ff53c */
+ u05 = 1.9559013964e-08, /* 0x32a802ba */
+ u06 = -3.9820518410e-11, /* 0xae2f21eb */
+ v01 = 1.2730483897e-02, /* 0x3c509385 */
+ v02 = 7.6006865129e-05, /* 0x389f65e0 */
+ v03 = 2.5915085189e-07, /* 0x348b216c */
+ v04 = 4.4111031494e-10; /* 0x2ff280c2 */
-float y0f(float x)
-{
- float z,u,v;
- uint32_t ix;
+float y0f(float x) {
+ float z, u, v;
+ uint32_t ix;
- GET_FLOAT_WORD(ix, x);
- if ((ix & 0x7fffffff) == 0)
- return -1/0.0f;
- if (ix>>31)
- return 0/0.0f;
- if (ix >= 0x7f800000)
- return 1/x;
- if (ix >= 0x40000000) { /* |x| >= 2.0 */
- /* large ulp error near zeros */
- return common(ix,x,1);
- }
- if (ix >= 0x39000000) { /* x >= 2**-13 */
- /* large ulp error at x ~= 0.89 */
- z = x*x;
- u = u00+z*(u01+z*(u02+z*(u03+z*(u04+z*(u05+z*u06)))));
- v = 1+z*(v01+z*(v02+z*(v03+z*v04)));
- return u/v + tpi*(j0f(x)*logf(x));
- }
- return u00 + tpi*logf(x);
+ GET_FLOAT_WORD(ix, x);
+ if ((ix & 0x7fffffff) == 0)
+ return -1 / 0.0f;
+ if (ix >> 31)
+ return 0 / 0.0f;
+ if (ix >= 0x7f800000)
+ return 1 / x;
+ if (ix >= 0x40000000) { /* |x| >= 2.0 */
+ /* large ulp error near zeros */
+ return common(ix, x, 1);
+ }
+ if (ix >= 0x39000000) { /* x >= 2**-13 */
+ /* large ulp error at x ~= 0.89 */
+ z = x * x;
+ u = u00 +
+ z * (u01 + z * (u02 + z * (u03 + z * (u04 + z * (u05 + z * u06)))));
+ v = 1 + z * (v01 + z * (v02 + z * (v03 + z * v04)));
+ return u / v + tpi * (j0f(x) * logf(x));
+ }
+ return u00 + tpi * logf(x);
}
/* The asymptotic expansions of pzero is
@@ -136,88 +131,99 @@
* and
* | pzero(x)-1-R/S | <= 2 ** ( -60.26)
*/
-static const float pR8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
- 0.0000000000e+00, /* 0x00000000 */
- -7.0312500000e-02, /* 0xbd900000 */
- -8.0816707611e+00, /* 0xc1014e86 */
- -2.5706311035e+02, /* 0xc3808814 */
- -2.4852163086e+03, /* 0xc51b5376 */
- -5.2530439453e+03, /* 0xc5a4285a */
+static const float pR8[6] = {
+ /* for x in [inf, 8]=1/[0,0.125] */
+ 0.0000000000e+00, /* 0x00000000 */
+ -7.0312500000e-02, /* 0xbd900000 */
+ -8.0816707611e+00, /* 0xc1014e86 */
+ -2.5706311035e+02, /* 0xc3808814 */
+ -2.4852163086e+03, /* 0xc51b5376 */
+ -5.2530439453e+03, /* 0xc5a4285a */
};
static const float pS8[5] = {
- 1.1653436279e+02, /* 0x42e91198 */
- 3.8337448730e+03, /* 0x456f9beb */
- 4.0597855469e+04, /* 0x471e95db */
- 1.1675296875e+05, /* 0x47e4087c */
- 4.7627726562e+04, /* 0x473a0bba */
+ 1.1653436279e+02, /* 0x42e91198 */
+ 3.8337448730e+03, /* 0x456f9beb */
+ 4.0597855469e+04, /* 0x471e95db */
+ 1.1675296875e+05, /* 0x47e4087c */
+ 4.7627726562e+04, /* 0x473a0bba */
};
-static const float pR5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
- -1.1412546255e-11, /* 0xad48c58a */
- -7.0312492549e-02, /* 0xbd8fffff */
- -4.1596107483e+00, /* 0xc0851b88 */
- -6.7674766541e+01, /* 0xc287597b */
- -3.3123129272e+02, /* 0xc3a59d9b */
- -3.4643338013e+02, /* 0xc3ad3779 */
+static const float pR5[6] = {
+ /* for x in [8,4.5454]=1/[0.125,0.22001] */
+ -1.1412546255e-11, /* 0xad48c58a */
+ -7.0312492549e-02, /* 0xbd8fffff */
+ -4.1596107483e+00, /* 0xc0851b88 */
+ -6.7674766541e+01, /* 0xc287597b */
+ -3.3123129272e+02, /* 0xc3a59d9b */
+ -3.4643338013e+02, /* 0xc3ad3779 */
};
static const float pS5[5] = {
- 6.0753936768e+01, /* 0x42730408 */
- 1.0512523193e+03, /* 0x44836813 */
- 5.9789707031e+03, /* 0x45bad7c4 */
- 9.6254453125e+03, /* 0x461665c8 */
- 2.4060581055e+03, /* 0x451660ee */
+ 6.0753936768e+01, /* 0x42730408 */
+ 1.0512523193e+03, /* 0x44836813 */
+ 5.9789707031e+03, /* 0x45bad7c4 */
+ 9.6254453125e+03, /* 0x461665c8 */
+ 2.4060581055e+03, /* 0x451660ee */
};
-static const float pR3[6] = {/* for x in [4.547,2.8571]=1/[0.2199,0.35001] */
- -2.5470459075e-09, /* 0xb12f081b */
- -7.0311963558e-02, /* 0xbd8fffb8 */
- -2.4090321064e+00, /* 0xc01a2d95 */
- -2.1965976715e+01, /* 0xc1afba52 */
- -5.8079170227e+01, /* 0xc2685112 */
- -3.1447946548e+01, /* 0xc1fb9565 */
+static const float pR3[6] = {
+ /* for x in [4.547,2.8571]=1/[0.2199,0.35001] */
+ -2.5470459075e-09, /* 0xb12f081b */
+ -7.0311963558e-02, /* 0xbd8fffb8 */
+ -2.4090321064e+00, /* 0xc01a2d95 */
+ -2.1965976715e+01, /* 0xc1afba52 */
+ -5.8079170227e+01, /* 0xc2685112 */
+ -3.1447946548e+01, /* 0xc1fb9565 */
};
static const float pS3[5] = {
- 3.5856033325e+01, /* 0x420f6c94 */
- 3.6151397705e+02, /* 0x43b4c1ca */
- 1.1936077881e+03, /* 0x44953373 */
- 1.1279968262e+03, /* 0x448cffe6 */
- 1.7358093262e+02, /* 0x432d94b8 */
+ 3.5856033325e+01, /* 0x420f6c94 */
+ 3.6151397705e+02, /* 0x43b4c1ca */
+ 1.1936077881e+03, /* 0x44953373 */
+ 1.1279968262e+03, /* 0x448cffe6 */
+ 1.7358093262e+02, /* 0x432d94b8 */
};
-static const float pR2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
- -8.8753431271e-08, /* 0xb3be98b7 */
- -7.0303097367e-02, /* 0xbd8ffb12 */
- -1.4507384300e+00, /* 0xbfb9b1cc */
- -7.6356959343e+00, /* 0xc0f4579f */
- -1.1193166733e+01, /* 0xc1331736 */
- -3.2336456776e+00, /* 0xc04ef40d */
+static const float pR2[6] = {
+ /* for x in [2.8570,2]=1/[0.3499,0.5] */
+ -8.8753431271e-08, /* 0xb3be98b7 */
+ -7.0303097367e-02, /* 0xbd8ffb12 */
+ -1.4507384300e+00, /* 0xbfb9b1cc */
+ -7.6356959343e+00, /* 0xc0f4579f */
+ -1.1193166733e+01, /* 0xc1331736 */
+ -3.2336456776e+00, /* 0xc04ef40d */
};
static const float pS2[5] = {
- 2.2220300674e+01, /* 0x41b1c32d */
- 1.3620678711e+02, /* 0x430834f0 */
- 2.7047027588e+02, /* 0x43873c32 */
- 1.5387539673e+02, /* 0x4319e01a */
- 1.4657617569e+01, /* 0x416a859a */
+ 2.2220300674e+01, /* 0x41b1c32d */
+ 1.3620678711e+02, /* 0x430834f0 */
+ 2.7047027588e+02, /* 0x43873c32 */
+ 1.5387539673e+02, /* 0x4319e01a */
+ 1.4657617569e+01, /* 0x416a859a */
};
-static float pzerof(float x)
-{
- const float *p,*q;
- float_t z,r,s;
- uint32_t ix;
+static float pzerof(float x) {
+ const float *p, *q;
+ float_t z, r, s;
+ uint32_t ix;
- GET_FLOAT_WORD(ix, x);
- ix &= 0x7fffffff;
- if (ix >= 0x41000000){p = pR8; q = pS8;}
- else if (ix >= 0x40f71c58){p = pR5; q = pS5;}
- else if (ix >= 0x4036db68){p = pR3; q = pS3;}
- else /*ix >= 0x40000000*/ {p = pR2; q = pS2;}
- z = 1.0f/(x*x);
- r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
- s = 1.0f+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*q[4]))));
- return 1.0f + r/s;
+ GET_FLOAT_WORD(ix, x);
+ ix &= 0x7fffffff;
+ if (ix >= 0x41000000) {
+ p = pR8;
+ q = pS8;
+ } else if (ix >= 0x40f71c58) {
+ p = pR5;
+ q = pS5;
+ } else if (ix >= 0x4036db68) {
+ p = pR3;
+ q = pS3;
+ } else /*ix >= 0x40000000*/ {
+ p = pR2;
+ q = pS2;
+ }
+ z = 1.0f / (x * x);
+ r = p[0] + z * (p[1] + z * (p[2] + z * (p[3] + z * (p[4] + z * p[5]))));
+ s = 1.0f + z * (q[0] + z * (q[1] + z * (q[2] + z * (q[3] + z * q[4]))));
+ return 1.0f + r / s;
}
-
/* For x >= 8, the asymptotic expansions of qzero is
* -1/8 s + 75/1024 s^3 - ..., where s = 1/x.
* We approximate pzero by
@@ -227,88 +233,101 @@
* and
* | qzero(x)/s +1.25-R/S | <= 2 ** ( -61.22)
*/
-static const float qR8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
- 0.0000000000e+00, /* 0x00000000 */
- 7.3242187500e-02, /* 0x3d960000 */
- 1.1768206596e+01, /* 0x413c4a93 */
- 5.5767340088e+02, /* 0x440b6b19 */
- 8.8591972656e+03, /* 0x460a6cca */
- 3.7014625000e+04, /* 0x471096a0 */
+static const float qR8[6] = {
+ /* for x in [inf, 8]=1/[0,0.125] */
+ 0.0000000000e+00, /* 0x00000000 */
+ 7.3242187500e-02, /* 0x3d960000 */
+ 1.1768206596e+01, /* 0x413c4a93 */
+ 5.5767340088e+02, /* 0x440b6b19 */
+ 8.8591972656e+03, /* 0x460a6cca */
+ 3.7014625000e+04, /* 0x471096a0 */
};
static const float qS8[6] = {
- 1.6377603149e+02, /* 0x4323c6aa */
- 8.0983447266e+03, /* 0x45fd12c2 */
- 1.4253829688e+05, /* 0x480b3293 */
- 8.0330925000e+05, /* 0x49441ed4 */
- 8.4050156250e+05, /* 0x494d3359 */
- -3.4389928125e+05, /* 0xc8a7eb69 */
+ 1.6377603149e+02, /* 0x4323c6aa */
+ 8.0983447266e+03, /* 0x45fd12c2 */
+ 1.4253829688e+05, /* 0x480b3293 */
+ 8.0330925000e+05, /* 0x49441ed4 */
+ 8.4050156250e+05, /* 0x494d3359 */
+ -3.4389928125e+05, /* 0xc8a7eb69 */
};
-static const float qR5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
- 1.8408595828e-11, /* 0x2da1ec79 */
- 7.3242180049e-02, /* 0x3d95ffff */
- 5.8356351852e+00, /* 0x40babd86 */
- 1.3511157227e+02, /* 0x43071c90 */
- 1.0272437744e+03, /* 0x448067cd */
- 1.9899779053e+03, /* 0x44f8bf4b */
+static const float qR5[6] = {
+ /* for x in [8,4.5454]=1/[0.125,0.22001] */
+ 1.8408595828e-11, /* 0x2da1ec79 */
+ 7.3242180049e-02, /* 0x3d95ffff */
+ 5.8356351852e+00, /* 0x40babd86 */
+ 1.3511157227e+02, /* 0x43071c90 */
+ 1.0272437744e+03, /* 0x448067cd */
+ 1.9899779053e+03, /* 0x44f8bf4b */
};
static const float qS5[6] = {
- 8.2776611328e+01, /* 0x42a58da0 */
- 2.0778142090e+03, /* 0x4501dd07 */
- 1.8847289062e+04, /* 0x46933e94 */
- 5.6751113281e+04, /* 0x475daf1d */
- 3.5976753906e+04, /* 0x470c88c1 */
- -5.3543427734e+03, /* 0xc5a752be */
+ 8.2776611328e+01, /* 0x42a58da0 */
+ 2.0778142090e+03, /* 0x4501dd07 */
+ 1.8847289062e+04, /* 0x46933e94 */
+ 5.6751113281e+04, /* 0x475daf1d */
+ 3.5976753906e+04, /* 0x470c88c1 */
+ -5.3543427734e+03, /* 0xc5a752be */
};
-static const float qR3[6] = {/* for x in [4.547,2.8571]=1/[0.2199,0.35001] */
- 4.3774099900e-09, /* 0x3196681b */
- 7.3241114616e-02, /* 0x3d95ff70 */
- 3.3442313671e+00, /* 0x405607e3 */
- 4.2621845245e+01, /* 0x422a7cc5 */
- 1.7080809021e+02, /* 0x432acedf */
- 1.6673394775e+02, /* 0x4326bbe4 */
+static const float qR3[6] = {
+ /* for x in [4.547,2.8571]=1/[0.2199,0.35001] */
+ 4.3774099900e-09, /* 0x3196681b */
+ 7.3241114616e-02, /* 0x3d95ff70 */
+ 3.3442313671e+00, /* 0x405607e3 */
+ 4.2621845245e+01, /* 0x422a7cc5 */
+ 1.7080809021e+02, /* 0x432acedf */
+ 1.6673394775e+02, /* 0x4326bbe4 */
};
static const float qS3[6] = {
- 4.8758872986e+01, /* 0x42430916 */
- 7.0968920898e+02, /* 0x44316c1c */
- 3.7041481934e+03, /* 0x4567825f */
- 6.4604252930e+03, /* 0x45c9e367 */
- 2.5163337402e+03, /* 0x451d4557 */
- -1.4924745178e+02, /* 0xc3153f59 */
+ 4.8758872986e+01, /* 0x42430916 */
+ 7.0968920898e+02, /* 0x44316c1c */
+ 3.7041481934e+03, /* 0x4567825f */
+ 6.4604252930e+03, /* 0x45c9e367 */
+ 2.5163337402e+03, /* 0x451d4557 */
+ -1.4924745178e+02, /* 0xc3153f59 */
};
-static const float qR2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
- 1.5044444979e-07, /* 0x342189db */
- 7.3223426938e-02, /* 0x3d95f62a */
- 1.9981917143e+00, /* 0x3fffc4bf */
- 1.4495602608e+01, /* 0x4167edfd */
- 3.1666231155e+01, /* 0x41fd5471 */
- 1.6252708435e+01, /* 0x4182058c */
+static const float qR2[6] = {
+ /* for x in [2.8570,2]=1/[0.3499,0.5] */
+ 1.5044444979e-07, /* 0x342189db */
+ 7.3223426938e-02, /* 0x3d95f62a */
+ 1.9981917143e+00, /* 0x3fffc4bf */
+ 1.4495602608e+01, /* 0x4167edfd */
+ 3.1666231155e+01, /* 0x41fd5471 */
+ 1.6252708435e+01, /* 0x4182058c */
};
static const float qS2[6] = {
- 3.0365585327e+01, /* 0x41f2ecb8 */
- 2.6934811401e+02, /* 0x4386ac8f */
- 8.4478375244e+02, /* 0x44533229 */
- 8.8293585205e+02, /* 0x445cbbe5 */
- 2.1266638184e+02, /* 0x4354aa98 */
- -5.3109550476e+00, /* 0xc0a9f358 */
+ 3.0365585327e+01, /* 0x41f2ecb8 */
+ 2.6934811401e+02, /* 0x4386ac8f */
+ 8.4478375244e+02, /* 0x44533229 */
+ 8.8293585205e+02, /* 0x445cbbe5 */
+ 2.1266638184e+02, /* 0x4354aa98 */
+ -5.3109550476e+00, /* 0xc0a9f358 */
};
-static float qzerof(float x)
-{
- const float *p,*q;
- float_t s,r,z;
- uint32_t ix;
+static float qzerof(float x) {
+ const float *p, *q;
+ float_t s, r, z;
+ uint32_t ix;
- GET_FLOAT_WORD(ix, x);
- ix &= 0x7fffffff;
- if (ix >= 0x41000000){p = qR8; q = qS8;}
- else if (ix >= 0x40f71c58){p = qR5; q = qS5;}
- else if (ix >= 0x4036db68){p = qR3; q = qS3;}
- else /*ix >= 0x40000000*/ {p = qR2; q = qS2;}
- z = 1.0f/(x*x);
- r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
- s = 1.0f+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*(q[4]+z*q[5])))));
- return (-.125f + r/s)/x;
+ GET_FLOAT_WORD(ix, x);
+ ix &= 0x7fffffff;
+ if (ix >= 0x41000000) {
+ p = qR8;
+ q = qS8;
+ } else if (ix >= 0x40f71c58) {
+ p = qR5;
+ q = qS5;
+ } else if (ix >= 0x4036db68) {
+ p = qR3;
+ q = qS3;
+ } else /*ix >= 0x40000000*/ {
+ p = qR2;
+ q = qS2;
+ }
+ z = 1.0f / (x * x);
+ r = p[0] + z * (p[1] + z * (p[2] + z * (p[3] + z * (p[4] + z * p[5]))));
+ s = 1.0f +
+ z * (q[0] + z * (q[1] + z * (q[2] + z * (q[3] + z * (q[4] + z * q[5])))));
+ return (-.125f + r / s) / x;
}
diff --git a/fusl/src/math/j1.c b/fusl/src/math/j1.c
index df724d1..d0715a2 100644
--- a/fusl/src/math/j1.c
+++ b/fusl/src/math/j1.c
@@ -58,119 +58,116 @@
static double pone(double), qone(double);
-static const double
-invsqrtpi = 5.64189583547756279280e-01, /* 0x3FE20DD7, 0x50429B6D */
-tpi = 6.36619772367581382433e-01; /* 0x3FE45F30, 0x6DC9C883 */
+static const double invsqrtpi =
+ 5.64189583547756279280e-01, /* 0x3FE20DD7, 0x50429B6D */
+ tpi = 6.36619772367581382433e-01; /* 0x3FE45F30, 0x6DC9C883 */
-static double common(uint32_t ix, double x, int y1, int sign)
-{
- double z,s,c,ss,cc;
+static double common(uint32_t ix, double x, int y1, int sign) {
+ double z, s, c, ss, cc;
- /*
- * j1(x) = sqrt(2/(pi*x))*(p1(x)*cos(x-3pi/4)-q1(x)*sin(x-3pi/4))
- * y1(x) = sqrt(2/(pi*x))*(p1(x)*sin(x-3pi/4)+q1(x)*cos(x-3pi/4))
- *
- * sin(x-3pi/4) = -(sin(x) + cos(x))/sqrt(2)
- * cos(x-3pi/4) = (sin(x) - cos(x))/sqrt(2)
- * sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x))
- */
- s = sin(x);
- if (y1)
- s = -s;
- c = cos(x);
- cc = s-c;
- if (ix < 0x7fe00000) {
- /* avoid overflow in 2*x */
- ss = -s-c;
- z = cos(2*x);
- if (s*c > 0)
- cc = z/ss;
- else
- ss = z/cc;
- if (ix < 0x48000000) {
- if (y1)
- ss = -ss;
- cc = pone(x)*cc-qone(x)*ss;
- }
- }
- if (sign)
- cc = -cc;
- return invsqrtpi*cc/sqrt(x);
+ /*
+ * j1(x) = sqrt(2/(pi*x))*(p1(x)*cos(x-3pi/4)-q1(x)*sin(x-3pi/4))
+ * y1(x) = sqrt(2/(pi*x))*(p1(x)*sin(x-3pi/4)+q1(x)*cos(x-3pi/4))
+ *
+ * sin(x-3pi/4) = -(sin(x) + cos(x))/sqrt(2)
+ * cos(x-3pi/4) = (sin(x) - cos(x))/sqrt(2)
+ * sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x))
+ */
+ s = sin(x);
+ if (y1)
+ s = -s;
+ c = cos(x);
+ cc = s - c;
+ if (ix < 0x7fe00000) {
+ /* avoid overflow in 2*x */
+ ss = -s - c;
+ z = cos(2 * x);
+ if (s * c > 0)
+ cc = z / ss;
+ else
+ ss = z / cc;
+ if (ix < 0x48000000) {
+ if (y1)
+ ss = -ss;
+ cc = pone(x) * cc - qone(x) * ss;
+ }
+ }
+ if (sign)
+ cc = -cc;
+ return invsqrtpi * cc / sqrt(x);
}
/* R0/S0 on [0,2] */
static const double
-r00 = -6.25000000000000000000e-02, /* 0xBFB00000, 0x00000000 */
-r01 = 1.40705666955189706048e-03, /* 0x3F570D9F, 0x98472C61 */
-r02 = -1.59955631084035597520e-05, /* 0xBEF0C5C6, 0xBA169668 */
-r03 = 4.96727999609584448412e-08, /* 0x3E6AAAFA, 0x46CA0BD9 */
-s01 = 1.91537599538363460805e-02, /* 0x3F939D0B, 0x12637E53 */
-s02 = 1.85946785588630915560e-04, /* 0x3F285F56, 0xB9CDF664 */
-s03 = 1.17718464042623683263e-06, /* 0x3EB3BFF8, 0x333F8498 */
-s04 = 5.04636257076217042715e-09, /* 0x3E35AC88, 0xC97DFF2C */
-s05 = 1.23542274426137913908e-11; /* 0x3DAB2ACF, 0xCFB97ED8 */
+ r00 = -6.25000000000000000000e-02, /* 0xBFB00000, 0x00000000 */
+ r01 = 1.40705666955189706048e-03, /* 0x3F570D9F, 0x98472C61 */
+ r02 = -1.59955631084035597520e-05, /* 0xBEF0C5C6, 0xBA169668 */
+ r03 = 4.96727999609584448412e-08, /* 0x3E6AAAFA, 0x46CA0BD9 */
+ s01 = 1.91537599538363460805e-02, /* 0x3F939D0B, 0x12637E53 */
+ s02 = 1.85946785588630915560e-04, /* 0x3F285F56, 0xB9CDF664 */
+ s03 = 1.17718464042623683263e-06, /* 0x3EB3BFF8, 0x333F8498 */
+ s04 = 5.04636257076217042715e-09, /* 0x3E35AC88, 0xC97DFF2C */
+ s05 = 1.23542274426137913908e-11; /* 0x3DAB2ACF, 0xCFB97ED8 */
-double j1(double x)
-{
- double z,r,s;
- uint32_t ix;
- int sign;
+double j1(double x) {
+ double z, r, s;
+ uint32_t ix;
+ int sign;
- GET_HIGH_WORD(ix, x);
- sign = ix>>31;
- ix &= 0x7fffffff;
- if (ix >= 0x7ff00000)
- return 1/(x*x);
- if (ix >= 0x40000000) /* |x| >= 2 */
- return common(ix, fabs(x), 0, sign);
- if (ix >= 0x38000000) { /* |x| >= 2**-127 */
- z = x*x;
- r = z*(r00+z*(r01+z*(r02+z*r03)));
- s = 1+z*(s01+z*(s02+z*(s03+z*(s04+z*s05))));
- z = r/s;
- } else
- /* avoid underflow, raise inexact if x!=0 */
- z = x;
- return (0.5 + z)*x;
+ GET_HIGH_WORD(ix, x);
+ sign = ix >> 31;
+ ix &= 0x7fffffff;
+ if (ix >= 0x7ff00000)
+ return 1 / (x * x);
+ if (ix >= 0x40000000) /* |x| >= 2 */
+ return common(ix, fabs(x), 0, sign);
+ if (ix >= 0x38000000) { /* |x| >= 2**-127 */
+ z = x * x;
+ r = z * (r00 + z * (r01 + z * (r02 + z * r03)));
+ s = 1 + z * (s01 + z * (s02 + z * (s03 + z * (s04 + z * s05))));
+ z = r / s;
+ } else
+ /* avoid underflow, raise inexact if x!=0 */
+ z = x;
+ return (0.5 + z) * x;
}
static const double U0[5] = {
- -1.96057090646238940668e-01, /* 0xBFC91866, 0x143CBC8A */
- 5.04438716639811282616e-02, /* 0x3FA9D3C7, 0x76292CD1 */
- -1.91256895875763547298e-03, /* 0xBF5F55E5, 0x4844F50F */
- 2.35252600561610495928e-05, /* 0x3EF8AB03, 0x8FA6B88E */
- -9.19099158039878874504e-08, /* 0xBE78AC00, 0x569105B8 */
+ -1.96057090646238940668e-01, /* 0xBFC91866, 0x143CBC8A */
+ 5.04438716639811282616e-02, /* 0x3FA9D3C7, 0x76292CD1 */
+ -1.91256895875763547298e-03, /* 0xBF5F55E5, 0x4844F50F */
+ 2.35252600561610495928e-05, /* 0x3EF8AB03, 0x8FA6B88E */
+ -9.19099158039878874504e-08, /* 0xBE78AC00, 0x569105B8 */
};
static const double V0[5] = {
- 1.99167318236649903973e-02, /* 0x3F94650D, 0x3F4DA9F0 */
- 2.02552581025135171496e-04, /* 0x3F2A8C89, 0x6C257764 */
- 1.35608801097516229404e-06, /* 0x3EB6C05A, 0x894E8CA6 */
- 6.22741452364621501295e-09, /* 0x3E3ABF1D, 0x5BA69A86 */
- 1.66559246207992079114e-11, /* 0x3DB25039, 0xDACA772A */
+ 1.99167318236649903973e-02, /* 0x3F94650D, 0x3F4DA9F0 */
+ 2.02552581025135171496e-04, /* 0x3F2A8C89, 0x6C257764 */
+ 1.35608801097516229404e-06, /* 0x3EB6C05A, 0x894E8CA6 */
+ 6.22741452364621501295e-09, /* 0x3E3ABF1D, 0x5BA69A86 */
+ 1.66559246207992079114e-11, /* 0x3DB25039, 0xDACA772A */
};
-double y1(double x)
-{
- double z,u,v;
- uint32_t ix,lx;
+double y1(double x) {
+ double z, u, v;
+ uint32_t ix, lx;
- EXTRACT_WORDS(ix, lx, x);
- /* y1(nan)=nan, y1(<0)=nan, y1(0)=-inf, y1(inf)=0 */
- if ((ix<<1 | lx) == 0)
- return -1/0.0;
- if (ix>>31)
- return 0/0.0;
- if (ix >= 0x7ff00000)
- return 1/x;
+ EXTRACT_WORDS(ix, lx, x);
+ /* y1(nan)=nan, y1(<0)=nan, y1(0)=-inf, y1(inf)=0 */
+ if ((ix << 1 | lx) == 0)
+ return -1 / 0.0;
+ if (ix >> 31)
+ return 0 / 0.0;
+ if (ix >= 0x7ff00000)
+ return 1 / x;
- if (ix >= 0x40000000) /* x >= 2 */
- return common(ix, x, 1, 0);
- if (ix < 0x3c900000) /* x < 2**-54 */
- return -tpi/x;
- z = x*x;
- u = U0[0]+z*(U0[1]+z*(U0[2]+z*(U0[3]+z*U0[4])));
- v = 1+z*(V0[0]+z*(V0[1]+z*(V0[2]+z*(V0[3]+z*V0[4]))));
- return x*(u/v) + tpi*(j1(x)*log(x)-1/x);
+ if (ix >= 0x40000000) /* x >= 2 */
+ return common(ix, x, 1, 0);
+ if (ix < 0x3c900000) /* x < 2**-54 */
+ return -tpi / x;
+ z = x * x;
+ u = U0[0] + z * (U0[1] + z * (U0[2] + z * (U0[3] + z * U0[4])));
+ v = 1 + z * (V0[0] + z * (V0[1] + z * (V0[2] + z * (V0[3] + z * V0[4]))));
+ return x * (u / v) + tpi * (j1(x) * log(x) - 1 / x);
}
/* For x >= 8, the asymptotic expansions of pone is
@@ -183,86 +180,97 @@
* | pone(x)-1-R/S | <= 2 ** ( -60.06)
*/
-static const double pr8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
- 0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */
- 1.17187499999988647970e-01, /* 0x3FBDFFFF, 0xFFFFFCCE */
- 1.32394806593073575129e+01, /* 0x402A7A9D, 0x357F7FCE */
- 4.12051854307378562225e+02, /* 0x4079C0D4, 0x652EA590 */
- 3.87474538913960532227e+03, /* 0x40AE457D, 0xA3A532CC */
- 7.91447954031891731574e+03, /* 0x40BEEA7A, 0xC32782DD */
+static const double pr8[6] = {
+ /* for x in [inf, 8]=1/[0,0.125] */
+ 0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */
+ 1.17187499999988647970e-01, /* 0x3FBDFFFF, 0xFFFFFCCE */
+ 1.32394806593073575129e+01, /* 0x402A7A9D, 0x357F7FCE */
+ 4.12051854307378562225e+02, /* 0x4079C0D4, 0x652EA590 */
+ 3.87474538913960532227e+03, /* 0x40AE457D, 0xA3A532CC */
+ 7.91447954031891731574e+03, /* 0x40BEEA7A, 0xC32782DD */
};
static const double ps8[5] = {
- 1.14207370375678408436e+02, /* 0x405C8D45, 0x8E656CAC */
- 3.65093083420853463394e+03, /* 0x40AC85DC, 0x964D274F */
- 3.69562060269033463555e+04, /* 0x40E20B86, 0x97C5BB7F */
- 9.76027935934950801311e+04, /* 0x40F7D42C, 0xB28F17BB */
- 3.08042720627888811578e+04, /* 0x40DE1511, 0x697A0B2D */
+ 1.14207370375678408436e+02, /* 0x405C8D45, 0x8E656CAC */
+ 3.65093083420853463394e+03, /* 0x40AC85DC, 0x964D274F */
+ 3.69562060269033463555e+04, /* 0x40E20B86, 0x97C5BB7F */
+ 9.76027935934950801311e+04, /* 0x40F7D42C, 0xB28F17BB */
+ 3.08042720627888811578e+04, /* 0x40DE1511, 0x697A0B2D */
};
-static const double pr5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
- 1.31990519556243522749e-11, /* 0x3DAD0667, 0xDAE1CA7D */
- 1.17187493190614097638e-01, /* 0x3FBDFFFF, 0xE2C10043 */
- 6.80275127868432871736e+00, /* 0x401B3604, 0x6E6315E3 */
- 1.08308182990189109773e+02, /* 0x405B13B9, 0x452602ED */
- 5.17636139533199752805e+02, /* 0x40802D16, 0xD052D649 */
- 5.28715201363337541807e+02, /* 0x408085B8, 0xBB7E0CB7 */
+static const double pr5[6] = {
+ /* for x in [8,4.5454]=1/[0.125,0.22001] */
+ 1.31990519556243522749e-11, /* 0x3DAD0667, 0xDAE1CA7D */
+ 1.17187493190614097638e-01, /* 0x3FBDFFFF, 0xE2C10043 */
+ 6.80275127868432871736e+00, /* 0x401B3604, 0x6E6315E3 */
+ 1.08308182990189109773e+02, /* 0x405B13B9, 0x452602ED */
+ 5.17636139533199752805e+02, /* 0x40802D16, 0xD052D649 */
+ 5.28715201363337541807e+02, /* 0x408085B8, 0xBB7E0CB7 */
};
static const double ps5[5] = {
- 5.92805987221131331921e+01, /* 0x404DA3EA, 0xA8AF633D */
- 9.91401418733614377743e+02, /* 0x408EFB36, 0x1B066701 */
- 5.35326695291487976647e+03, /* 0x40B4E944, 0x5706B6FB */
- 7.84469031749551231769e+03, /* 0x40BEA4B0, 0xB8A5BB15 */
- 1.50404688810361062679e+03, /* 0x40978030, 0x036F5E51 */
+ 5.92805987221131331921e+01, /* 0x404DA3EA, 0xA8AF633D */
+ 9.91401418733614377743e+02, /* 0x408EFB36, 0x1B066701 */
+ 5.35326695291487976647e+03, /* 0x40B4E944, 0x5706B6FB */
+ 7.84469031749551231769e+03, /* 0x40BEA4B0, 0xB8A5BB15 */
+ 1.50404688810361062679e+03, /* 0x40978030, 0x036F5E51 */
};
static const double pr3[6] = {
- 3.02503916137373618024e-09, /* 0x3E29FC21, 0xA7AD9EDD */
- 1.17186865567253592491e-01, /* 0x3FBDFFF5, 0x5B21D17B */
- 3.93297750033315640650e+00, /* 0x400F76BC, 0xE85EAD8A */
- 3.51194035591636932736e+01, /* 0x40418F48, 0x9DA6D129 */
- 9.10550110750781271918e+01, /* 0x4056C385, 0x4D2C1837 */
- 4.85590685197364919645e+01, /* 0x4048478F, 0x8EA83EE5 */
+ 3.02503916137373618024e-09, /* 0x3E29FC21, 0xA7AD9EDD */
+ 1.17186865567253592491e-01, /* 0x3FBDFFF5, 0x5B21D17B */
+ 3.93297750033315640650e+00, /* 0x400F76BC, 0xE85EAD8A */
+ 3.51194035591636932736e+01, /* 0x40418F48, 0x9DA6D129 */
+ 9.10550110750781271918e+01, /* 0x4056C385, 0x4D2C1837 */
+ 4.85590685197364919645e+01, /* 0x4048478F, 0x8EA83EE5 */
};
static const double ps3[5] = {
- 3.47913095001251519989e+01, /* 0x40416549, 0xA134069C */
- 3.36762458747825746741e+02, /* 0x40750C33, 0x07F1A75F */
- 1.04687139975775130551e+03, /* 0x40905B7C, 0x5037D523 */
- 8.90811346398256432622e+02, /* 0x408BD67D, 0xA32E31E9 */
- 1.03787932439639277504e+02, /* 0x4059F26D, 0x7C2EED53 */
+ 3.47913095001251519989e+01, /* 0x40416549, 0xA134069C */
+ 3.36762458747825746741e+02, /* 0x40750C33, 0x07F1A75F */
+ 1.04687139975775130551e+03, /* 0x40905B7C, 0x5037D523 */
+ 8.90811346398256432622e+02, /* 0x408BD67D, 0xA32E31E9 */
+ 1.03787932439639277504e+02, /* 0x4059F26D, 0x7C2EED53 */
};
-static const double pr2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
- 1.07710830106873743082e-07, /* 0x3E7CE9D4, 0xF65544F4 */
- 1.17176219462683348094e-01, /* 0x3FBDFF42, 0xBE760D83 */
- 2.36851496667608785174e+00, /* 0x4002F2B7, 0xF98FAEC0 */
- 1.22426109148261232917e+01, /* 0x40287C37, 0x7F71A964 */
- 1.76939711271687727390e+01, /* 0x4031B1A8, 0x177F8EE2 */
- 5.07352312588818499250e+00, /* 0x40144B49, 0xA574C1FE */
+static const double pr2[6] = {
+ /* for x in [2.8570,2]=1/[0.3499,0.5] */
+ 1.07710830106873743082e-07, /* 0x3E7CE9D4, 0xF65544F4 */
+ 1.17176219462683348094e-01, /* 0x3FBDFF42, 0xBE760D83 */
+ 2.36851496667608785174e+00, /* 0x4002F2B7, 0xF98FAEC0 */
+ 1.22426109148261232917e+01, /* 0x40287C37, 0x7F71A964 */
+ 1.76939711271687727390e+01, /* 0x4031B1A8, 0x177F8EE2 */
+ 5.07352312588818499250e+00, /* 0x40144B49, 0xA574C1FE */
};
static const double ps2[5] = {
- 2.14364859363821409488e+01, /* 0x40356FBD, 0x8AD5ECDC */
- 1.25290227168402751090e+02, /* 0x405F5293, 0x14F92CD5 */
- 2.32276469057162813669e+02, /* 0x406D08D8, 0xD5A2DBD9 */
- 1.17679373287147100768e+02, /* 0x405D6B7A, 0xDA1884A9 */
- 8.36463893371618283368e+00, /* 0x4020BAB1, 0xF44E5192 */
+ 2.14364859363821409488e+01, /* 0x40356FBD, 0x8AD5ECDC */
+ 1.25290227168402751090e+02, /* 0x405F5293, 0x14F92CD5 */
+ 2.32276469057162813669e+02, /* 0x406D08D8, 0xD5A2DBD9 */
+ 1.17679373287147100768e+02, /* 0x405D6B7A, 0xDA1884A9 */
+ 8.36463893371618283368e+00, /* 0x4020BAB1, 0xF44E5192 */
};
-static double pone(double x)
-{
- const double *p,*q;
- double_t z,r,s;
- uint32_t ix;
+static double pone(double x) {
+ const double *p, *q;
+ double_t z, r, s;
+ uint32_t ix;
- GET_HIGH_WORD(ix, x);
- ix &= 0x7fffffff;
- if (ix >= 0x40200000){p = pr8; q = ps8;}
- else if (ix >= 0x40122E8B){p = pr5; q = ps5;}
- else if (ix >= 0x4006DB6D){p = pr3; q = ps3;}
- else /*ix >= 0x40000000*/ {p = pr2; q = ps2;}
- z = 1.0/(x*x);
- r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
- s = 1.0+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*q[4]))));
- return 1.0+ r/s;
+ GET_HIGH_WORD(ix, x);
+ ix &= 0x7fffffff;
+ if (ix >= 0x40200000) {
+ p = pr8;
+ q = ps8;
+ } else if (ix >= 0x40122E8B) {
+ p = pr5;
+ q = ps5;
+ } else if (ix >= 0x4006DB6D) {
+ p = pr3;
+ q = ps3;
+ } else /*ix >= 0x40000000*/ {
+ p = pr2;
+ q = ps2;
+ }
+ z = 1.0 / (x * x);
+ r = p[0] + z * (p[1] + z * (p[2] + z * (p[3] + z * (p[4] + z * p[5]))));
+ s = 1.0 + z * (q[0] + z * (q[1] + z * (q[2] + z * (q[3] + z * q[4]))));
+ return 1.0 + r / s;
}
/* For x >= 8, the asymptotic expansions of qone is
@@ -275,88 +283,100 @@
* | qone(x)/s -0.375-R/S | <= 2 ** ( -61.13)
*/
-static const double qr8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
- 0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */
- -1.02539062499992714161e-01, /* 0xBFBA3FFF, 0xFFFFFDF3 */
- -1.62717534544589987888e+01, /* 0xC0304591, 0xA26779F7 */
- -7.59601722513950107896e+02, /* 0xC087BCD0, 0x53E4B576 */
- -1.18498066702429587167e+04, /* 0xC0C724E7, 0x40F87415 */
- -4.84385124285750353010e+04, /* 0xC0E7A6D0, 0x65D09C6A */
+static const double qr8[6] = {
+ /* for x in [inf, 8]=1/[0,0.125] */
+ 0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */
+ -1.02539062499992714161e-01, /* 0xBFBA3FFF, 0xFFFFFDF3 */
+ -1.62717534544589987888e+01, /* 0xC0304591, 0xA26779F7 */
+ -7.59601722513950107896e+02, /* 0xC087BCD0, 0x53E4B576 */
+ -1.18498066702429587167e+04, /* 0xC0C724E7, 0x40F87415 */
+ -4.84385124285750353010e+04, /* 0xC0E7A6D0, 0x65D09C6A */
};
static const double qs8[6] = {
- 1.61395369700722909556e+02, /* 0x40642CA6, 0xDE5BCDE5 */
- 7.82538599923348465381e+03, /* 0x40BE9162, 0xD0D88419 */
- 1.33875336287249578163e+05, /* 0x4100579A, 0xB0B75E98 */
- 7.19657723683240939863e+05, /* 0x4125F653, 0x72869C19 */
- 6.66601232617776375264e+05, /* 0x412457D2, 0x7719AD5C */
- -2.94490264303834643215e+05, /* 0xC111F969, 0x0EA5AA18 */
+ 1.61395369700722909556e+02, /* 0x40642CA6, 0xDE5BCDE5 */
+ 7.82538599923348465381e+03, /* 0x40BE9162, 0xD0D88419 */
+ 1.33875336287249578163e+05, /* 0x4100579A, 0xB0B75E98 */
+ 7.19657723683240939863e+05, /* 0x4125F653, 0x72869C19 */
+ 6.66601232617776375264e+05, /* 0x412457D2, 0x7719AD5C */
+ -2.94490264303834643215e+05, /* 0xC111F969, 0x0EA5AA18 */
};
-static const double qr5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
- -2.08979931141764104297e-11, /* 0xBDB6FA43, 0x1AA1A098 */
- -1.02539050241375426231e-01, /* 0xBFBA3FFF, 0xCB597FEF */
- -8.05644828123936029840e+00, /* 0xC0201CE6, 0xCA03AD4B */
- -1.83669607474888380239e+02, /* 0xC066F56D, 0x6CA7B9B0 */
- -1.37319376065508163265e+03, /* 0xC09574C6, 0x6931734F */
- -2.61244440453215656817e+03, /* 0xC0A468E3, 0x88FDA79D */
+static const double qr5[6] = {
+ /* for x in [8,4.5454]=1/[0.125,0.22001] */
+ -2.08979931141764104297e-11, /* 0xBDB6FA43, 0x1AA1A098 */
+ -1.02539050241375426231e-01, /* 0xBFBA3FFF, 0xCB597FEF */
+ -8.05644828123936029840e+00, /* 0xC0201CE6, 0xCA03AD4B */
+ -1.83669607474888380239e+02, /* 0xC066F56D, 0x6CA7B9B0 */
+ -1.37319376065508163265e+03, /* 0xC09574C6, 0x6931734F */
+ -2.61244440453215656817e+03, /* 0xC0A468E3, 0x88FDA79D */
};
static const double qs5[6] = {
- 8.12765501384335777857e+01, /* 0x405451B2, 0xFF5A11B2 */
- 1.99179873460485964642e+03, /* 0x409F1F31, 0xE77BF839 */
- 1.74684851924908907677e+04, /* 0x40D10F1F, 0x0D64CE29 */
- 4.98514270910352279316e+04, /* 0x40E8576D, 0xAABAD197 */
- 2.79480751638918118260e+04, /* 0x40DB4B04, 0xCF7C364B */
- -4.71918354795128470869e+03, /* 0xC0B26F2E, 0xFCFFA004 */
+ 8.12765501384335777857e+01, /* 0x405451B2, 0xFF5A11B2 */
+ 1.99179873460485964642e+03, /* 0x409F1F31, 0xE77BF839 */
+ 1.74684851924908907677e+04, /* 0x40D10F1F, 0x0D64CE29 */
+ 4.98514270910352279316e+04, /* 0x40E8576D, 0xAABAD197 */
+ 2.79480751638918118260e+04, /* 0x40DB4B04, 0xCF7C364B */
+ -4.71918354795128470869e+03, /* 0xC0B26F2E, 0xFCFFA004 */
};
static const double qr3[6] = {
- -5.07831226461766561369e-09, /* 0xBE35CFA9, 0xD38FC84F */
- -1.02537829820837089745e-01, /* 0xBFBA3FEB, 0x51AEED54 */
- -4.61011581139473403113e+00, /* 0xC01270C2, 0x3302D9FF */
- -5.78472216562783643212e+01, /* 0xC04CEC71, 0xC25D16DA */
- -2.28244540737631695038e+02, /* 0xC06C87D3, 0x4718D55F */
- -2.19210128478909325622e+02, /* 0xC06B66B9, 0x5F5C1BF6 */
+ -5.07831226461766561369e-09, /* 0xBE35CFA9, 0xD38FC84F */
+ -1.02537829820837089745e-01, /* 0xBFBA3FEB, 0x51AEED54 */
+ -4.61011581139473403113e+00, /* 0xC01270C2, 0x3302D9FF */
+ -5.78472216562783643212e+01, /* 0xC04CEC71, 0xC25D16DA */
+ -2.28244540737631695038e+02, /* 0xC06C87D3, 0x4718D55F */
+ -2.19210128478909325622e+02, /* 0xC06B66B9, 0x5F5C1BF6 */
};
static const double qs3[6] = {
- 4.76651550323729509273e+01, /* 0x4047D523, 0xCCD367E4 */
- 6.73865112676699709482e+02, /* 0x40850EEB, 0xC031EE3E */
- 3.38015286679526343505e+03, /* 0x40AA684E, 0x448E7C9A */
- 5.54772909720722782367e+03, /* 0x40B5ABBA, 0xA61D54A6 */
- 1.90311919338810798763e+03, /* 0x409DBC7A, 0x0DD4DF4B */
- -1.35201191444307340817e+02, /* 0xC060E670, 0x290A311F */
+ 4.76651550323729509273e+01, /* 0x4047D523, 0xCCD367E4 */
+ 6.73865112676699709482e+02, /* 0x40850EEB, 0xC031EE3E */
+ 3.38015286679526343505e+03, /* 0x40AA684E, 0x448E7C9A */
+ 5.54772909720722782367e+03, /* 0x40B5ABBA, 0xA61D54A6 */
+ 1.90311919338810798763e+03, /* 0x409DBC7A, 0x0DD4DF4B */
+ -1.35201191444307340817e+02, /* 0xC060E670, 0x290A311F */
};
-static const double qr2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
- -1.78381727510958865572e-07, /* 0xBE87F126, 0x44C626D2 */
- -1.02517042607985553460e-01, /* 0xBFBA3E8E, 0x9148B010 */
- -2.75220568278187460720e+00, /* 0xC0060484, 0x69BB4EDA */
- -1.96636162643703720221e+01, /* 0xC033A9E2, 0xC168907F */
- -4.23253133372830490089e+01, /* 0xC04529A3, 0xDE104AAA */
- -2.13719211703704061733e+01, /* 0xC0355F36, 0x39CF6E52 */
+static const double qr2[6] = {
+ /* for x in [2.8570,2]=1/[0.3499,0.5] */
+ -1.78381727510958865572e-07, /* 0xBE87F126, 0x44C626D2 */
+ -1.02517042607985553460e-01, /* 0xBFBA3E8E, 0x9148B010 */
+ -2.75220568278187460720e+00, /* 0xC0060484, 0x69BB4EDA */
+ -1.96636162643703720221e+01, /* 0xC033A9E2, 0xC168907F */
+ -4.23253133372830490089e+01, /* 0xC04529A3, 0xDE104AAA */
+ -2.13719211703704061733e+01, /* 0xC0355F36, 0x39CF6E52 */
};
static const double qs2[6] = {
- 2.95333629060523854548e+01, /* 0x403D888A, 0x78AE64FF */
- 2.52981549982190529136e+02, /* 0x406F9F68, 0xDB821CBA */
- 7.57502834868645436472e+02, /* 0x4087AC05, 0xCE49A0F7 */
- 7.39393205320467245656e+02, /* 0x40871B25, 0x48D4C029 */
- 1.55949003336666123687e+02, /* 0x40637E5E, 0x3C3ED8D4 */
- -4.95949898822628210127e+00, /* 0xC013D686, 0xE71BE86B */
+ 2.95333629060523854548e+01, /* 0x403D888A, 0x78AE64FF */
+ 2.52981549982190529136e+02, /* 0x406F9F68, 0xDB821CBA */
+ 7.57502834868645436472e+02, /* 0x4087AC05, 0xCE49A0F7 */
+ 7.39393205320467245656e+02, /* 0x40871B25, 0x48D4C029 */
+ 1.55949003336666123687e+02, /* 0x40637E5E, 0x3C3ED8D4 */
+ -4.95949898822628210127e+00, /* 0xC013D686, 0xE71BE86B */
};
-static double qone(double x)
-{
- const double *p,*q;
- double_t s,r,z;
- uint32_t ix;
+static double qone(double x) {
+ const double *p, *q;
+ double_t s, r, z;
+ uint32_t ix;
- GET_HIGH_WORD(ix, x);
- ix &= 0x7fffffff;
- if (ix >= 0x40200000){p = qr8; q = qs8;}
- else if (ix >= 0x40122E8B){p = qr5; q = qs5;}
- else if (ix >= 0x4006DB6D){p = qr3; q = qs3;}
- else /*ix >= 0x40000000*/ {p = qr2; q = qs2;}
- z = 1.0/(x*x);
- r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
- s = 1.0+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*(q[4]+z*q[5])))));
- return (.375 + r/s)/x;
+ GET_HIGH_WORD(ix, x);
+ ix &= 0x7fffffff;
+ if (ix >= 0x40200000) {
+ p = qr8;
+ q = qs8;
+ } else if (ix >= 0x40122E8B) {
+ p = qr5;
+ q = qs5;
+ } else if (ix >= 0x4006DB6D) {
+ p = qr3;
+ q = qs3;
+ } else /*ix >= 0x40000000*/ {
+ p = qr2;
+ q = qs2;
+ }
+ z = 1.0 / (x * x);
+ r = p[0] + z * (p[1] + z * (p[2] + z * (p[3] + z * (p[4] + z * p[5]))));
+ s = 1.0 +
+ z * (q[0] + z * (q[1] + z * (q[2] + z * (q[3] + z * (q[4] + z * q[5])))));
+ return (.375 + r / s) / x;
}
diff --git a/fusl/src/math/j1f.c b/fusl/src/math/j1f.c
index 58875af..2001017 100644
--- a/fusl/src/math/j1f.c
+++ b/fusl/src/math/j1f.c
@@ -18,108 +18,103 @@
static float ponef(float), qonef(float);
-static const float
-invsqrtpi = 5.6418961287e-01, /* 0x3f106ebb */
-tpi = 6.3661974669e-01; /* 0x3f22f983 */
+static const float invsqrtpi = 5.6418961287e-01, /* 0x3f106ebb */
+ tpi = 6.3661974669e-01; /* 0x3f22f983 */
-static float common(uint32_t ix, float x, int y1, int sign)
-{
- double z,s,c,ss,cc;
+static float common(uint32_t ix, float x, int y1, int sign) {
+ double z, s, c, ss, cc;
- s = sinf(x);
- if (y1)
- s = -s;
- c = cosf(x);
- cc = s-c;
- if (ix < 0x7f000000) {
- ss = -s-c;
- z = cosf(2*x);
- if (s*c > 0)
- cc = z/ss;
- else
- ss = z/cc;
- if (ix < 0x58800000) {
- if (y1)
- ss = -ss;
- cc = ponef(x)*cc-qonef(x)*ss;
- }
- }
- if (sign)
- cc = -cc;
- return invsqrtpi*cc/sqrtf(x);
+ s = sinf(x);
+ if (y1)
+ s = -s;
+ c = cosf(x);
+ cc = s - c;
+ if (ix < 0x7f000000) {
+ ss = -s - c;
+ z = cosf(2 * x);
+ if (s * c > 0)
+ cc = z / ss;
+ else
+ ss = z / cc;
+ if (ix < 0x58800000) {
+ if (y1)
+ ss = -ss;
+ cc = ponef(x) * cc - qonef(x) * ss;
+ }
+ }
+ if (sign)
+ cc = -cc;
+ return invsqrtpi * cc / sqrtf(x);
}
/* R0/S0 on [0,2] */
-static const float
-r00 = -6.2500000000e-02, /* 0xbd800000 */
-r01 = 1.4070566976e-03, /* 0x3ab86cfd */
-r02 = -1.5995563444e-05, /* 0xb7862e36 */
-r03 = 4.9672799207e-08, /* 0x335557d2 */
-s01 = 1.9153760746e-02, /* 0x3c9ce859 */
-s02 = 1.8594678841e-04, /* 0x3942fab6 */
-s03 = 1.1771846857e-06, /* 0x359dffc2 */
-s04 = 5.0463624390e-09, /* 0x31ad6446 */
-s05 = 1.2354227016e-11; /* 0x2d59567e */
+static const float r00 = -6.2500000000e-02, /* 0xbd800000 */
+ r01 = 1.4070566976e-03, /* 0x3ab86cfd */
+ r02 = -1.5995563444e-05, /* 0xb7862e36 */
+ r03 = 4.9672799207e-08, /* 0x335557d2 */
+ s01 = 1.9153760746e-02, /* 0x3c9ce859 */
+ s02 = 1.8594678841e-04, /* 0x3942fab6 */
+ s03 = 1.1771846857e-06, /* 0x359dffc2 */
+ s04 = 5.0463624390e-09, /* 0x31ad6446 */
+ s05 = 1.2354227016e-11; /* 0x2d59567e */
-float j1f(float x)
-{
- float z,r,s;
- uint32_t ix;
- int sign;
+float j1f(float x) {
+ float z, r, s;
+ uint32_t ix;
+ int sign;
- GET_FLOAT_WORD(ix, x);
- sign = ix>>31;
- ix &= 0x7fffffff;
- if (ix >= 0x7f800000)
- return 1/(x*x);
- if (ix >= 0x40000000) /* |x| >= 2 */
- return common(ix, fabsf(x), 0, sign);
- if (ix >= 0x32000000) { /* |x| >= 2**-27 */
- z = x*x;
- r = z*(r00+z*(r01+z*(r02+z*r03)));
- s = 1+z*(s01+z*(s02+z*(s03+z*(s04+z*s05))));
- z = 0.5f + r/s;
- } else
- /* raise inexact if x!=0 */
- z = 0.5f + x;
- return z*x;
+ GET_FLOAT_WORD(ix, x);
+ sign = ix >> 31;
+ ix &= 0x7fffffff;
+ if (ix >= 0x7f800000)
+ return 1 / (x * x);
+ if (ix >= 0x40000000) /* |x| >= 2 */
+ return common(ix, fabsf(x), 0, sign);
+ if (ix >= 0x32000000) { /* |x| >= 2**-27 */
+ z = x * x;
+ r = z * (r00 + z * (r01 + z * (r02 + z * r03)));
+ s = 1 + z * (s01 + z * (s02 + z * (s03 + z * (s04 + z * s05))));
+ z = 0.5f + r / s;
+ } else
+ /* raise inexact if x!=0 */
+ z = 0.5f + x;
+ return z * x;
}
static const float U0[5] = {
- -1.9605709612e-01, /* 0xbe48c331 */
- 5.0443872809e-02, /* 0x3d4e9e3c */
- -1.9125689287e-03, /* 0xbafaaf2a */
- 2.3525259166e-05, /* 0x37c5581c */
- -9.1909917899e-08, /* 0xb3c56003 */
+ -1.9605709612e-01, /* 0xbe48c331 */
+ 5.0443872809e-02, /* 0x3d4e9e3c */
+ -1.9125689287e-03, /* 0xbafaaf2a */
+ 2.3525259166e-05, /* 0x37c5581c */
+ -9.1909917899e-08, /* 0xb3c56003 */
};
static const float V0[5] = {
- 1.9916731864e-02, /* 0x3ca3286a */
- 2.0255257550e-04, /* 0x3954644b */
- 1.3560879779e-06, /* 0x35b602d4 */
- 6.2274145840e-09, /* 0x31d5f8eb */
- 1.6655924903e-11, /* 0x2d9281cf */
+ 1.9916731864e-02, /* 0x3ca3286a */
+ 2.0255257550e-04, /* 0x3954644b */
+ 1.3560879779e-06, /* 0x35b602d4 */
+ 6.2274145840e-09, /* 0x31d5f8eb */
+ 1.6655924903e-11, /* 0x2d9281cf */
};
-float y1f(float x)
-{
- float z,u,v;
- uint32_t ix;
+float y1f(float x) {
+ float z, u, v;
+ uint32_t ix;
- GET_FLOAT_WORD(ix, x);
- if ((ix & 0x7fffffff) == 0)
- return -1/0.0f;
- if (ix>>31)
- return 0/0.0f;
- if (ix >= 0x7f800000)
- return 1/x;
- if (ix >= 0x40000000) /* |x| >= 2.0 */
- return common(ix,x,1,0);
- if (ix < 0x32000000) /* x < 2**-27 */
- return -tpi/x;
- z = x*x;
- u = U0[0]+z*(U0[1]+z*(U0[2]+z*(U0[3]+z*U0[4])));
- v = 1.0f+z*(V0[0]+z*(V0[1]+z*(V0[2]+z*(V0[3]+z*V0[4]))));
- return x*(u/v) + tpi*(j1f(x)*logf(x)-1.0f/x);
+ GET_FLOAT_WORD(ix, x);
+ if ((ix & 0x7fffffff) == 0)
+ return -1 / 0.0f;
+ if (ix >> 31)
+ return 0 / 0.0f;
+ if (ix >= 0x7f800000)
+ return 1 / x;
+ if (ix >= 0x40000000) /* |x| >= 2.0 */
+ return common(ix, x, 1, 0);
+ if (ix < 0x32000000) /* x < 2**-27 */
+ return -tpi / x;
+ z = x * x;
+ u = U0[0] + z * (U0[1] + z * (U0[2] + z * (U0[3] + z * U0[4])));
+ v = 1.0f + z * (V0[0] + z * (V0[1] + z * (V0[2] + z * (V0[3] + z * V0[4]))));
+ return x * (u / v) + tpi * (j1f(x) * logf(x) - 1.0f / x);
}
/* For x >= 8, the asymptotic expansions of pone is
@@ -132,86 +127,97 @@
* | pone(x)-1-R/S | <= 2 ** ( -60.06)
*/
-static const float pr8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
- 0.0000000000e+00, /* 0x00000000 */
- 1.1718750000e-01, /* 0x3df00000 */
- 1.3239480972e+01, /* 0x4153d4ea */
- 4.1205184937e+02, /* 0x43ce06a3 */
- 3.8747453613e+03, /* 0x45722bed */
- 7.9144794922e+03, /* 0x45f753d6 */
+static const float pr8[6] = {
+ /* for x in [inf, 8]=1/[0,0.125] */
+ 0.0000000000e+00, /* 0x00000000 */
+ 1.1718750000e-01, /* 0x3df00000 */
+ 1.3239480972e+01, /* 0x4153d4ea */
+ 4.1205184937e+02, /* 0x43ce06a3 */
+ 3.8747453613e+03, /* 0x45722bed */
+ 7.9144794922e+03, /* 0x45f753d6 */
};
static const float ps8[5] = {
- 1.1420736694e+02, /* 0x42e46a2c */
- 3.6509309082e+03, /* 0x45642ee5 */
- 3.6956207031e+04, /* 0x47105c35 */
- 9.7602796875e+04, /* 0x47bea166 */
- 3.0804271484e+04, /* 0x46f0a88b */
+ 1.1420736694e+02, /* 0x42e46a2c */
+ 3.6509309082e+03, /* 0x45642ee5 */
+ 3.6956207031e+04, /* 0x47105c35 */
+ 9.7602796875e+04, /* 0x47bea166 */
+ 3.0804271484e+04, /* 0x46f0a88b */
};
-static const float pr5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
- 1.3199052094e-11, /* 0x2d68333f */
- 1.1718749255e-01, /* 0x3defffff */
- 6.8027510643e+00, /* 0x40d9b023 */
- 1.0830818176e+02, /* 0x42d89dca */
- 5.1763616943e+02, /* 0x440168b7 */
- 5.2871520996e+02, /* 0x44042dc6 */
+static const float pr5[6] = {
+ /* for x in [8,4.5454]=1/[0.125,0.22001] */
+ 1.3199052094e-11, /* 0x2d68333f */
+ 1.1718749255e-01, /* 0x3defffff */
+ 6.8027510643e+00, /* 0x40d9b023 */
+ 1.0830818176e+02, /* 0x42d89dca */
+ 5.1763616943e+02, /* 0x440168b7 */
+ 5.2871520996e+02, /* 0x44042dc6 */
};
static const float ps5[5] = {
- 5.9280597687e+01, /* 0x426d1f55 */
- 9.9140142822e+02, /* 0x4477d9b1 */
- 5.3532670898e+03, /* 0x45a74a23 */
- 7.8446904297e+03, /* 0x45f52586 */
- 1.5040468750e+03, /* 0x44bc0180 */
+ 5.9280597687e+01, /* 0x426d1f55 */
+ 9.9140142822e+02, /* 0x4477d9b1 */
+ 5.3532670898e+03, /* 0x45a74a23 */
+ 7.8446904297e+03, /* 0x45f52586 */
+ 1.5040468750e+03, /* 0x44bc0180 */
};
static const float pr3[6] = {
- 3.0250391081e-09, /* 0x314fe10d */
- 1.1718686670e-01, /* 0x3defffab */
- 3.9329774380e+00, /* 0x407bb5e7 */
- 3.5119403839e+01, /* 0x420c7a45 */
- 9.1055007935e+01, /* 0x42b61c2a */
- 4.8559066772e+01, /* 0x42423c7c */
+ 3.0250391081e-09, /* 0x314fe10d */
+ 1.1718686670e-01, /* 0x3defffab */
+ 3.9329774380e+00, /* 0x407bb5e7 */
+ 3.5119403839e+01, /* 0x420c7a45 */
+ 9.1055007935e+01, /* 0x42b61c2a */
+ 4.8559066772e+01, /* 0x42423c7c */
};
static const float ps3[5] = {
- 3.4791309357e+01, /* 0x420b2a4d */
- 3.3676245117e+02, /* 0x43a86198 */
- 1.0468714600e+03, /* 0x4482dbe3 */
- 8.9081134033e+02, /* 0x445eb3ed */
- 1.0378793335e+02, /* 0x42cf936c */
+ 3.4791309357e+01, /* 0x420b2a4d */
+ 3.3676245117e+02, /* 0x43a86198 */
+ 1.0468714600e+03, /* 0x4482dbe3 */
+ 8.9081134033e+02, /* 0x445eb3ed */
+ 1.0378793335e+02, /* 0x42cf936c */
};
-static const float pr2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
- 1.0771083225e-07, /* 0x33e74ea8 */
- 1.1717621982e-01, /* 0x3deffa16 */
- 2.3685150146e+00, /* 0x401795c0 */
- 1.2242610931e+01, /* 0x4143e1bc */
- 1.7693971634e+01, /* 0x418d8d41 */
- 5.0735230446e+00, /* 0x40a25a4d */
+static const float pr2[6] = {
+ /* for x in [2.8570,2]=1/[0.3499,0.5] */
+ 1.0771083225e-07, /* 0x33e74ea8 */
+ 1.1717621982e-01, /* 0x3deffa16 */
+ 2.3685150146e+00, /* 0x401795c0 */
+ 1.2242610931e+01, /* 0x4143e1bc */
+ 1.7693971634e+01, /* 0x418d8d41 */
+ 5.0735230446e+00, /* 0x40a25a4d */
};
static const float ps2[5] = {
- 2.1436485291e+01, /* 0x41ab7dec */
- 1.2529022980e+02, /* 0x42fa9499 */
- 2.3227647400e+02, /* 0x436846c7 */
- 1.1767937469e+02, /* 0x42eb5bd7 */
- 8.3646392822e+00, /* 0x4105d590 */
+ 2.1436485291e+01, /* 0x41ab7dec */
+ 1.2529022980e+02, /* 0x42fa9499 */
+ 2.3227647400e+02, /* 0x436846c7 */
+ 1.1767937469e+02, /* 0x42eb5bd7 */
+ 8.3646392822e+00, /* 0x4105d590 */
};
-static float ponef(float x)
-{
- const float *p,*q;
- float_t z,r,s;
- uint32_t ix;
+static float ponef(float x) {
+ const float *p, *q;
+ float_t z, r, s;
+ uint32_t ix;
- GET_FLOAT_WORD(ix, x);
- ix &= 0x7fffffff;
- if (ix >= 0x41000000){p = pr8; q = ps8;}
- else if (ix >= 0x40f71c58){p = pr5; q = ps5;}
- else if (ix >= 0x4036db68){p = pr3; q = ps3;}
- else /*ix >= 0x40000000*/ {p = pr2; q = ps2;}
- z = 1.0f/(x*x);
- r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
- s = 1.0f+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*q[4]))));
- return 1.0f + r/s;
+ GET_FLOAT_WORD(ix, x);
+ ix &= 0x7fffffff;
+ if (ix >= 0x41000000) {
+ p = pr8;
+ q = ps8;
+ } else if (ix >= 0x40f71c58) {
+ p = pr5;
+ q = ps5;
+ } else if (ix >= 0x4036db68) {
+ p = pr3;
+ q = ps3;
+ } else /*ix >= 0x40000000*/ {
+ p = pr2;
+ q = ps2;
+ }
+ z = 1.0f / (x * x);
+ r = p[0] + z * (p[1] + z * (p[2] + z * (p[3] + z * (p[4] + z * p[5]))));
+ s = 1.0f + z * (q[0] + z * (q[1] + z * (q[2] + z * (q[3] + z * q[4]))));
+ return 1.0f + r / s;
}
/* For x >= 8, the asymptotic expansions of qone is
@@ -224,88 +230,100 @@
* | qone(x)/s -0.375-R/S | <= 2 ** ( -61.13)
*/
-static const float qr8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
- 0.0000000000e+00, /* 0x00000000 */
- -1.0253906250e-01, /* 0xbdd20000 */
- -1.6271753311e+01, /* 0xc1822c8d */
- -7.5960174561e+02, /* 0xc43de683 */
- -1.1849806641e+04, /* 0xc639273a */
- -4.8438511719e+04, /* 0xc73d3683 */
+static const float qr8[6] = {
+ /* for x in [inf, 8]=1/[0,0.125] */
+ 0.0000000000e+00, /* 0x00000000 */
+ -1.0253906250e-01, /* 0xbdd20000 */
+ -1.6271753311e+01, /* 0xc1822c8d */
+ -7.5960174561e+02, /* 0xc43de683 */
+ -1.1849806641e+04, /* 0xc639273a */
+ -4.8438511719e+04, /* 0xc73d3683 */
};
static const float qs8[6] = {
- 1.6139537048e+02, /* 0x43216537 */
- 7.8253862305e+03, /* 0x45f48b17 */
- 1.3387534375e+05, /* 0x4802bcd6 */
- 7.1965775000e+05, /* 0x492fb29c */
- 6.6660125000e+05, /* 0x4922be94 */
- -2.9449025000e+05, /* 0xc88fcb48 */
+ 1.6139537048e+02, /* 0x43216537 */
+ 7.8253862305e+03, /* 0x45f48b17 */
+ 1.3387534375e+05, /* 0x4802bcd6 */
+ 7.1965775000e+05, /* 0x492fb29c */
+ 6.6660125000e+05, /* 0x4922be94 */
+ -2.9449025000e+05, /* 0xc88fcb48 */
};
-static const float qr5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
- -2.0897993405e-11, /* 0xadb7d219 */
- -1.0253904760e-01, /* 0xbdd1fffe */
- -8.0564479828e+00, /* 0xc100e736 */
- -1.8366960144e+02, /* 0xc337ab6b */
- -1.3731937256e+03, /* 0xc4aba633 */
- -2.6124443359e+03, /* 0xc523471c */
+static const float qr5[6] = {
+ /* for x in [8,4.5454]=1/[0.125,0.22001] */
+ -2.0897993405e-11, /* 0xadb7d219 */
+ -1.0253904760e-01, /* 0xbdd1fffe */
+ -8.0564479828e+00, /* 0xc100e736 */
+ -1.8366960144e+02, /* 0xc337ab6b */
+ -1.3731937256e+03, /* 0xc4aba633 */
+ -2.6124443359e+03, /* 0xc523471c */
};
static const float qs5[6] = {
- 8.1276550293e+01, /* 0x42a28d98 */
- 1.9917987061e+03, /* 0x44f8f98f */
- 1.7468484375e+04, /* 0x468878f8 */
- 4.9851425781e+04, /* 0x4742bb6d */
- 2.7948074219e+04, /* 0x46da5826 */
- -4.7191835938e+03, /* 0xc5937978 */
+ 8.1276550293e+01, /* 0x42a28d98 */
+ 1.9917987061e+03, /* 0x44f8f98f */
+ 1.7468484375e+04, /* 0x468878f8 */
+ 4.9851425781e+04, /* 0x4742bb6d */
+ 2.7948074219e+04, /* 0x46da5826 */
+ -4.7191835938e+03, /* 0xc5937978 */
};
static const float qr3[6] = {
- -5.0783124372e-09, /* 0xb1ae7d4f */
- -1.0253783315e-01, /* 0xbdd1ff5b */
- -4.6101160049e+00, /* 0xc0938612 */
- -5.7847221375e+01, /* 0xc267638e */
- -2.2824453735e+02, /* 0xc3643e9a */
- -2.1921012878e+02, /* 0xc35b35cb */
+ -5.0783124372e-09, /* 0xb1ae7d4f */
+ -1.0253783315e-01, /* 0xbdd1ff5b */
+ -4.6101160049e+00, /* 0xc0938612 */
+ -5.7847221375e+01, /* 0xc267638e */
+ -2.2824453735e+02, /* 0xc3643e9a */
+ -2.1921012878e+02, /* 0xc35b35cb */
};
static const float qs3[6] = {
- 4.7665153503e+01, /* 0x423ea91e */
- 6.7386511230e+02, /* 0x4428775e */
- 3.3801528320e+03, /* 0x45534272 */
- 5.5477290039e+03, /* 0x45ad5dd5 */
- 1.9031191406e+03, /* 0x44ede3d0 */
- -1.3520118713e+02, /* 0xc3073381 */
+ 4.7665153503e+01, /* 0x423ea91e */
+ 6.7386511230e+02, /* 0x4428775e */
+ 3.3801528320e+03, /* 0x45534272 */
+ 5.5477290039e+03, /* 0x45ad5dd5 */
+ 1.9031191406e+03, /* 0x44ede3d0 */
+ -1.3520118713e+02, /* 0xc3073381 */
};
-static const float qr2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
- -1.7838172539e-07, /* 0xb43f8932 */
- -1.0251704603e-01, /* 0xbdd1f475 */
- -2.7522056103e+00, /* 0xc0302423 */
- -1.9663616180e+01, /* 0xc19d4f16 */
- -4.2325313568e+01, /* 0xc2294d1f */
- -2.1371921539e+01, /* 0xc1aaf9b2 */
+static const float qr2[6] = {
+ /* for x in [2.8570,2]=1/[0.3499,0.5] */
+ -1.7838172539e-07, /* 0xb43f8932 */
+ -1.0251704603e-01, /* 0xbdd1f475 */
+ -2.7522056103e+00, /* 0xc0302423 */
+ -1.9663616180e+01, /* 0xc19d4f16 */
+ -4.2325313568e+01, /* 0xc2294d1f */
+ -2.1371921539e+01, /* 0xc1aaf9b2 */
};
static const float qs2[6] = {
- 2.9533363342e+01, /* 0x41ec4454 */
- 2.5298155212e+02, /* 0x437cfb47 */
- 7.5750280762e+02, /* 0x443d602e */
- 7.3939318848e+02, /* 0x4438d92a */
- 1.5594900513e+02, /* 0x431bf2f2 */
- -4.9594988823e+00, /* 0xc09eb437 */
+ 2.9533363342e+01, /* 0x41ec4454 */
+ 2.5298155212e+02, /* 0x437cfb47 */
+ 7.5750280762e+02, /* 0x443d602e */
+ 7.3939318848e+02, /* 0x4438d92a */
+ 1.5594900513e+02, /* 0x431bf2f2 */
+ -4.9594988823e+00, /* 0xc09eb437 */
};
-static float qonef(float x)
-{
- const float *p,*q;
- float_t s,r,z;
- uint32_t ix;
+static float qonef(float x) {
+ const float *p, *q;
+ float_t s, r, z;
+ uint32_t ix;
- GET_FLOAT_WORD(ix, x);
- ix &= 0x7fffffff;
- if (ix >= 0x40200000){p = qr8; q = qs8;}
- else if (ix >= 0x40f71c58){p = qr5; q = qs5;}
- else if (ix >= 0x4036db68){p = qr3; q = qs3;}
- else /*ix >= 0x40000000*/ {p = qr2; q = qs2;}
- z = 1.0f/(x*x);
- r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
- s = 1.0f+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*(q[4]+z*q[5])))));
- return (.375f + r/s)/x;
+ GET_FLOAT_WORD(ix, x);
+ ix &= 0x7fffffff;
+ if (ix >= 0x40200000) {
+ p = qr8;
+ q = qs8;
+ } else if (ix >= 0x40f71c58) {
+ p = qr5;
+ q = qs5;
+ } else if (ix >= 0x4036db68) {
+ p = qr3;
+ q = qs3;
+ } else /*ix >= 0x40000000*/ {
+ p = qr2;
+ q = qs2;
+ }
+ z = 1.0f / (x * x);
+ r = p[0] + z * (p[1] + z * (p[2] + z * (p[3] + z * (p[4] + z * p[5]))));
+ s = 1.0f +
+ z * (q[0] + z * (q[1] + z * (q[2] + z * (q[3] + z * (q[4] + z * q[5])))));
+ return (.375f + r / s) / x;
}
diff --git a/fusl/src/math/jn.c b/fusl/src/math/jn.c
index 4878a54..a0dcbaf 100644
--- a/fusl/src/math/jn.c
+++ b/fusl/src/math/jn.c
@@ -36,245 +36,259 @@
#include "libm.h"
-static const double invsqrtpi = 5.64189583547756279280e-01; /* 0x3FE20DD7, 0x50429B6D */
+static const double invsqrtpi =
+ 5.64189583547756279280e-01; /* 0x3FE20DD7, 0x50429B6D */
-double jn(int n, double x)
-{
- uint32_t ix, lx;
- int nm1, i, sign;
- double a, b, temp;
+double jn(int n, double x) {
+ uint32_t ix, lx;
+ int nm1, i, sign;
+ double a, b, temp;
- EXTRACT_WORDS(ix, lx, x);
- sign = ix>>31;
- ix &= 0x7fffffff;
+ EXTRACT_WORDS(ix, lx, x);
+ sign = ix >> 31;
+ ix &= 0x7fffffff;
- if ((ix | (lx|-lx)>>31) > 0x7ff00000) /* nan */
- return x;
+ if ((ix | (lx | -lx) >> 31) > 0x7ff00000) /* nan */
+ return x;
- /* J(-n,x) = (-1)^n * J(n, x), J(n, -x) = (-1)^n * J(n, x)
- * Thus, J(-n,x) = J(n,-x)
- */
- /* nm1 = |n|-1 is used instead of |n| to handle n==INT_MIN */
- if (n == 0)
- return j0(x);
- if (n < 0) {
- nm1 = -(n+1);
- x = -x;
- sign ^= 1;
- } else
- nm1 = n-1;
- if (nm1 == 0)
- return j1(x);
+ /* J(-n,x) = (-1)^n * J(n, x), J(n, -x) = (-1)^n * J(n, x)
+ * Thus, J(-n,x) = J(n,-x)
+ */
+ /* nm1 = |n|-1 is used instead of |n| to handle n==INT_MIN */
+ if (n == 0)
+ return j0(x);
+ if (n < 0) {
+ nm1 = -(n + 1);
+ x = -x;
+ sign ^= 1;
+ } else
+ nm1 = n - 1;
+ if (nm1 == 0)
+ return j1(x);
- sign &= n; /* even n: 0, odd n: signbit(x) */
- x = fabs(x);
- if ((ix|lx) == 0 || ix == 0x7ff00000) /* if x is 0 or inf */
- b = 0.0;
- else if (nm1 < x) {
- /* Safe to use J(n+1,x)=2n/x *J(n,x)-J(n-1,x) */
- if (ix >= 0x52d00000) { /* x > 2**302 */
- /* (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
- */
- switch(nm1&3) {
- case 0: temp = -cos(x)+sin(x); break;
- case 1: temp = -cos(x)-sin(x); break;
- case 2: temp = cos(x)-sin(x); break;
- default:
- case 3: temp = cos(x)+sin(x); break;
- }
- b = invsqrtpi*temp/sqrt(x);
- } else {
- a = j0(x);
- b = j1(x);
- for (i=0; i<nm1; ) {
- i++;
- temp = b;
- b = b*(2.0*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 (nm1 > 32) /* underflow */
- b = 0.0;
- else {
- temp = x*0.5;
- b = temp;
- a = 1.0;
- for (i=2; i<=nm1+1; i++) {
- a *= (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 */
- double t,q0,q1,w,h,z,tmp,nf;
- int k;
+ sign &= n; /* even n: 0, odd n: signbit(x) */
+ x = fabs(x);
+ if ((ix | lx) == 0 || ix == 0x7ff00000) /* if x is 0 or inf */
+ b = 0.0;
+ else if (nm1 < x) {
+ /* Safe to use J(n+1,x)=2n/x *J(n,x)-J(n-1,x) */
+ if (ix >= 0x52d00000) { /* x > 2**302 */
+ /* (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
+ */
+ switch (nm1 & 3) {
+ case 0:
+ temp = -cos(x) + sin(x);
+ break;
+ case 1:
+ temp = -cos(x) - sin(x);
+ break;
+ case 2:
+ temp = cos(x) - sin(x);
+ break;
+ default:
+ case 3:
+ temp = cos(x) + sin(x);
+ break;
+ }
+ b = invsqrtpi * temp / sqrt(x);
+ } else {
+ a = j0(x);
+ b = j1(x);
+ for (i = 0; i < nm1;) {
+ i++;
+ temp = b;
+ b = b * (2.0 * 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 (nm1 > 32) /* underflow */
+ b = 0.0;
+ else {
+ temp = x * 0.5;
+ b = temp;
+ a = 1.0;
+ for (i = 2; i <= nm1 + 1; i++) {
+ a *= (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 */
+ double t, q0, q1, w, h, z, tmp, nf;
+ int k;
- nf = nm1 + 1.0;
- w = 2*nf/x;
- h = 2/x;
- z = w+h;
- q0 = w;
- q1 = w*z - 1.0;
- k = 1;
- while (q1 < 1.0e9) {
- k += 1;
- z += h;
- tmp = z*q1 - q0;
- q0 = q1;
- q1 = tmp;
- }
- for (t=0.0, i=k; i>=0; i--)
- t = 1/(2*(i+nf)/x - t);
- a = t;
- b = 1.0;
- /* 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 = nf*log(fabs(w));
- if (tmp < 7.09782712893383973096e+02) {
- for (i=nm1; i>0; i--) {
- temp = b;
- b = b*(2.0*i)/x - a;
- a = temp;
- }
- } else {
- for (i=nm1; i>0; i--) {
- temp = b;
- b = b*(2.0*i)/x - a;
- a = temp;
- /* scale b to avoid spurious overflow */
- if (b > 0x1p500) {
- a /= b;
- t /= b;
- b = 1.0;
- }
- }
- }
- z = j0(x);
- w = j1(x);
- if (fabs(z) >= fabs(w))
- b = t*z/b;
- else
- b = t*w/a;
- }
- }
- return sign ? -b : b;
+ nf = nm1 + 1.0;
+ w = 2 * nf / x;
+ h = 2 / x;
+ z = w + h;
+ q0 = w;
+ q1 = w * z - 1.0;
+ k = 1;
+ while (q1 < 1.0e9) {
+ k += 1;
+ z += h;
+ tmp = z * q1 - q0;
+ q0 = q1;
+ q1 = tmp;
+ }
+ for (t = 0.0, i = k; i >= 0; i--)
+ t = 1 / (2 * (i + nf) / x - t);
+ a = t;
+ b = 1.0;
+ /* 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 = nf * log(fabs(w));
+ if (tmp < 7.09782712893383973096e+02) {
+ for (i = nm1; i > 0; i--) {
+ temp = b;
+ b = b * (2.0 * i) / x - a;
+ a = temp;
+ }
+ } else {
+ for (i = nm1; i > 0; i--) {
+ temp = b;
+ b = b * (2.0 * i) / x - a;
+ a = temp;
+ /* scale b to avoid spurious overflow */
+ if (b > 0x1p500) {
+ a /= b;
+ t /= b;
+ b = 1.0;
+ }
+ }
+ }
+ z = j0(x);
+ w = j1(x);
+ if (fabs(z) >= fabs(w))
+ b = t * z / b;
+ else
+ b = t * w / a;
+ }
+ }
+ return sign ? -b : b;
}
+double yn(int n, double x) {
+ uint32_t ix, lx, ib;
+ int nm1, sign, i;
+ double a, b, temp;
-double yn(int n, double x)
-{
- uint32_t ix, lx, ib;
- int nm1, sign, i;
- double a, b, temp;
+ EXTRACT_WORDS(ix, lx, x);
+ sign = ix >> 31;
+ ix &= 0x7fffffff;
- EXTRACT_WORDS(ix, lx, x);
- sign = ix>>31;
- ix &= 0x7fffffff;
+ if ((ix | (lx | -lx) >> 31) > 0x7ff00000) /* nan */
+ return x;
+ if (sign && (ix | lx) != 0) /* x < 0 */
+ return 0 / 0.0;
+ if (ix == 0x7ff00000)
+ return 0.0;
- if ((ix | (lx|-lx)>>31) > 0x7ff00000) /* nan */
- return x;
- if (sign && (ix|lx)!=0) /* x < 0 */
- return 0/0.0;
- if (ix == 0x7ff00000)
- return 0.0;
+ if (n == 0)
+ return y0(x);
+ if (n < 0) {
+ nm1 = -(n + 1);
+ sign = n & 1;
+ } else {
+ nm1 = n - 1;
+ sign = 0;
+ }
+ if (nm1 == 0)
+ return sign ? -y1(x) : y1(x);
- if (n == 0)
- return y0(x);
- if (n < 0) {
- nm1 = -(n+1);
- sign = n&1;
- } else {
- nm1 = n-1;
- sign = 0;
- }
- if (nm1 == 0)
- return sign ? -y1(x) : y1(x);
-
- if (ix >= 0x52d00000) { /* x > 2**302 */
- /* (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
- */
- switch(nm1&3) {
- case 0: temp = -sin(x)-cos(x); break;
- case 1: temp = -sin(x)+cos(x); break;
- case 2: temp = sin(x)+cos(x); break;
- default:
- case 3: temp = sin(x)-cos(x); break;
- }
- b = invsqrtpi*temp/sqrt(x);
- } else {
- a = y0(x);
- b = y1(x);
- /* quit if b is -inf */
- GET_HIGH_WORD(ib, b);
- for (i=0; i<nm1 && ib!=0xfff00000; ){
- i++;
- temp = b;
- b = (2.0*i/x)*b - a;
- GET_HIGH_WORD(ib, b);
- a = temp;
- }
- }
- return sign ? -b : b;
+ if (ix >= 0x52d00000) { /* x > 2**302 */
+ /* (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
+ */
+ switch (nm1 & 3) {
+ case 0:
+ temp = -sin(x) - cos(x);
+ break;
+ case 1:
+ temp = -sin(x) + cos(x);
+ break;
+ case 2:
+ temp = sin(x) + cos(x);
+ break;
+ default:
+ case 3:
+ temp = sin(x) - cos(x);
+ break;
+ }
+ b = invsqrtpi * temp / sqrt(x);
+ } else {
+ a = y0(x);
+ b = y1(x);
+ /* quit if b is -inf */
+ GET_HIGH_WORD(ib, b);
+ for (i = 0; i < nm1 && ib != 0xfff00000;) {
+ i++;
+ temp = b;
+ b = (2.0 * i / x) * b - a;
+ GET_HIGH_WORD(ib, b);
+ a = temp;
+ }
+ }
+ return sign ? -b : b;
}
diff --git a/fusl/src/math/jnf.c b/fusl/src/math/jnf.c
index f63c062..6ee472a 100644
--- a/fusl/src/math/jnf.c
+++ b/fusl/src/math/jnf.c
@@ -16,187 +16,185 @@
#define _GNU_SOURCE
#include "libm.h"
-float jnf(int n, float x)
-{
- uint32_t ix;
- int nm1, sign, i;
- float a, b, temp;
+float jnf(int n, float x) {
+ uint32_t ix;
+ int nm1, sign, i;
+ float a, b, temp;
- GET_FLOAT_WORD(ix, x);
- sign = ix>>31;
- ix &= 0x7fffffff;
- if (ix > 0x7f800000) /* nan */
- return x;
+ GET_FLOAT_WORD(ix, x);
+ sign = ix >> 31;
+ ix &= 0x7fffffff;
+ if (ix > 0x7f800000) /* nan */
+ return x;
- /* J(-n,x) = J(n,-x), use |n|-1 to avoid overflow in -n */
- if (n == 0)
- return j0f(x);
- if (n < 0) {
- nm1 = -(n+1);
- x = -x;
- sign ^= 1;
- } else
- nm1 = n-1;
- if (nm1 == 0)
- return j1f(x);
+ /* J(-n,x) = J(n,-x), use |n|-1 to avoid overflow in -n */
+ if (n == 0)
+ return j0f(x);
+ if (n < 0) {
+ nm1 = -(n + 1);
+ x = -x;
+ sign ^= 1;
+ } else
+ nm1 = n - 1;
+ if (nm1 == 0)
+ return j1f(x);
- sign &= n; /* even n: 0, odd n: signbit(x) */
- x = fabsf(x);
- if (ix == 0 || ix == 0x7f800000) /* if x is 0 or inf */
- b = 0.0f;
- else if (nm1 < x) {
- /* Safe to use J(n+1,x)=2n/x *J(n,x)-J(n-1,x) */
- a = j0f(x);
- b = j1f(x);
- for (i=0; i<nm1; ){
- i++;
- temp = b;
- b = b*(2.0f*i/x) - a;
- a = temp;
- }
- } else {
- if (ix < 0x35800000) { /* x < 2**-20 */
- /* x is tiny, return the first Taylor expansion of J(n,x)
- * J(n,x) = 1/n!*(x/2)^n - ...
- */
- if (nm1 > 8) /* underflow */
- nm1 = 8;
- temp = 0.5f * x;
- b = temp;
- a = 1.0f;
- for (i=2; i<=nm1+1; i++) {
- a *= (float)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 */
- float t,q0,q1,w,h,z,tmp,nf;
- int k;
+ sign &= n; /* even n: 0, odd n: signbit(x) */
+ x = fabsf(x);
+ if (ix == 0 || ix == 0x7f800000) /* if x is 0 or inf */
+ b = 0.0f;
+ else if (nm1 < x) {
+ /* Safe to use J(n+1,x)=2n/x *J(n,x)-J(n-1,x) */
+ a = j0f(x);
+ b = j1f(x);
+ for (i = 0; i < nm1;) {
+ i++;
+ temp = b;
+ b = b * (2.0f * i / x) - a;
+ a = temp;
+ }
+ } else {
+ if (ix < 0x35800000) { /* x < 2**-20 */
+ /* x is tiny, return the first Taylor expansion of J(n,x)
+ * J(n,x) = 1/n!*(x/2)^n - ...
+ */
+ if (nm1 > 8) /* underflow */
+ nm1 = 8;
+ temp = 0.5f * x;
+ b = temp;
+ a = 1.0f;
+ for (i = 2; i <= nm1 + 1; i++) {
+ a *= (float)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 */
+ float t, q0, q1, w, h, z, tmp, nf;
+ int k;
- nf = nm1+1.0f;
- w = 2*nf/x;
- h = 2/x;
- z = w+h;
- q0 = w;
- q1 = w*z - 1.0f;
- k = 1;
- while (q1 < 1.0e4f) {
- k += 1;
- z += h;
- tmp = z*q1 - q0;
- q0 = q1;
- q1 = tmp;
- }
- for (t=0.0f, i=k; i>=0; i--)
- t = 1.0f/(2*(i+nf)/x-t);
- a = t;
- b = 1.0f;
- /* 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 = nf*logf(fabsf(w));
- if (tmp < 88.721679688f) {
- for (i=nm1; i>0; i--) {
- temp = b;
- b = 2.0f*i*b/x - a;
- a = temp;
- }
- } else {
- for (i=nm1; i>0; i--){
- temp = b;
- b = 2.0f*i*b/x - a;
- a = temp;
- /* scale b to avoid spurious overflow */
- if (b > 0x1p60f) {
- a /= b;
- t /= b;
- b = 1.0f;
- }
- }
- }
- z = j0f(x);
- w = j1f(x);
- if (fabsf(z) >= fabsf(w))
- b = t*z/b;
- else
- b = t*w/a;
- }
- }
- return sign ? -b : b;
+ nf = nm1 + 1.0f;
+ w = 2 * nf / x;
+ h = 2 / x;
+ z = w + h;
+ q0 = w;
+ q1 = w * z - 1.0f;
+ k = 1;
+ while (q1 < 1.0e4f) {
+ k += 1;
+ z += h;
+ tmp = z * q1 - q0;
+ q0 = q1;
+ q1 = tmp;
+ }
+ for (t = 0.0f, i = k; i >= 0; i--)
+ t = 1.0f / (2 * (i + nf) / x - t);
+ a = t;
+ b = 1.0f;
+ /* 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 = nf * logf(fabsf(w));
+ if (tmp < 88.721679688f) {
+ for (i = nm1; i > 0; i--) {
+ temp = b;
+ b = 2.0f * i * b / x - a;
+ a = temp;
+ }
+ } else {
+ for (i = nm1; i > 0; i--) {
+ temp = b;
+ b = 2.0f * i * b / x - a;
+ a = temp;
+ /* scale b to avoid spurious overflow */
+ if (b > 0x1p60f) {
+ a /= b;
+ t /= b;
+ b = 1.0f;
+ }
+ }
+ }
+ z = j0f(x);
+ w = j1f(x);
+ if (fabsf(z) >= fabsf(w))
+ b = t * z / b;
+ else
+ b = t * w / a;
+ }
+ }
+ return sign ? -b : b;
}
-float ynf(int n, float x)
-{
- uint32_t ix, ib;
- int nm1, sign, i;
- float a, b, temp;
+float ynf(int n, float x) {
+ uint32_t ix, ib;
+ int nm1, sign, i;
+ float a, b, temp;
- GET_FLOAT_WORD(ix, x);
- sign = ix>>31;
- ix &= 0x7fffffff;
- if (ix > 0x7f800000) /* nan */
- return x;
- if (sign && ix != 0) /* x < 0 */
- return 0/0.0f;
- if (ix == 0x7f800000)
- return 0.0f;
+ GET_FLOAT_WORD(ix, x);
+ sign = ix >> 31;
+ ix &= 0x7fffffff;
+ if (ix > 0x7f800000) /* nan */
+ return x;
+ if (sign && ix != 0) /* x < 0 */
+ return 0 / 0.0f;
+ if (ix == 0x7f800000)
+ return 0.0f;
- if (n == 0)
- return y0f(x);
- if (n < 0) {
- nm1 = -(n+1);
- sign = n&1;
- } else {
- nm1 = n-1;
- sign = 0;
- }
- if (nm1 == 0)
- return sign ? -y1f(x) : y1f(x);
+ if (n == 0)
+ return y0f(x);
+ if (n < 0) {
+ nm1 = -(n + 1);
+ sign = n & 1;
+ } else {
+ nm1 = n - 1;
+ sign = 0;
+ }
+ if (nm1 == 0)
+ return sign ? -y1f(x) : y1f(x);
- a = y0f(x);
- b = y1f(x);
- /* quit if b is -inf */
- GET_FLOAT_WORD(ib,b);
- for (i = 0; i < nm1 && ib != 0xff800000; ) {
- i++;
- temp = b;
- b = (2.0f*i/x)*b - a;
- GET_FLOAT_WORD(ib, b);
- a = temp;
- }
- return sign ? -b : b;
+ a = y0f(x);
+ b = y1f(x);
+ /* quit if b is -inf */
+ GET_FLOAT_WORD(ib, b);
+ for (i = 0; i < nm1 && ib != 0xff800000;) {
+ i++;
+ temp = b;
+ b = (2.0f * i / x) * b - a;
+ GET_FLOAT_WORD(ib, b);
+ a = temp;
+ }
+ return sign ? -b : b;
}
diff --git a/fusl/src/math/ldexp.c b/fusl/src/math/ldexp.c
index f4d1cd6..4a7424b 100644
--- a/fusl/src/math/ldexp.c
+++ b/fusl/src/math/ldexp.c
@@ -1,6 +1,5 @@
#include <math.h>
-double ldexp(double x, int n)
-{
- return scalbn(x, n);
+double ldexp(double x, int n) {
+ return scalbn(x, n);
}
diff --git a/fusl/src/math/ldexpf.c b/fusl/src/math/ldexpf.c
index 3bad5f3..71ccf56 100644
--- a/fusl/src/math/ldexpf.c
+++ b/fusl/src/math/ldexpf.c
@@ -1,6 +1,5 @@
#include <math.h>
-float ldexpf(float x, int n)
-{
- return scalbnf(x, n);
+float ldexpf(float x, int n) {
+ return scalbnf(x, n);
}
diff --git a/fusl/src/math/ldexpl.c b/fusl/src/math/ldexpl.c
index fd145cc..fb7d3c2 100644
--- a/fusl/src/math/ldexpl.c
+++ b/fusl/src/math/ldexpl.c
@@ -1,6 +1,5 @@
#include <math.h>
-long double ldexpl(long double x, int n)
-{
- return scalbnl(x, n);
+long double ldexpl(long double x, int n) {
+ return scalbnl(x, n);
}
diff --git a/fusl/src/math/lgamma.c b/fusl/src/math/lgamma.c
index e25ec8e..cea2fc6 100644
--- a/fusl/src/math/lgamma.c
+++ b/fusl/src/math/lgamma.c
@@ -1,9 +1,8 @@
#include <math.h>
extern int __signgam;
-double __lgamma_r(double, int *);
+double __lgamma_r(double, int*);
-double lgamma(double x)
-{
- return __lgamma_r(x, &__signgam);
+double lgamma(double x) {
+ return __lgamma_r(x, &__signgam);
}
diff --git a/fusl/src/math/lgamma_r.c b/fusl/src/math/lgamma_r.c
index fff565d..7dd2851 100644
--- a/fusl/src/math/lgamma_r.c
+++ b/fusl/src/math/lgamma_r.c
@@ -81,204 +81,215 @@
#include "libm.h"
#include "libc.h"
-static const double
-pi = 3.14159265358979311600e+00, /* 0x400921FB, 0x54442D18 */
-a0 = 7.72156649015328655494e-02, /* 0x3FB3C467, 0xE37DB0C8 */
-a1 = 3.22467033424113591611e-01, /* 0x3FD4A34C, 0xC4A60FAD */
-a2 = 6.73523010531292681824e-02, /* 0x3FB13E00, 0x1A5562A7 */
-a3 = 2.05808084325167332806e-02, /* 0x3F951322, 0xAC92547B */
-a4 = 7.38555086081402883957e-03, /* 0x3F7E404F, 0xB68FEFE8 */
-a5 = 2.89051383673415629091e-03, /* 0x3F67ADD8, 0xCCB7926B */
-a6 = 1.19270763183362067845e-03, /* 0x3F538A94, 0x116F3F5D */
-a7 = 5.10069792153511336608e-04, /* 0x3F40B6C6, 0x89B99C00 */
-a8 = 2.20862790713908385557e-04, /* 0x3F2CF2EC, 0xED10E54D */
-a9 = 1.08011567247583939954e-04, /* 0x3F1C5088, 0x987DFB07 */
-a10 = 2.52144565451257326939e-05, /* 0x3EFA7074, 0x428CFA52 */
-a11 = 4.48640949618915160150e-05, /* 0x3F07858E, 0x90A45837 */
-tc = 1.46163214496836224576e+00, /* 0x3FF762D8, 0x6356BE3F */
-tf = -1.21486290535849611461e-01, /* 0xBFBF19B9, 0xBCC38A42 */
-/* tt = -(tail of tf) */
-tt = -3.63867699703950536541e-18, /* 0xBC50C7CA, 0xA48A971F */
-t0 = 4.83836122723810047042e-01, /* 0x3FDEF72B, 0xC8EE38A2 */
-t1 = -1.47587722994593911752e-01, /* 0xBFC2E427, 0x8DC6C509 */
-t2 = 6.46249402391333854778e-02, /* 0x3FB08B42, 0x94D5419B */
-t3 = -3.27885410759859649565e-02, /* 0xBFA0C9A8, 0xDF35B713 */
-t4 = 1.79706750811820387126e-02, /* 0x3F9266E7, 0x970AF9EC */
-t5 = -1.03142241298341437450e-02, /* 0xBF851F9F, 0xBA91EC6A */
-t6 = 6.10053870246291332635e-03, /* 0x3F78FCE0, 0xE370E344 */
-t7 = -3.68452016781138256760e-03, /* 0xBF6E2EFF, 0xB3E914D7 */
-t8 = 2.25964780900612472250e-03, /* 0x3F6282D3, 0x2E15C915 */
-t9 = -1.40346469989232843813e-03, /* 0xBF56FE8E, 0xBF2D1AF1 */
-t10 = 8.81081882437654011382e-04, /* 0x3F4CDF0C, 0xEF61A8E9 */
-t11 = -5.38595305356740546715e-04, /* 0xBF41A610, 0x9C73E0EC */
-t12 = 3.15632070903625950361e-04, /* 0x3F34AF6D, 0x6C0EBBF7 */
-t13 = -3.12754168375120860518e-04, /* 0xBF347F24, 0xECC38C38 */
-t14 = 3.35529192635519073543e-04, /* 0x3F35FD3E, 0xE8C2D3F4 */
-u0 = -7.72156649015328655494e-02, /* 0xBFB3C467, 0xE37DB0C8 */
-u1 = 6.32827064025093366517e-01, /* 0x3FE4401E, 0x8B005DFF */
-u2 = 1.45492250137234768737e+00, /* 0x3FF7475C, 0xD119BD6F */
-u3 = 9.77717527963372745603e-01, /* 0x3FEF4976, 0x44EA8450 */
-u4 = 2.28963728064692451092e-01, /* 0x3FCD4EAE, 0xF6010924 */
-u5 = 1.33810918536787660377e-02, /* 0x3F8B678B, 0xBF2BAB09 */
-v1 = 2.45597793713041134822e+00, /* 0x4003A5D7, 0xC2BD619C */
-v2 = 2.12848976379893395361e+00, /* 0x40010725, 0xA42B18F5 */
-v3 = 7.69285150456672783825e-01, /* 0x3FE89DFB, 0xE45050AF */
-v4 = 1.04222645593369134254e-01, /* 0x3FBAAE55, 0xD6537C88 */
-v5 = 3.21709242282423911810e-03, /* 0x3F6A5ABB, 0x57D0CF61 */
-s0 = -7.72156649015328655494e-02, /* 0xBFB3C467, 0xE37DB0C8 */
-s1 = 2.14982415960608852501e-01, /* 0x3FCB848B, 0x36E20878 */
-s2 = 3.25778796408930981787e-01, /* 0x3FD4D98F, 0x4F139F59 */
-s3 = 1.46350472652464452805e-01, /* 0x3FC2BB9C, 0xBEE5F2F7 */
-s4 = 2.66422703033638609560e-02, /* 0x3F9B481C, 0x7E939961 */
-s5 = 1.84028451407337715652e-03, /* 0x3F5E26B6, 0x7368F239 */
-s6 = 3.19475326584100867617e-05, /* 0x3F00BFEC, 0xDD17E945 */
-r1 = 1.39200533467621045958e+00, /* 0x3FF645A7, 0x62C4AB74 */
-r2 = 7.21935547567138069525e-01, /* 0x3FE71A18, 0x93D3DCDC */
-r3 = 1.71933865632803078993e-01, /* 0x3FC601ED, 0xCCFBDF27 */
-r4 = 1.86459191715652901344e-02, /* 0x3F9317EA, 0x742ED475 */
-r5 = 7.77942496381893596434e-04, /* 0x3F497DDA, 0xCA41A95B */
-r6 = 7.32668430744625636189e-06, /* 0x3EDEBAF7, 0xA5B38140 */
-w0 = 4.18938533204672725052e-01, /* 0x3FDACFE3, 0x90C97D69 */
-w1 = 8.33333333333329678849e-02, /* 0x3FB55555, 0x5555553B */
-w2 = -2.77777777728775536470e-03, /* 0xBF66C16C, 0x16B02E5C */
-w3 = 7.93650558643019558500e-04, /* 0x3F4A019F, 0x98CF38B6 */
-w4 = -5.95187557450339963135e-04, /* 0xBF4380CB, 0x8C0FE741 */
-w5 = 8.36339918996282139126e-04, /* 0x3F4B67BA, 0x4CDAD5D1 */
-w6 = -1.63092934096575273989e-03; /* 0xBF5AB89D, 0x0B9E43E4 */
+static const double pi =
+ 3.14159265358979311600e+00, /* 0x400921FB, 0x54442D18 */
+ a0 = 7.72156649015328655494e-02, /* 0x3FB3C467, 0xE37DB0C8 */
+ a1 = 3.22467033424113591611e-01, /* 0x3FD4A34C, 0xC4A60FAD */
+ a2 = 6.73523010531292681824e-02, /* 0x3FB13E00, 0x1A5562A7 */
+ a3 = 2.05808084325167332806e-02, /* 0x3F951322, 0xAC92547B */
+ a4 = 7.38555086081402883957e-03, /* 0x3F7E404F, 0xB68FEFE8 */
+ a5 = 2.89051383673415629091e-03, /* 0x3F67ADD8, 0xCCB7926B */
+ a6 = 1.19270763183362067845e-03, /* 0x3F538A94, 0x116F3F5D */
+ a7 = 5.10069792153511336608e-04, /* 0x3F40B6C6, 0x89B99C00 */
+ a8 = 2.20862790713908385557e-04, /* 0x3F2CF2EC, 0xED10E54D */
+ a9 = 1.08011567247583939954e-04, /* 0x3F1C5088, 0x987DFB07 */
+ a10 = 2.52144565451257326939e-05, /* 0x3EFA7074, 0x428CFA52 */
+ a11 = 4.48640949618915160150e-05, /* 0x3F07858E, 0x90A45837 */
+ tc = 1.46163214496836224576e+00, /* 0x3FF762D8, 0x6356BE3F */
+ tf = -1.21486290535849611461e-01, /* 0xBFBF19B9, 0xBCC38A42 */
+ /* tt = -(tail of tf) */
+ tt = -3.63867699703950536541e-18, /* 0xBC50C7CA, 0xA48A971F */
+ t0 = 4.83836122723810047042e-01, /* 0x3FDEF72B, 0xC8EE38A2 */
+ t1 = -1.47587722994593911752e-01, /* 0xBFC2E427, 0x8DC6C509 */
+ t2 = 6.46249402391333854778e-02, /* 0x3FB08B42, 0x94D5419B */
+ t3 = -3.27885410759859649565e-02, /* 0xBFA0C9A8, 0xDF35B713 */
+ t4 = 1.79706750811820387126e-02, /* 0x3F9266E7, 0x970AF9EC */
+ t5 = -1.03142241298341437450e-02, /* 0xBF851F9F, 0xBA91EC6A */
+ t6 = 6.10053870246291332635e-03, /* 0x3F78FCE0, 0xE370E344 */
+ t7 = -3.68452016781138256760e-03, /* 0xBF6E2EFF, 0xB3E914D7 */
+ t8 = 2.25964780900612472250e-03, /* 0x3F6282D3, 0x2E15C915 */
+ t9 = -1.40346469989232843813e-03, /* 0xBF56FE8E, 0xBF2D1AF1 */
+ t10 = 8.81081882437654011382e-04, /* 0x3F4CDF0C, 0xEF61A8E9 */
+ t11 = -5.38595305356740546715e-04, /* 0xBF41A610, 0x9C73E0EC */
+ t12 = 3.15632070903625950361e-04, /* 0x3F34AF6D, 0x6C0EBBF7 */
+ t13 = -3.12754168375120860518e-04, /* 0xBF347F24, 0xECC38C38 */
+ t14 = 3.35529192635519073543e-04, /* 0x3F35FD3E, 0xE8C2D3F4 */
+ u0 = -7.72156649015328655494e-02, /* 0xBFB3C467, 0xE37DB0C8 */
+ u1 = 6.32827064025093366517e-01, /* 0x3FE4401E, 0x8B005DFF */
+ u2 = 1.45492250137234768737e+00, /* 0x3FF7475C, 0xD119BD6F */
+ u3 = 9.77717527963372745603e-01, /* 0x3FEF4976, 0x44EA8450 */
+ u4 = 2.28963728064692451092e-01, /* 0x3FCD4EAE, 0xF6010924 */
+ u5 = 1.33810918536787660377e-02, /* 0x3F8B678B, 0xBF2BAB09 */
+ v1 = 2.45597793713041134822e+00, /* 0x4003A5D7, 0xC2BD619C */
+ v2 = 2.12848976379893395361e+00, /* 0x40010725, 0xA42B18F5 */
+ v3 = 7.69285150456672783825e-01, /* 0x3FE89DFB, 0xE45050AF */
+ v4 = 1.04222645593369134254e-01, /* 0x3FBAAE55, 0xD6537C88 */
+ v5 = 3.21709242282423911810e-03, /* 0x3F6A5ABB, 0x57D0CF61 */
+ s0 = -7.72156649015328655494e-02, /* 0xBFB3C467, 0xE37DB0C8 */
+ s1 = 2.14982415960608852501e-01, /* 0x3FCB848B, 0x36E20878 */
+ s2 = 3.25778796408930981787e-01, /* 0x3FD4D98F, 0x4F139F59 */
+ s3 = 1.46350472652464452805e-01, /* 0x3FC2BB9C, 0xBEE5F2F7 */
+ s4 = 2.66422703033638609560e-02, /* 0x3F9B481C, 0x7E939961 */
+ s5 = 1.84028451407337715652e-03, /* 0x3F5E26B6, 0x7368F239 */
+ s6 = 3.19475326584100867617e-05, /* 0x3F00BFEC, 0xDD17E945 */
+ r1 = 1.39200533467621045958e+00, /* 0x3FF645A7, 0x62C4AB74 */
+ r2 = 7.21935547567138069525e-01, /* 0x3FE71A18, 0x93D3DCDC */
+ r3 = 1.71933865632803078993e-01, /* 0x3FC601ED, 0xCCFBDF27 */
+ r4 = 1.86459191715652901344e-02, /* 0x3F9317EA, 0x742ED475 */
+ r5 = 7.77942496381893596434e-04, /* 0x3F497DDA, 0xCA41A95B */
+ r6 = 7.32668430744625636189e-06, /* 0x3EDEBAF7, 0xA5B38140 */
+ w0 = 4.18938533204672725052e-01, /* 0x3FDACFE3, 0x90C97D69 */
+ w1 = 8.33333333333329678849e-02, /* 0x3FB55555, 0x5555553B */
+ w2 = -2.77777777728775536470e-03, /* 0xBF66C16C, 0x16B02E5C */
+ w3 = 7.93650558643019558500e-04, /* 0x3F4A019F, 0x98CF38B6 */
+ w4 = -5.95187557450339963135e-04, /* 0xBF4380CB, 0x8C0FE741 */
+ w5 = 8.36339918996282139126e-04, /* 0x3F4B67BA, 0x4CDAD5D1 */
+ w6 = -1.63092934096575273989e-03; /* 0xBF5AB89D, 0x0B9E43E4 */
/* sin(pi*x) assuming x > 2^-100, if sin(pi*x)==0 the sign is arbitrary */
-static double sin_pi(double x)
-{
- int n;
+static double sin_pi(double x) {
+ int n;
- /* spurious inexact if odd int */
- x = 2.0*(x*0.5 - floor(x*0.5)); /* x mod 2.0 */
+ /* spurious inexact if odd int */
+ x = 2.0 * (x * 0.5 - floor(x * 0.5)); /* x mod 2.0 */
- n = (int)(x*4.0);
- n = (n+1)/2;
- x -= n*0.5f;
- x *= pi;
+ n = (int)(x * 4.0);
+ n = (n + 1) / 2;
+ x -= n * 0.5f;
+ x *= pi;
- switch (n) {
- default: /* case 4: */
- case 0: return __sin(x, 0.0, 0);
- case 1: return __cos(x, 0.0);
- case 2: return __sin(-x, 0.0, 0);
- case 3: return -__cos(x, 0.0);
- }
+ switch (n) {
+ default: /* case 4: */
+ case 0:
+ return __sin(x, 0.0, 0);
+ case 1:
+ return __cos(x, 0.0);
+ case 2:
+ return __sin(-x, 0.0, 0);
+ case 3:
+ return -__cos(x, 0.0);
+ }
}
-double __lgamma_r(double x, int *signgamp)
-{
- union {double f; uint64_t i;} u = {x};
- double_t t,y,z,nadj,p,p1,p2,p3,q,r,w;
- uint32_t ix;
- int sign,i;
+double __lgamma_r(double x, int* signgamp) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {x};
+ double_t t, y, z, nadj, p, p1, p2, p3, q, r, w;
+ uint32_t ix;
+ int sign, i;
- /* purge off +-inf, NaN, +-0, tiny and negative arguments */
- *signgamp = 1;
- sign = u.i>>63;
- ix = u.i>>32 & 0x7fffffff;
- if (ix >= 0x7ff00000)
- return x*x;
- if (ix < (0x3ff-70)<<20) { /* |x|<2**-70, return -log(|x|) */
- if(sign) {
- x = -x;
- *signgamp = -1;
- }
- return -log(x);
- }
- if (sign) {
- x = -x;
- t = sin_pi(x);
- if (t == 0.0) /* -integer */
- return 1.0/(x-x);
- if (t > 0.0)
- *signgamp = -1;
- else
- t = -t;
- nadj = log(pi/(t*x));
- }
+ /* purge off +-inf, NaN, +-0, tiny and negative arguments */
+ *signgamp = 1;
+ sign = u.i >> 63;
+ ix = u.i >> 32 & 0x7fffffff;
+ if (ix >= 0x7ff00000)
+ return x * x;
+ if (ix < (0x3ff - 70) << 20) { /* |x|<2**-70, return -log(|x|) */
+ if (sign) {
+ x = -x;
+ *signgamp = -1;
+ }
+ return -log(x);
+ }
+ if (sign) {
+ x = -x;
+ t = sin_pi(x);
+ if (t == 0.0) /* -integer */
+ return 1.0 / (x - x);
+ if (t > 0.0)
+ *signgamp = -1;
+ else
+ t = -t;
+ nadj = log(pi / (t * x));
+ }
- /* purge off 1 and 2 */
- if ((ix == 0x3ff00000 || ix == 0x40000000) && (uint32_t)u.i == 0)
- r = 0;
- /* for x < 2.0 */
- else if (ix < 0x40000000) {
- if (ix <= 0x3feccccc) { /* lgamma(x) = lgamma(x+1)-log(x) */
- r = -log(x);
- if (ix >= 0x3FE76944) {
- y = 1.0 - x;
- i = 0;
- } else if (ix >= 0x3FCDA661) {
- y = x - (tc-1.0);
- i = 1;
- } else {
- y = x;
- i = 2;
- }
- } else {
- r = 0.0;
- if (ix >= 0x3FFBB4C3) { /* [1.7316,2] */
- y = 2.0 - x;
- i = 0;
- } else if(ix >= 0x3FF3B4C4) { /* [1.23,1.73] */
- y = x - tc;
- i = 1;
- } else {
- y = x - 1.0;
- i = 2;
- }
- }
- switch (i) {
- case 0:
- z = y*y;
- p1 = a0+z*(a2+z*(a4+z*(a6+z*(a8+z*a10))));
- p2 = z*(a1+z*(a3+z*(a5+z*(a7+z*(a9+z*a11)))));
- p = y*p1+p2;
- r += (p-0.5*y);
- break;
- case 1:
- z = y*y;
- w = z*y;
- p1 = t0+w*(t3+w*(t6+w*(t9 +w*t12))); /* parallel comp */
- p2 = t1+w*(t4+w*(t7+w*(t10+w*t13)));
- p3 = t2+w*(t5+w*(t8+w*(t11+w*t14)));
- p = z*p1-(tt-w*(p2+y*p3));
- r += tf + p;
- break;
- case 2:
- p1 = y*(u0+y*(u1+y*(u2+y*(u3+y*(u4+y*u5)))));
- p2 = 1.0+y*(v1+y*(v2+y*(v3+y*(v4+y*v5))));
- r += -0.5*y + p1/p2;
- }
- } else if (ix < 0x40200000) { /* x < 8.0 */
- i = (int)x;
- y = x - (double)i;
- p = y*(s0+y*(s1+y*(s2+y*(s3+y*(s4+y*(s5+y*s6))))));
- q = 1.0+y*(r1+y*(r2+y*(r3+y*(r4+y*(r5+y*r6)))));
- r = 0.5*y+p/q;
- z = 1.0; /* lgamma(1+s) = log(s) + lgamma(s) */
- switch (i) {
- case 7: z *= y + 6.0; /* FALLTHRU */
- case 6: z *= y + 5.0; /* FALLTHRU */
- case 5: z *= y + 4.0; /* FALLTHRU */
- case 4: z *= y + 3.0; /* FALLTHRU */
- case 3: z *= y + 2.0; /* FALLTHRU */
- r += log(z);
- break;
- }
- } else if (ix < 0x43900000) { /* 8.0 <= x < 2**58 */
- t = log(x);
- z = 1.0/x;
- y = z*z;
- w = w0+z*(w1+y*(w2+y*(w3+y*(w4+y*(w5+y*w6)))));
- r = (x-0.5)*(t-1.0)+w;
- } else /* 2**58 <= x <= inf */
- r = x*(log(x)-1.0);
- if (sign)
- r = nadj - r;
- return r;
+ /* purge off 1 and 2 */
+ if ((ix == 0x3ff00000 || ix == 0x40000000) && (uint32_t)u.i == 0)
+ r = 0;
+ /* for x < 2.0 */
+ else if (ix < 0x40000000) {
+ if (ix <= 0x3feccccc) { /* lgamma(x) = lgamma(x+1)-log(x) */
+ r = -log(x);
+ if (ix >= 0x3FE76944) {
+ y = 1.0 - x;
+ i = 0;
+ } else if (ix >= 0x3FCDA661) {
+ y = x - (tc - 1.0);
+ i = 1;
+ } else {
+ y = x;
+ i = 2;
+ }
+ } else {
+ r = 0.0;
+ if (ix >= 0x3FFBB4C3) { /* [1.7316,2] */
+ y = 2.0 - x;
+ i = 0;
+ } else if (ix >= 0x3FF3B4C4) { /* [1.23,1.73] */
+ y = x - tc;
+ i = 1;
+ } else {
+ y = x - 1.0;
+ i = 2;
+ }
+ }
+ switch (i) {
+ case 0:
+ z = y * y;
+ p1 = a0 + z * (a2 + z * (a4 + z * (a6 + z * (a8 + z * a10))));
+ p2 = z * (a1 + z * (a3 + z * (a5 + z * (a7 + z * (a9 + z * a11)))));
+ p = y * p1 + p2;
+ r += (p - 0.5 * y);
+ break;
+ case 1:
+ z = y * y;
+ w = z * y;
+ p1 = t0 + w * (t3 + w * (t6 + w * (t9 + w * t12))); /* parallel comp */
+ p2 = t1 + w * (t4 + w * (t7 + w * (t10 + w * t13)));
+ p3 = t2 + w * (t5 + w * (t8 + w * (t11 + w * t14)));
+ p = z * p1 - (tt - w * (p2 + y * p3));
+ r += tf + p;
+ break;
+ case 2:
+ p1 = y * (u0 + y * (u1 + y * (u2 + y * (u3 + y * (u4 + y * u5)))));
+ p2 = 1.0 + y * (v1 + y * (v2 + y * (v3 + y * (v4 + y * v5))));
+ r += -0.5 * y + p1 / p2;
+ }
+ } else if (ix < 0x40200000) { /* x < 8.0 */
+ i = (int)x;
+ y = x - (double)i;
+ p = y *
+ (s0 + y * (s1 + y * (s2 + y * (s3 + y * (s4 + y * (s5 + y * s6))))));
+ q = 1.0 + y * (r1 + y * (r2 + y * (r3 + y * (r4 + y * (r5 + y * r6)))));
+ r = 0.5 * y + p / q;
+ z = 1.0; /* lgamma(1+s) = log(s) + lgamma(s) */
+ switch (i) {
+ case 7:
+ z *= y + 6.0; /* FALLTHRU */
+ case 6:
+ z *= y + 5.0; /* FALLTHRU */
+ case 5:
+ z *= y + 4.0; /* FALLTHRU */
+ case 4:
+ z *= y + 3.0; /* FALLTHRU */
+ case 3:
+ z *= y + 2.0; /* FALLTHRU */
+ r += log(z);
+ break;
+ }
+ } else if (ix < 0x43900000) { /* 8.0 <= x < 2**58 */
+ t = log(x);
+ z = 1.0 / x;
+ y = z * z;
+ w = w0 + z * (w1 + y * (w2 + y * (w3 + y * (w4 + y * (w5 + y * w6)))));
+ r = (x - 0.5) * (t - 1.0) + w;
+ } else /* 2**58 <= x <= inf */
+ r = x * (log(x) - 1.0);
+ if (sign)
+ r = nadj - r;
+ return r;
}
weak_alias(__lgamma_r, lgamma_r);
diff --git a/fusl/src/math/lgammaf.c b/fusl/src/math/lgammaf.c
index badb6df..a4786c5 100644
--- a/fusl/src/math/lgammaf.c
+++ b/fusl/src/math/lgammaf.c
@@ -1,9 +1,8 @@
#include <math.h>
extern int __signgam;
-float __lgammaf_r(float, int *);
+float __lgammaf_r(float, int*);
-float lgammaf(float x)
-{
- return __lgammaf_r(x, &__signgam);
+float lgammaf(float x) {
+ return __lgammaf_r(x, &__signgam);
}
diff --git a/fusl/src/math/lgammaf_r.c b/fusl/src/math/lgammaf_r.c
index c5b43db..f0c8f4a 100644
--- a/fusl/src/math/lgammaf_r.c
+++ b/fusl/src/math/lgammaf_r.c
@@ -16,204 +16,214 @@
#include "libm.h"
#include "libc.h"
-static const float
-pi = 3.1415927410e+00, /* 0x40490fdb */
-a0 = 7.7215664089e-02, /* 0x3d9e233f */
-a1 = 3.2246702909e-01, /* 0x3ea51a66 */
-a2 = 6.7352302372e-02, /* 0x3d89f001 */
-a3 = 2.0580807701e-02, /* 0x3ca89915 */
-a4 = 7.3855509982e-03, /* 0x3bf2027e */
-a5 = 2.8905137442e-03, /* 0x3b3d6ec6 */
-a6 = 1.1927076848e-03, /* 0x3a9c54a1 */
-a7 = 5.1006977446e-04, /* 0x3a05b634 */
-a8 = 2.2086278477e-04, /* 0x39679767 */
-a9 = 1.0801156895e-04, /* 0x38e28445 */
-a10 = 2.5214456400e-05, /* 0x37d383a2 */
-a11 = 4.4864096708e-05, /* 0x383c2c75 */
-tc = 1.4616321325e+00, /* 0x3fbb16c3 */
-tf = -1.2148628384e-01, /* 0xbdf8cdcd */
-/* tt = -(tail of tf) */
-tt = 6.6971006518e-09, /* 0x31e61c52 */
-t0 = 4.8383611441e-01, /* 0x3ef7b95e */
-t1 = -1.4758771658e-01, /* 0xbe17213c */
-t2 = 6.4624942839e-02, /* 0x3d845a15 */
-t3 = -3.2788541168e-02, /* 0xbd064d47 */
-t4 = 1.7970675603e-02, /* 0x3c93373d */
-t5 = -1.0314224288e-02, /* 0xbc28fcfe */
-t6 = 6.1005386524e-03, /* 0x3bc7e707 */
-t7 = -3.6845202558e-03, /* 0xbb7177fe */
-t8 = 2.2596477065e-03, /* 0x3b141699 */
-t9 = -1.4034647029e-03, /* 0xbab7f476 */
-t10 = 8.8108185446e-04, /* 0x3a66f867 */
-t11 = -5.3859531181e-04, /* 0xba0d3085 */
-t12 = 3.1563205994e-04, /* 0x39a57b6b */
-t13 = -3.1275415677e-04, /* 0xb9a3f927 */
-t14 = 3.3552918467e-04, /* 0x39afe9f7 */
-u0 = -7.7215664089e-02, /* 0xbd9e233f */
-u1 = 6.3282704353e-01, /* 0x3f2200f4 */
-u2 = 1.4549225569e+00, /* 0x3fba3ae7 */
-u3 = 9.7771751881e-01, /* 0x3f7a4bb2 */
-u4 = 2.2896373272e-01, /* 0x3e6a7578 */
-u5 = 1.3381091878e-02, /* 0x3c5b3c5e */
-v1 = 2.4559779167e+00, /* 0x401d2ebe */
-v2 = 2.1284897327e+00, /* 0x4008392d */
-v3 = 7.6928514242e-01, /* 0x3f44efdf */
-v4 = 1.0422264785e-01, /* 0x3dd572af */
-v5 = 3.2170924824e-03, /* 0x3b52d5db */
-s0 = -7.7215664089e-02, /* 0xbd9e233f */
-s1 = 2.1498242021e-01, /* 0x3e5c245a */
-s2 = 3.2577878237e-01, /* 0x3ea6cc7a */
-s3 = 1.4635047317e-01, /* 0x3e15dce6 */
-s4 = 2.6642270386e-02, /* 0x3cda40e4 */
-s5 = 1.8402845599e-03, /* 0x3af135b4 */
-s6 = 3.1947532989e-05, /* 0x3805ff67 */
-r1 = 1.3920053244e+00, /* 0x3fb22d3b */
-r2 = 7.2193557024e-01, /* 0x3f38d0c5 */
-r3 = 1.7193385959e-01, /* 0x3e300f6e */
-r4 = 1.8645919859e-02, /* 0x3c98bf54 */
-r5 = 7.7794247773e-04, /* 0x3a4beed6 */
-r6 = 7.3266842264e-06, /* 0x36f5d7bd */
-w0 = 4.1893854737e-01, /* 0x3ed67f1d */
-w1 = 8.3333335817e-02, /* 0x3daaaaab */
-w2 = -2.7777778450e-03, /* 0xbb360b61 */
-w3 = 7.9365057172e-04, /* 0x3a500cfd */
-w4 = -5.9518753551e-04, /* 0xba1c065c */
-w5 = 8.3633989561e-04, /* 0x3a5b3dd2 */
-w6 = -1.6309292987e-03; /* 0xbad5c4e8 */
+static const float pi = 3.1415927410e+00, /* 0x40490fdb */
+ a0 = 7.7215664089e-02, /* 0x3d9e233f */
+ a1 = 3.2246702909e-01, /* 0x3ea51a66 */
+ a2 = 6.7352302372e-02, /* 0x3d89f001 */
+ a3 = 2.0580807701e-02, /* 0x3ca89915 */
+ a4 = 7.3855509982e-03, /* 0x3bf2027e */
+ a5 = 2.8905137442e-03, /* 0x3b3d6ec6 */
+ a6 = 1.1927076848e-03, /* 0x3a9c54a1 */
+ a7 = 5.1006977446e-04, /* 0x3a05b634 */
+ a8 = 2.2086278477e-04, /* 0x39679767 */
+ a9 = 1.0801156895e-04, /* 0x38e28445 */
+ a10 = 2.5214456400e-05, /* 0x37d383a2 */
+ a11 = 4.4864096708e-05, /* 0x383c2c75 */
+ tc = 1.4616321325e+00, /* 0x3fbb16c3 */
+ tf = -1.2148628384e-01, /* 0xbdf8cdcd */
+ /* tt = -(tail of tf) */
+ tt = 6.6971006518e-09, /* 0x31e61c52 */
+ t0 = 4.8383611441e-01, /* 0x3ef7b95e */
+ t1 = -1.4758771658e-01, /* 0xbe17213c */
+ t2 = 6.4624942839e-02, /* 0x3d845a15 */
+ t3 = -3.2788541168e-02, /* 0xbd064d47 */
+ t4 = 1.7970675603e-02, /* 0x3c93373d */
+ t5 = -1.0314224288e-02, /* 0xbc28fcfe */
+ t6 = 6.1005386524e-03, /* 0x3bc7e707 */
+ t7 = -3.6845202558e-03, /* 0xbb7177fe */
+ t8 = 2.2596477065e-03, /* 0x3b141699 */
+ t9 = -1.4034647029e-03, /* 0xbab7f476 */
+ t10 = 8.8108185446e-04, /* 0x3a66f867 */
+ t11 = -5.3859531181e-04, /* 0xba0d3085 */
+ t12 = 3.1563205994e-04, /* 0x39a57b6b */
+ t13 = -3.1275415677e-04, /* 0xb9a3f927 */
+ t14 = 3.3552918467e-04, /* 0x39afe9f7 */
+ u0 = -7.7215664089e-02, /* 0xbd9e233f */
+ u1 = 6.3282704353e-01, /* 0x3f2200f4 */
+ u2 = 1.4549225569e+00, /* 0x3fba3ae7 */
+ u3 = 9.7771751881e-01, /* 0x3f7a4bb2 */
+ u4 = 2.2896373272e-01, /* 0x3e6a7578 */
+ u5 = 1.3381091878e-02, /* 0x3c5b3c5e */
+ v1 = 2.4559779167e+00, /* 0x401d2ebe */
+ v2 = 2.1284897327e+00, /* 0x4008392d */
+ v3 = 7.6928514242e-01, /* 0x3f44efdf */
+ v4 = 1.0422264785e-01, /* 0x3dd572af */
+ v5 = 3.2170924824e-03, /* 0x3b52d5db */
+ s0 = -7.7215664089e-02, /* 0xbd9e233f */
+ s1 = 2.1498242021e-01, /* 0x3e5c245a */
+ s2 = 3.2577878237e-01, /* 0x3ea6cc7a */
+ s3 = 1.4635047317e-01, /* 0x3e15dce6 */
+ s4 = 2.6642270386e-02, /* 0x3cda40e4 */
+ s5 = 1.8402845599e-03, /* 0x3af135b4 */
+ s6 = 3.1947532989e-05, /* 0x3805ff67 */
+ r1 = 1.3920053244e+00, /* 0x3fb22d3b */
+ r2 = 7.2193557024e-01, /* 0x3f38d0c5 */
+ r3 = 1.7193385959e-01, /* 0x3e300f6e */
+ r4 = 1.8645919859e-02, /* 0x3c98bf54 */
+ r5 = 7.7794247773e-04, /* 0x3a4beed6 */
+ r6 = 7.3266842264e-06, /* 0x36f5d7bd */
+ w0 = 4.1893854737e-01, /* 0x3ed67f1d */
+ w1 = 8.3333335817e-02, /* 0x3daaaaab */
+ w2 = -2.7777778450e-03, /* 0xbb360b61 */
+ w3 = 7.9365057172e-04, /* 0x3a500cfd */
+ w4 = -5.9518753551e-04, /* 0xba1c065c */
+ w5 = 8.3633989561e-04, /* 0x3a5b3dd2 */
+ w6 = -1.6309292987e-03; /* 0xbad5c4e8 */
/* sin(pi*x) assuming x > 2^-100, if sin(pi*x)==0 the sign is arbitrary */
-static float sin_pi(float x)
-{
- double_t y;
- int n;
+static float sin_pi(float x) {
+ double_t y;
+ int n;
- /* spurious inexact if odd int */
- x = 2*(x*0.5f - floorf(x*0.5f)); /* x mod 2.0 */
+ /* spurious inexact if odd int */
+ x = 2 * (x * 0.5f - floorf(x * 0.5f)); /* x mod 2.0 */
- n = (int)(x*4);
- n = (n+1)/2;
- y = x - n*0.5f;
- y *= 3.14159265358979323846;
- switch (n) {
- default: /* case 4: */
- case 0: return __sindf(y);
- case 1: return __cosdf(y);
- case 2: return __sindf(-y);
- case 3: return -__cosdf(y);
- }
+ n = (int)(x * 4);
+ n = (n + 1) / 2;
+ y = x - n * 0.5f;
+ y *= 3.14159265358979323846;
+ switch (n) {
+ default: /* case 4: */
+ case 0:
+ return __sindf(y);
+ case 1:
+ return __cosdf(y);
+ case 2:
+ return __sindf(-y);
+ case 3:
+ return -__cosdf(y);
+ }
}
-float __lgammaf_r(float x, int *signgamp)
-{
- union {float f; uint32_t i;} u = {x};
- float t,y,z,nadj,p,p1,p2,p3,q,r,w;
- uint32_t ix;
- int i,sign;
+float __lgammaf_r(float x, int* signgamp) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {x};
+ float t, y, z, nadj, p, p1, p2, p3, q, r, w;
+ uint32_t ix;
+ int i, sign;
- /* purge off +-inf, NaN, +-0, tiny and negative arguments */
- *signgamp = 1;
- sign = u.i>>31;
- ix = u.i & 0x7fffffff;
- if (ix >= 0x7f800000)
- return x*x;
- if (ix < 0x35000000) { /* |x| < 2**-21, return -log(|x|) */
- if (sign) {
- *signgamp = -1;
- x = -x;
- }
- return -logf(x);
- }
- if (sign) {
- x = -x;
- t = sin_pi(x);
- if (t == 0.0f) /* -integer */
- return 1.0f/(x-x);
- if (t > 0.0f)
- *signgamp = -1;
- else
- t = -t;
- nadj = logf(pi/(t*x));
- }
+ /* purge off +-inf, NaN, +-0, tiny and negative arguments */
+ *signgamp = 1;
+ sign = u.i >> 31;
+ ix = u.i & 0x7fffffff;
+ if (ix >= 0x7f800000)
+ return x * x;
+ if (ix < 0x35000000) { /* |x| < 2**-21, return -log(|x|) */
+ if (sign) {
+ *signgamp = -1;
+ x = -x;
+ }
+ return -logf(x);
+ }
+ if (sign) {
+ x = -x;
+ t = sin_pi(x);
+ if (t == 0.0f) /* -integer */
+ return 1.0f / (x - x);
+ if (t > 0.0f)
+ *signgamp = -1;
+ else
+ t = -t;
+ nadj = logf(pi / (t * x));
+ }
- /* purge off 1 and 2 */
- if (ix == 0x3f800000 || ix == 0x40000000)
- r = 0;
- /* for x < 2.0 */
- else if (ix < 0x40000000) {
- if (ix <= 0x3f666666) { /* lgamma(x) = lgamma(x+1)-log(x) */
- r = -logf(x);
- if (ix >= 0x3f3b4a20) {
- y = 1.0f - x;
- i = 0;
- } else if (ix >= 0x3e6d3308) {
- y = x - (tc-1.0f);
- i = 1;
- } else {
- y = x;
- i = 2;
- }
- } else {
- r = 0.0f;
- if (ix >= 0x3fdda618) { /* [1.7316,2] */
- y = 2.0f - x;
- i = 0;
- } else if (ix >= 0x3F9da620) { /* [1.23,1.73] */
- y = x - tc;
- i = 1;
- } else {
- y = x - 1.0f;
- i = 2;
- }
- }
- switch(i) {
- case 0:
- z = y*y;
- p1 = a0+z*(a2+z*(a4+z*(a6+z*(a8+z*a10))));
- p2 = z*(a1+z*(a3+z*(a5+z*(a7+z*(a9+z*a11)))));
- p = y*p1+p2;
- r += p - 0.5f*y;
- break;
- case 1:
- z = y*y;
- w = z*y;
- p1 = t0+w*(t3+w*(t6+w*(t9 +w*t12))); /* parallel comp */
- p2 = t1+w*(t4+w*(t7+w*(t10+w*t13)));
- p3 = t2+w*(t5+w*(t8+w*(t11+w*t14)));
- p = z*p1-(tt-w*(p2+y*p3));
- r += (tf + p);
- break;
- case 2:
- p1 = y*(u0+y*(u1+y*(u2+y*(u3+y*(u4+y*u5)))));
- p2 = 1.0f+y*(v1+y*(v2+y*(v3+y*(v4+y*v5))));
- r += -0.5f*y + p1/p2;
- }
- } else if (ix < 0x41000000) { /* x < 8.0 */
- i = (int)x;
- y = x - (float)i;
- p = y*(s0+y*(s1+y*(s2+y*(s3+y*(s4+y*(s5+y*s6))))));
- q = 1.0f+y*(r1+y*(r2+y*(r3+y*(r4+y*(r5+y*r6)))));
- r = 0.5f*y+p/q;
- z = 1.0f; /* lgamma(1+s) = log(s) + lgamma(s) */
- switch (i) {
- case 7: z *= y + 6.0f; /* FALLTHRU */
- case 6: z *= y + 5.0f; /* FALLTHRU */
- case 5: z *= y + 4.0f; /* FALLTHRU */
- case 4: z *= y + 3.0f; /* FALLTHRU */
- case 3: z *= y + 2.0f; /* FALLTHRU */
- r += logf(z);
- break;
- }
- } else if (ix < 0x5c800000) { /* 8.0 <= x < 2**58 */
- t = logf(x);
- z = 1.0f/x;
- y = z*z;
- w = w0+z*(w1+y*(w2+y*(w3+y*(w4+y*(w5+y*w6)))));
- r = (x-0.5f)*(t-1.0f)+w;
- } else /* 2**58 <= x <= inf */
- r = x*(logf(x)-1.0f);
- if (sign)
- r = nadj - r;
- return r;
+ /* purge off 1 and 2 */
+ if (ix == 0x3f800000 || ix == 0x40000000)
+ r = 0;
+ /* for x < 2.0 */
+ else if (ix < 0x40000000) {
+ if (ix <= 0x3f666666) { /* lgamma(x) = lgamma(x+1)-log(x) */
+ r = -logf(x);
+ if (ix >= 0x3f3b4a20) {
+ y = 1.0f - x;
+ i = 0;
+ } else if (ix >= 0x3e6d3308) {
+ y = x - (tc - 1.0f);
+ i = 1;
+ } else {
+ y = x;
+ i = 2;
+ }
+ } else {
+ r = 0.0f;
+ if (ix >= 0x3fdda618) { /* [1.7316,2] */
+ y = 2.0f - x;
+ i = 0;
+ } else if (ix >= 0x3F9da620) { /* [1.23,1.73] */
+ y = x - tc;
+ i = 1;
+ } else {
+ y = x - 1.0f;
+ i = 2;
+ }
+ }
+ switch (i) {
+ case 0:
+ z = y * y;
+ p1 = a0 + z * (a2 + z * (a4 + z * (a6 + z * (a8 + z * a10))));
+ p2 = z * (a1 + z * (a3 + z * (a5 + z * (a7 + z * (a9 + z * a11)))));
+ p = y * p1 + p2;
+ r += p - 0.5f * y;
+ break;
+ case 1:
+ z = y * y;
+ w = z * y;
+ p1 = t0 + w * (t3 + w * (t6 + w * (t9 + w * t12))); /* parallel comp */
+ p2 = t1 + w * (t4 + w * (t7 + w * (t10 + w * t13)));
+ p3 = t2 + w * (t5 + w * (t8 + w * (t11 + w * t14)));
+ p = z * p1 - (tt - w * (p2 + y * p3));
+ r += (tf + p);
+ break;
+ case 2:
+ p1 = y * (u0 + y * (u1 + y * (u2 + y * (u3 + y * (u4 + y * u5)))));
+ p2 = 1.0f + y * (v1 + y * (v2 + y * (v3 + y * (v4 + y * v5))));
+ r += -0.5f * y + p1 / p2;
+ }
+ } else if (ix < 0x41000000) { /* x < 8.0 */
+ i = (int)x;
+ y = x - (float)i;
+ p = y *
+ (s0 + y * (s1 + y * (s2 + y * (s3 + y * (s4 + y * (s5 + y * s6))))));
+ q = 1.0f + y * (r1 + y * (r2 + y * (r3 + y * (r4 + y * (r5 + y * r6)))));
+ r = 0.5f * y + p / q;
+ z = 1.0f; /* lgamma(1+s) = log(s) + lgamma(s) */
+ switch (i) {
+ case 7:
+ z *= y + 6.0f; /* FALLTHRU */
+ case 6:
+ z *= y + 5.0f; /* FALLTHRU */
+ case 5:
+ z *= y + 4.0f; /* FALLTHRU */
+ case 4:
+ z *= y + 3.0f; /* FALLTHRU */
+ case 3:
+ z *= y + 2.0f; /* FALLTHRU */
+ r += logf(z);
+ break;
+ }
+ } else if (ix < 0x5c800000) { /* 8.0 <= x < 2**58 */
+ t = logf(x);
+ z = 1.0f / x;
+ y = z * z;
+ w = w0 + z * (w1 + y * (w2 + y * (w3 + y * (w4 + y * (w5 + y * w6)))));
+ r = (x - 0.5f) * (t - 1.0f) + w;
+ } else /* 2**58 <= x <= inf */
+ r = x * (logf(x) - 1.0f);
+ if (sign)
+ r = nadj - r;
+ return r;
}
weak_alias(__lgammaf_r, lgammaf_r);
diff --git a/fusl/src/math/lgammal.c b/fusl/src/math/lgammal.c
index 2b354a7..dcac5e7 100644
--- a/fusl/src/math/lgammal.c
+++ b/fusl/src/math/lgammal.c
@@ -90,271 +90,270 @@
#include "libc.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-double __lgamma_r(double x, int *sg);
+double __lgamma_r(double x, int* sg);
-long double __lgammal_r(long double x, int *sg)
-{
- return __lgamma_r(x, sg);
+long double __lgammal_r(long double x, int* sg) {
+ return __lgamma_r(x, sg);
}
#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
static const long double
-pi = 3.14159265358979323846264L,
+ pi = 3.14159265358979323846264L,
-/* lgam(1+x) = 0.5 x + x a(x)/b(x)
- -0.268402099609375 <= x <= 0
- peak relative error 6.6e-22 */
-a0 = -6.343246574721079391729402781192128239938E2L,
-a1 = 1.856560238672465796768677717168371401378E3L,
-a2 = 2.404733102163746263689288466865843408429E3L,
-a3 = 8.804188795790383497379532868917517596322E2L,
-a4 = 1.135361354097447729740103745999661157426E2L,
-a5 = 3.766956539107615557608581581190400021285E0L,
+ /* lgam(1+x) = 0.5 x + x a(x)/b(x)
+ -0.268402099609375 <= x <= 0
+ peak relative error 6.6e-22 */
+ a0 = -6.343246574721079391729402781192128239938E2L,
+ a1 = 1.856560238672465796768677717168371401378E3L,
+ a2 = 2.404733102163746263689288466865843408429E3L,
+ a3 = 8.804188795790383497379532868917517596322E2L,
+ a4 = 1.135361354097447729740103745999661157426E2L,
+ a5 = 3.766956539107615557608581581190400021285E0L,
-b0 = 8.214973713960928795704317259806842490498E3L,
-b1 = 1.026343508841367384879065363925870888012E4L,
-b2 = 4.553337477045763320522762343132210919277E3L,
-b3 = 8.506975785032585797446253359230031874803E2L,
-b4 = 6.042447899703295436820744186992189445813E1L,
-/* b5 = 1.000000000000000000000000000000000000000E0 */
+ b0 = 8.214973713960928795704317259806842490498E3L,
+ b1 = 1.026343508841367384879065363925870888012E4L,
+ b2 = 4.553337477045763320522762343132210919277E3L,
+ b3 = 8.506975785032585797446253359230031874803E2L,
+ b4 = 6.042447899703295436820744186992189445813E1L,
+ /* b5 = 1.000000000000000000000000000000000000000E0 */
+ tc = 1.4616321449683623412626595423257213284682E0L,
+ tf = -1.2148629053584961146050602565082954242826E-1, /* double precision */
+ /* tt = (tail of tf), i.e. tf + tt has extended precision. */
+ tt = 3.3649914684731379602768989080467587736363E-18L,
+ /* lgam ( 1.4616321449683623412626595423257213284682E0 ) =
+ -1.2148629053584960809551455717769158215135617312999903886372437313313530E-1
+ */
-tc = 1.4616321449683623412626595423257213284682E0L,
-tf = -1.2148629053584961146050602565082954242826E-1, /* double precision */
-/* tt = (tail of tf), i.e. tf + tt has extended precision. */
-tt = 3.3649914684731379602768989080467587736363E-18L,
-/* lgam ( 1.4616321449683623412626595423257213284682E0 ) =
--1.2148629053584960809551455717769158215135617312999903886372437313313530E-1 */
+ /* lgam (x + tc) = tf + tt + x g(x)/h(x)
+ -0.230003726999612341262659542325721328468 <= x
+ <= 0.2699962730003876587373404576742786715318
+ peak relative error 2.1e-21 */
+ g0 = 3.645529916721223331888305293534095553827E-18L,
+ g1 = 5.126654642791082497002594216163574795690E3L,
+ g2 = 8.828603575854624811911631336122070070327E3L,
+ g3 = 5.464186426932117031234820886525701595203E3L,
+ g4 = 1.455427403530884193180776558102868592293E3L,
+ g5 = 1.541735456969245924860307497029155838446E2L,
+ g6 = 4.335498275274822298341872707453445815118E0L,
-/* lgam (x + tc) = tf + tt + x g(x)/h(x)
- -0.230003726999612341262659542325721328468 <= x
- <= 0.2699962730003876587373404576742786715318
- peak relative error 2.1e-21 */
-g0 = 3.645529916721223331888305293534095553827E-18L,
-g1 = 5.126654642791082497002594216163574795690E3L,
-g2 = 8.828603575854624811911631336122070070327E3L,
-g3 = 5.464186426932117031234820886525701595203E3L,
-g4 = 1.455427403530884193180776558102868592293E3L,
-g5 = 1.541735456969245924860307497029155838446E2L,
-g6 = 4.335498275274822298341872707453445815118E0L,
+ h0 = 1.059584930106085509696730443974495979641E4L,
+ h1 = 2.147921653490043010629481226937850618860E4L,
+ h2 = 1.643014770044524804175197151958100656728E4L,
+ h3 = 5.869021995186925517228323497501767586078E3L,
+ h4 = 9.764244777714344488787381271643502742293E2L,
+ h5 = 6.442485441570592541741092969581997002349E1L,
+ /* h6 = 1.000000000000000000000000000000000000000E0 */
-h0 = 1.059584930106085509696730443974495979641E4L,
-h1 = 2.147921653490043010629481226937850618860E4L,
-h2 = 1.643014770044524804175197151958100656728E4L,
-h3 = 5.869021995186925517228323497501767586078E3L,
-h4 = 9.764244777714344488787381271643502742293E2L,
-h5 = 6.442485441570592541741092969581997002349E1L,
-/* h6 = 1.000000000000000000000000000000000000000E0 */
+ /* lgam (x+1) = -0.5 x + x u(x)/v(x)
+ -0.100006103515625 <= x <= 0.231639862060546875
+ peak relative error 1.3e-21 */
+ u0 = -8.886217500092090678492242071879342025627E1L,
+ u1 = 6.840109978129177639438792958320783599310E2L,
+ u2 = 2.042626104514127267855588786511809932433E3L,
+ u3 = 1.911723903442667422201651063009856064275E3L,
+ u4 = 7.447065275665887457628865263491667767695E2L,
+ u5 = 1.132256494121790736268471016493103952637E2L,
+ u6 = 4.484398885516614191003094714505960972894E0L,
+ v0 = 1.150830924194461522996462401210374632929E3L,
+ v1 = 3.399692260848747447377972081399737098610E3L,
+ v2 = 3.786631705644460255229513563657226008015E3L,
+ v3 = 1.966450123004478374557778781564114347876E3L,
+ v4 = 4.741359068914069299837355438370682773122E2L,
+ v5 = 4.508989649747184050907206782117647852364E1L,
+ /* v6 = 1.000000000000000000000000000000000000000E0 */
-/* lgam (x+1) = -0.5 x + x u(x)/v(x)
- -0.100006103515625 <= x <= 0.231639862060546875
- peak relative error 1.3e-21 */
-u0 = -8.886217500092090678492242071879342025627E1L,
-u1 = 6.840109978129177639438792958320783599310E2L,
-u2 = 2.042626104514127267855588786511809932433E3L,
-u3 = 1.911723903442667422201651063009856064275E3L,
-u4 = 7.447065275665887457628865263491667767695E2L,
-u5 = 1.132256494121790736268471016493103952637E2L,
-u6 = 4.484398885516614191003094714505960972894E0L,
+ /* lgam (x+2) = .5 x + x s(x)/r(x)
+ 0 <= x <= 1
+ peak relative error 7.2e-22 */
+ s0 = 1.454726263410661942989109455292824853344E6L,
+ s1 = -3.901428390086348447890408306153378922752E6L,
+ s2 = -6.573568698209374121847873064292963089438E6L,
+ s3 = -3.319055881485044417245964508099095984643E6L,
+ s4 = -7.094891568758439227560184618114707107977E5L,
+ s5 = -6.263426646464505837422314539808112478303E4L,
+ s6 = -1.684926520999477529949915657519454051529E3L,
-v0 = 1.150830924194461522996462401210374632929E3L,
-v1 = 3.399692260848747447377972081399737098610E3L,
-v2 = 3.786631705644460255229513563657226008015E3L,
-v3 = 1.966450123004478374557778781564114347876E3L,
-v4 = 4.741359068914069299837355438370682773122E2L,
-v5 = 4.508989649747184050907206782117647852364E1L,
-/* v6 = 1.000000000000000000000000000000000000000E0 */
+ r0 = -1.883978160734303518163008696712983134698E7L,
+ r1 = -2.815206082812062064902202753264922306830E7L,
+ r2 = -1.600245495251915899081846093343626358398E7L,
+ r3 = -4.310526301881305003489257052083370058799E6L,
+ r4 = -5.563807682263923279438235987186184968542E5L,
+ r5 = -3.027734654434169996032905158145259713083E4L,
+ r6 = -4.501995652861105629217250715790764371267E2L,
+ /* r6 = 1.000000000000000000000000000000000000000E0 */
-
-/* lgam (x+2) = .5 x + x s(x)/r(x)
- 0 <= x <= 1
- peak relative error 7.2e-22 */
-s0 = 1.454726263410661942989109455292824853344E6L,
-s1 = -3.901428390086348447890408306153378922752E6L,
-s2 = -6.573568698209374121847873064292963089438E6L,
-s3 = -3.319055881485044417245964508099095984643E6L,
-s4 = -7.094891568758439227560184618114707107977E5L,
-s5 = -6.263426646464505837422314539808112478303E4L,
-s6 = -1.684926520999477529949915657519454051529E3L,
-
-r0 = -1.883978160734303518163008696712983134698E7L,
-r1 = -2.815206082812062064902202753264922306830E7L,
-r2 = -1.600245495251915899081846093343626358398E7L,
-r3 = -4.310526301881305003489257052083370058799E6L,
-r4 = -5.563807682263923279438235987186184968542E5L,
-r5 = -3.027734654434169996032905158145259713083E4L,
-r6 = -4.501995652861105629217250715790764371267E2L,
-/* r6 = 1.000000000000000000000000000000000000000E0 */
-
-
-/* lgam(x) = ( x - 0.5 ) * log(x) - x + LS2PI + 1/x w(1/x^2)
- x >= 8
- Peak relative error 1.51e-21
-w0 = LS2PI - 0.5 */
-w0 = 4.189385332046727417803e-1L,
-w1 = 8.333333333333331447505E-2L,
-w2 = -2.777777777750349603440E-3L,
-w3 = 7.936507795855070755671E-4L,
-w4 = -5.952345851765688514613E-4L,
-w5 = 8.412723297322498080632E-4L,
-w6 = -1.880801938119376907179E-3L,
-w7 = 4.885026142432270781165E-3L;
+ /* lgam(x) = ( x - 0.5 ) * log(x) - x + LS2PI + 1/x w(1/x^2)
+ x >= 8
+ Peak relative error 1.51e-21
+ w0 = LS2PI - 0.5 */
+ w0 = 4.189385332046727417803e-1L, w1 = 8.333333333333331447505E-2L,
+ w2 = -2.777777777750349603440E-3L, w3 = 7.936507795855070755671E-4L,
+ w4 = -5.952345851765688514613E-4L, w5 = 8.412723297322498080632E-4L,
+ w6 = -1.880801938119376907179E-3L, w7 = 4.885026142432270781165E-3L;
/* sin(pi*x) assuming x > 2^-1000, if sin(pi*x)==0 the sign is arbitrary */
-static long double sin_pi(long double x)
-{
- int n;
+static long double sin_pi(long double x) {
+ int n;
- /* spurious inexact if odd int */
- x *= 0.5;
- x = 2.0*(x - floorl(x)); /* x mod 2.0 */
+ /* spurious inexact if odd int */
+ x *= 0.5;
+ x = 2.0 * (x - floorl(x)); /* x mod 2.0 */
- n = (int)(x*4.0);
- n = (n+1)/2;
- x -= n*0.5f;
- x *= pi;
+ n = (int)(x * 4.0);
+ n = (n + 1) / 2;
+ x -= n * 0.5f;
+ x *= pi;
- switch (n) {
- default: /* case 4: */
- case 0: return __sinl(x, 0.0, 0);
- case 1: return __cosl(x, 0.0);
- case 2: return __sinl(-x, 0.0, 0);
- case 3: return -__cosl(x, 0.0);
- }
+ switch (n) {
+ default: /* case 4: */
+ case 0:
+ return __sinl(x, 0.0, 0);
+ case 1:
+ return __cosl(x, 0.0);
+ case 2:
+ return __sinl(-x, 0.0, 0);
+ case 3:
+ return -__cosl(x, 0.0);
+ }
}
-long double __lgammal_r(long double x, int *sg) {
- long double t, y, z, nadj, p, p1, p2, q, r, w;
- union ldshape u = {x};
- uint32_t ix = (u.i.se & 0x7fffU)<<16 | u.i.m>>48;
- int sign = u.i.se >> 15;
- int i;
+long double __lgammal_r(long double x, int* sg) {
+ long double t, y, z, nadj, p, p1, p2, q, r, w;
+ union ldshape u = {x};
+ uint32_t ix = (u.i.se & 0x7fffU) << 16 | u.i.m >> 48;
+ int sign = u.i.se >> 15;
+ int i;
- *sg = 1;
+ *sg = 1;
- /* purge off +-inf, NaN, +-0, tiny and negative arguments */
- if (ix >= 0x7fff0000)
- return x * x;
- if (ix < 0x3fc08000) { /* |x|<2**-63, return -log(|x|) */
- if (sign) {
- *sg = -1;
- x = -x;
- }
- return -logl(x);
- }
- if (sign) {
- x = -x;
- t = sin_pi(x);
- if (t == 0.0)
- return 1.0 / (x-x); /* -integer */
- if (t > 0.0)
- *sg = -1;
- else
- t = -t;
- nadj = logl(pi / (t * x));
- }
+ /* purge off +-inf, NaN, +-0, tiny and negative arguments */
+ if (ix >= 0x7fff0000)
+ return x * x;
+ if (ix < 0x3fc08000) { /* |x|<2**-63, return -log(|x|) */
+ if (sign) {
+ *sg = -1;
+ x = -x;
+ }
+ return -logl(x);
+ }
+ if (sign) {
+ x = -x;
+ t = sin_pi(x);
+ if (t == 0.0)
+ return 1.0 / (x - x); /* -integer */
+ if (t > 0.0)
+ *sg = -1;
+ else
+ t = -t;
+ nadj = logl(pi / (t * x));
+ }
- /* purge off 1 and 2 (so the sign is ok with downward rounding) */
- if ((ix == 0x3fff8000 || ix == 0x40008000) && u.i.m == 0) {
- r = 0;
- } else if (ix < 0x40008000) { /* x < 2.0 */
- if (ix <= 0x3ffee666) { /* 8.99993896484375e-1 */
- /* lgamma(x) = lgamma(x+1) - log(x) */
- r = -logl(x);
- if (ix >= 0x3ffebb4a) { /* 7.31597900390625e-1 */
- y = x - 1.0;
- i = 0;
- } else if (ix >= 0x3ffced33) { /* 2.31639862060546875e-1 */
- y = x - (tc - 1.0);
- i = 1;
- } else { /* x < 0.23 */
- y = x;
- i = 2;
- }
- } else {
- r = 0.0;
- if (ix >= 0x3fffdda6) { /* 1.73162841796875 */
- /* [1.7316,2] */
- y = x - 2.0;
- i = 0;
- } else if (ix >= 0x3fff9da6) { /* 1.23162841796875 */
- /* [1.23,1.73] */
- y = x - tc;
- i = 1;
- } else {
- /* [0.9, 1.23] */
- y = x - 1.0;
- i = 2;
- }
- }
- switch (i) {
- case 0:
- p1 = a0 + y * (a1 + y * (a2 + y * (a3 + y * (a4 + y * a5))));
- p2 = b0 + y * (b1 + y * (b2 + y * (b3 + y * (b4 + y))));
- r += 0.5 * y + y * p1/p2;
- break;
- case 1:
- p1 = g0 + y * (g1 + y * (g2 + y * (g3 + y * (g4 + y * (g5 + y * g6)))));
- p2 = h0 + y * (h1 + y * (h2 + y * (h3 + y * (h4 + y * (h5 + y)))));
- p = tt + y * p1/p2;
- r += (tf + p);
- break;
- case 2:
- p1 = y * (u0 + y * (u1 + y * (u2 + y * (u3 + y * (u4 + y * (u5 + y * u6))))));
- p2 = v0 + y * (v1 + y * (v2 + y * (v3 + y * (v4 + y * (v5 + y)))));
- r += (-0.5 * y + p1 / p2);
- }
- } else if (ix < 0x40028000) { /* 8.0 */
- /* x < 8.0 */
- i = (int)x;
- y = x - (double)i;
- p = y * (s0 + y * (s1 + y * (s2 + y * (s3 + y * (s4 + y * (s5 + y * s6))))));
- q = r0 + y * (r1 + y * (r2 + y * (r3 + y * (r4 + y * (r5 + y * (r6 + y))))));
- r = 0.5 * y + p / q;
- z = 1.0;
- /* lgamma(1+s) = log(s) + lgamma(s) */
- switch (i) {
- case 7:
- z *= (y + 6.0); /* FALLTHRU */
- case 6:
- z *= (y + 5.0); /* FALLTHRU */
- case 5:
- z *= (y + 4.0); /* FALLTHRU */
- case 4:
- z *= (y + 3.0); /* FALLTHRU */
- case 3:
- z *= (y + 2.0); /* FALLTHRU */
- r += logl(z);
- break;
- }
- } else if (ix < 0x40418000) { /* 2^66 */
- /* 8.0 <= x < 2**66 */
- t = logl(x);
- z = 1.0 / x;
- y = z * z;
- w = w0 + z * (w1 + y * (w2 + y * (w3 + y * (w4 + y * (w5 + y * (w6 + y * w7))))));
- r = (x - 0.5) * (t - 1.0) + w;
- } else /* 2**66 <= x <= inf */
- r = x * (logl(x) - 1.0);
- if (sign)
- r = nadj - r;
- return r;
+ /* purge off 1 and 2 (so the sign is ok with downward rounding) */
+ if ((ix == 0x3fff8000 || ix == 0x40008000) && u.i.m == 0) {
+ r = 0;
+ } else if (ix < 0x40008000) { /* x < 2.0 */
+ if (ix <= 0x3ffee666) { /* 8.99993896484375e-1 */
+ /* lgamma(x) = lgamma(x+1) - log(x) */
+ r = -logl(x);
+ if (ix >= 0x3ffebb4a) { /* 7.31597900390625e-1 */
+ y = x - 1.0;
+ i = 0;
+ } else if (ix >= 0x3ffced33) { /* 2.31639862060546875e-1 */
+ y = x - (tc - 1.0);
+ i = 1;
+ } else { /* x < 0.23 */
+ y = x;
+ i = 2;
+ }
+ } else {
+ r = 0.0;
+ if (ix >= 0x3fffdda6) { /* 1.73162841796875 */
+ /* [1.7316,2] */
+ y = x - 2.0;
+ i = 0;
+ } else if (ix >= 0x3fff9da6) { /* 1.23162841796875 */
+ /* [1.23,1.73] */
+ y = x - tc;
+ i = 1;
+ } else {
+ /* [0.9, 1.23] */
+ y = x - 1.0;
+ i = 2;
+ }
+ }
+ switch (i) {
+ case 0:
+ p1 = a0 + y * (a1 + y * (a2 + y * (a3 + y * (a4 + y * a5))));
+ p2 = b0 + y * (b1 + y * (b2 + y * (b3 + y * (b4 + y))));
+ r += 0.5 * y + y * p1 / p2;
+ break;
+ case 1:
+ p1 = g0 + y * (g1 + y * (g2 + y * (g3 + y * (g4 + y * (g5 + y * g6)))));
+ p2 = h0 + y * (h1 + y * (h2 + y * (h3 + y * (h4 + y * (h5 + y)))));
+ p = tt + y * p1 / p2;
+ r += (tf + p);
+ break;
+ case 2:
+ p1 =
+ y * (u0 +
+ y * (u1 + y * (u2 + y * (u3 + y * (u4 + y * (u5 + y * u6))))));
+ p2 = v0 + y * (v1 + y * (v2 + y * (v3 + y * (v4 + y * (v5 + y)))));
+ r += (-0.5 * y + p1 / p2);
+ }
+ } else if (ix < 0x40028000) { /* 8.0 */
+ /* x < 8.0 */
+ i = (int)x;
+ y = x - (double)i;
+ p = y *
+ (s0 + y * (s1 + y * (s2 + y * (s3 + y * (s4 + y * (s5 + y * s6))))));
+ q = r0 +
+ y * (r1 + y * (r2 + y * (r3 + y * (r4 + y * (r5 + y * (r6 + y))))));
+ r = 0.5 * y + p / q;
+ z = 1.0;
+ /* lgamma(1+s) = log(s) + lgamma(s) */
+ switch (i) {
+ case 7:
+ z *= (y + 6.0); /* FALLTHRU */
+ case 6:
+ z *= (y + 5.0); /* FALLTHRU */
+ case 5:
+ z *= (y + 4.0); /* FALLTHRU */
+ case 4:
+ z *= (y + 3.0); /* FALLTHRU */
+ case 3:
+ z *= (y + 2.0); /* FALLTHRU */
+ r += logl(z);
+ break;
+ }
+ } else if (ix < 0x40418000) { /* 2^66 */
+ /* 8.0 <= x < 2**66 */
+ t = logl(x);
+ z = 1.0 / x;
+ y = z * z;
+ w = w0 +
+ z * (w1 +
+ y * (w2 + y * (w3 + y * (w4 + y * (w5 + y * (w6 + y * w7))))));
+ r = (x - 0.5) * (t - 1.0) + w;
+ } else /* 2**66 <= x <= inf */
+ r = x * (logl(x) - 1.0);
+ if (sign)
+ r = nadj - r;
+ return r;
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
// TODO: broken implementation to make things compile
-double __lgamma_r(double x, int *sg);
+double __lgamma_r(double x, int* sg);
-long double __lgammal_r(long double x, int *sg)
-{
- return __lgamma_r(x, sg);
+long double __lgammal_r(long double x, int* sg) {
+ return __lgamma_r(x, sg);
}
#endif
extern int __signgam;
-long double lgammal(long double x)
-{
- return __lgammal_r(x, &__signgam);
+long double lgammal(long double x) {
+ return __lgammal_r(x, &__signgam);
}
weak_alias(__lgammal_r, lgammal_r);
diff --git a/fusl/src/math/llrint.c b/fusl/src/math/llrint.c
index 4f583ae..d778d1f 100644
--- a/fusl/src/math/llrint.c
+++ b/fusl/src/math/llrint.c
@@ -2,7 +2,6 @@
/* uses LLONG_MAX > 2^53, see comments in lrint.c */
-long long llrint(double x)
-{
- return rint(x);
+long long llrint(double x) {
+ return rint(x);
}
diff --git a/fusl/src/math/llrintf.c b/fusl/src/math/llrintf.c
index 96949a0..d6ae6de 100644
--- a/fusl/src/math/llrintf.c
+++ b/fusl/src/math/llrintf.c
@@ -2,7 +2,6 @@
/* uses LLONG_MAX > 2^24, see comments in lrint.c */
-long long llrintf(float x)
-{
- return rintf(x);
+long long llrintf(float x) {
+ return rintf(x);
}
diff --git a/fusl/src/math/llrintl.c b/fusl/src/math/llrintl.c
index 56150fb..15ab6a5 100644
--- a/fusl/src/math/llrintl.c
+++ b/fusl/src/math/llrintl.c
@@ -2,11 +2,9 @@
#include <fenv.h>
#include "libm.h"
-
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long long llrintl(long double x)
-{
- return llrint(x);
+long long llrintl(long double x) {
+ return llrint(x);
}
#elif defined(FE_INEXACT)
/*
@@ -16,21 +14,19 @@
then x == 2**63 - 0.5 is the only input that overflows and
raises inexact (with tonearest or upward rounding mode)
*/
-long long llrintl(long double x)
-{
- PRAGMA_STDC_FENV_ACCESS_ON
- int e;
+long long llrintl(long double x) {
+ PRAGMA_STDC_FENV_ACCESS_ON
+ int e;
- e = fetestexcept(FE_INEXACT);
- x = rintl(x);
- if (!e && (x > LLONG_MAX || x < LLONG_MIN))
- feclearexcept(FE_INEXACT);
- /* conversion */
- return x;
+ e = fetestexcept(FE_INEXACT);
+ x = rintl(x);
+ if (!e && (x > LLONG_MAX || x < LLONG_MIN))
+ feclearexcept(FE_INEXACT);
+ /* conversion */
+ return x;
}
#else
-long long llrintl(long double x)
-{
- return rintl(x);
+long long llrintl(long double x) {
+ return rintl(x);
}
#endif
diff --git a/fusl/src/math/llround.c b/fusl/src/math/llround.c
index 4d94787..37c49a0 100644
--- a/fusl/src/math/llround.c
+++ b/fusl/src/math/llround.c
@@ -1,6 +1,5 @@
#include <math.h>
-long long llround(double x)
-{
- return round(x);
+long long llround(double x) {
+ return round(x);
}
diff --git a/fusl/src/math/llroundf.c b/fusl/src/math/llroundf.c
index 19eb77e..b2fd7e0 100644
--- a/fusl/src/math/llroundf.c
+++ b/fusl/src/math/llroundf.c
@@ -1,6 +1,5 @@
#include <math.h>
-long long llroundf(float x)
-{
- return roundf(x);
+long long llroundf(float x) {
+ return roundf(x);
}
diff --git a/fusl/src/math/llroundl.c b/fusl/src/math/llroundl.c
index 2c2ee5e..e22c907 100644
--- a/fusl/src/math/llroundl.c
+++ b/fusl/src/math/llroundl.c
@@ -1,6 +1,5 @@
#include <math.h>
-long long llroundl(long double x)
-{
- return roundl(x);
+long long llroundl(long double x) {
+ return roundl(x);
}
diff --git a/fusl/src/math/log.c b/fusl/src/math/log.c
index e61e113..c7e85a9 100644
--- a/fusl/src/math/log.c
+++ b/fusl/src/math/log.c
@@ -63,56 +63,57 @@
#include <math.h>
#include <stdint.h>
-static const double
-ln2_hi = 6.93147180369123816490e-01, /* 3fe62e42 fee00000 */
-ln2_lo = 1.90821492927058770002e-10, /* 3dea39ef 35793c76 */
-Lg1 = 6.666666666666735130e-01, /* 3FE55555 55555593 */
-Lg2 = 3.999999999940941908e-01, /* 3FD99999 9997FA04 */
-Lg3 = 2.857142874366239149e-01, /* 3FD24924 94229359 */
-Lg4 = 2.222219843214978396e-01, /* 3FCC71C5 1D8E78AF */
-Lg5 = 1.818357216161805012e-01, /* 3FC74664 96CB03DE */
-Lg6 = 1.531383769920937332e-01, /* 3FC39A09 D078C69F */
-Lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
+static const double ln2_hi = 6.93147180369123816490e-01, /* 3fe62e42 fee00000 */
+ ln2_lo = 1.90821492927058770002e-10, /* 3dea39ef 35793c76 */
+ Lg1 = 6.666666666666735130e-01, /* 3FE55555 55555593 */
+ Lg2 = 3.999999999940941908e-01, /* 3FD99999 9997FA04 */
+ Lg3 = 2.857142874366239149e-01, /* 3FD24924 94229359 */
+ Lg4 = 2.222219843214978396e-01, /* 3FCC71C5 1D8E78AF */
+ Lg5 = 1.818357216161805012e-01, /* 3FC74664 96CB03DE */
+ Lg6 = 1.531383769920937332e-01, /* 3FC39A09 D078C69F */
+ Lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
-double log(double x)
-{
- union {double f; uint64_t i;} u = {x};
- double_t hfsq,f,s,z,R,w,t1,t2,dk;
- uint32_t hx;
- int k;
+double log(double x) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {x};
+ double_t hfsq, f, s, z, R, w, t1, t2, dk;
+ uint32_t hx;
+ int k;
- hx = u.i>>32;
- k = 0;
- if (hx < 0x00100000 || hx>>31) {
- if (u.i<<1 == 0)
- return -1/(x*x); /* log(+-0)=-inf */
- if (hx>>31)
- return (x-x)/0.0; /* log(-#) = NaN */
- /* subnormal number, scale x up */
- k -= 54;
- x *= 0x1p54;
- u.f = x;
- hx = u.i>>32;
- } else if (hx >= 0x7ff00000) {
- return x;
- } else if (hx == 0x3ff00000 && u.i<<32 == 0)
- return 0;
+ hx = u.i >> 32;
+ k = 0;
+ if (hx < 0x00100000 || hx >> 31) {
+ if (u.i << 1 == 0)
+ return -1 / (x * x); /* log(+-0)=-inf */
+ if (hx >> 31)
+ return (x - x) / 0.0; /* log(-#) = NaN */
+ /* subnormal number, scale x up */
+ k -= 54;
+ x *= 0x1p54;
+ u.f = x;
+ hx = u.i >> 32;
+ } else if (hx >= 0x7ff00000) {
+ return x;
+ } else if (hx == 0x3ff00000 && u.i << 32 == 0)
+ return 0;
- /* reduce x into [sqrt(2)/2, sqrt(2)] */
- hx += 0x3ff00000 - 0x3fe6a09e;
- k += (int)(hx>>20) - 0x3ff;
- hx = (hx&0x000fffff) + 0x3fe6a09e;
- u.i = (uint64_t)hx<<32 | (u.i&0xffffffff);
- x = u.f;
+ /* reduce x into [sqrt(2)/2, sqrt(2)] */
+ hx += 0x3ff00000 - 0x3fe6a09e;
+ k += (int)(hx >> 20) - 0x3ff;
+ hx = (hx & 0x000fffff) + 0x3fe6a09e;
+ u.i = (uint64_t)hx << 32 | (u.i & 0xffffffff);
+ x = u.f;
- f = x - 1.0;
- hfsq = 0.5*f*f;
- s = f/(2.0+f);
- z = s*s;
- w = z*z;
- t1 = w*(Lg2+w*(Lg4+w*Lg6));
- t2 = z*(Lg1+w*(Lg3+w*(Lg5+w*Lg7)));
- R = t2 + t1;
- dk = k;
- return s*(hfsq+R) + dk*ln2_lo - hfsq + f + dk*ln2_hi;
+ f = x - 1.0;
+ hfsq = 0.5 * f * f;
+ s = f / (2.0 + f);
+ z = s * s;
+ w = z * z;
+ t1 = w * (Lg2 + w * (Lg4 + w * Lg6));
+ t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));
+ R = t2 + t1;
+ dk = k;
+ return s * (hfsq + R) + dk * ln2_lo - hfsq + f + dk * ln2_hi;
}
diff --git a/fusl/src/math/log10.c b/fusl/src/math/log10.c
index 8102687..621e15e 100644
--- a/fusl/src/math/log10.c
+++ b/fusl/src/math/log10.c
@@ -20,82 +20,84 @@
#include <math.h>
#include <stdint.h>
-static const double
-ivln10hi = 4.34294481878168880939e-01, /* 0x3fdbcb7b, 0x15200000 */
-ivln10lo = 2.50829467116452752298e-11, /* 0x3dbb9438, 0xca9aadd5 */
-log10_2hi = 3.01029995663611771306e-01, /* 0x3FD34413, 0x509F6000 */
-log10_2lo = 3.69423907715893078616e-13, /* 0x3D59FEF3, 0x11F12B36 */
-Lg1 = 6.666666666666735130e-01, /* 3FE55555 55555593 */
-Lg2 = 3.999999999940941908e-01, /* 3FD99999 9997FA04 */
-Lg3 = 2.857142874366239149e-01, /* 3FD24924 94229359 */
-Lg4 = 2.222219843214978396e-01, /* 3FCC71C5 1D8E78AF */
-Lg5 = 1.818357216161805012e-01, /* 3FC74664 96CB03DE */
-Lg6 = 1.531383769920937332e-01, /* 3FC39A09 D078C69F */
-Lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
+static const double ivln10hi =
+ 4.34294481878168880939e-01, /* 0x3fdbcb7b, 0x15200000 */
+ ivln10lo = 2.50829467116452752298e-11, /* 0x3dbb9438, 0xca9aadd5 */
+ log10_2hi = 3.01029995663611771306e-01, /* 0x3FD34413, 0x509F6000 */
+ log10_2lo = 3.69423907715893078616e-13, /* 0x3D59FEF3, 0x11F12B36 */
+ Lg1 = 6.666666666666735130e-01, /* 3FE55555 55555593 */
+ Lg2 = 3.999999999940941908e-01, /* 3FD99999 9997FA04 */
+ Lg3 = 2.857142874366239149e-01, /* 3FD24924 94229359 */
+ Lg4 = 2.222219843214978396e-01, /* 3FCC71C5 1D8E78AF */
+ Lg5 = 1.818357216161805012e-01, /* 3FC74664 96CB03DE */
+ Lg6 = 1.531383769920937332e-01, /* 3FC39A09 D078C69F */
+ Lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
-double log10(double x)
-{
- union {double f; uint64_t i;} u = {x};
- double_t hfsq,f,s,z,R,w,t1,t2,dk,y,hi,lo,val_hi,val_lo;
- uint32_t hx;
- int k;
+double log10(double x) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {x};
+ double_t hfsq, f, s, z, R, w, t1, t2, dk, y, hi, lo, val_hi, val_lo;
+ uint32_t hx;
+ int k;
- hx = u.i>>32;
- k = 0;
- if (hx < 0x00100000 || hx>>31) {
- if (u.i<<1 == 0)
- return -1/(x*x); /* log(+-0)=-inf */
- if (hx>>31)
- return (x-x)/0.0; /* log(-#) = NaN */
- /* subnormal number, scale x up */
- k -= 54;
- x *= 0x1p54;
- u.f = x;
- hx = u.i>>32;
- } else if (hx >= 0x7ff00000) {
- return x;
- } else if (hx == 0x3ff00000 && u.i<<32 == 0)
- return 0;
+ hx = u.i >> 32;
+ k = 0;
+ if (hx < 0x00100000 || hx >> 31) {
+ if (u.i << 1 == 0)
+ return -1 / (x * x); /* log(+-0)=-inf */
+ if (hx >> 31)
+ return (x - x) / 0.0; /* log(-#) = NaN */
+ /* subnormal number, scale x up */
+ k -= 54;
+ x *= 0x1p54;
+ u.f = x;
+ hx = u.i >> 32;
+ } else if (hx >= 0x7ff00000) {
+ return x;
+ } else if (hx == 0x3ff00000 && u.i << 32 == 0)
+ return 0;
- /* reduce x into [sqrt(2)/2, sqrt(2)] */
- hx += 0x3ff00000 - 0x3fe6a09e;
- k += (int)(hx>>20) - 0x3ff;
- hx = (hx&0x000fffff) + 0x3fe6a09e;
- u.i = (uint64_t)hx<<32 | (u.i&0xffffffff);
- x = u.f;
+ /* reduce x into [sqrt(2)/2, sqrt(2)] */
+ hx += 0x3ff00000 - 0x3fe6a09e;
+ k += (int)(hx >> 20) - 0x3ff;
+ hx = (hx & 0x000fffff) + 0x3fe6a09e;
+ u.i = (uint64_t)hx << 32 | (u.i & 0xffffffff);
+ x = u.f;
- f = x - 1.0;
- hfsq = 0.5*f*f;
- s = f/(2.0+f);
- z = s*s;
- w = z*z;
- t1 = w*(Lg2+w*(Lg4+w*Lg6));
- t2 = z*(Lg1+w*(Lg3+w*(Lg5+w*Lg7)));
- R = t2 + t1;
+ f = x - 1.0;
+ hfsq = 0.5 * f * f;
+ s = f / (2.0 + f);
+ z = s * s;
+ w = z * z;
+ t1 = w * (Lg2 + w * (Lg4 + w * Lg6));
+ t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));
+ R = t2 + t1;
- /* See log2.c for details. */
- /* hi+lo = f - hfsq + s*(hfsq+R) ~ log(1+f) */
- hi = f - hfsq;
- u.f = hi;
- u.i &= (uint64_t)-1<<32;
- hi = u.f;
- lo = f - hi - hfsq + s*(hfsq+R);
+ /* See log2.c for details. */
+ /* hi+lo = f - hfsq + s*(hfsq+R) ~ log(1+f) */
+ hi = f - hfsq;
+ u.f = hi;
+ u.i &= (uint64_t)-1 << 32;
+ hi = u.f;
+ lo = f - hi - hfsq + s * (hfsq + R);
- /* val_hi+val_lo ~ log10(1+f) + k*log10(2) */
- val_hi = hi*ivln10hi;
- dk = k;
- y = dk*log10_2hi;
- val_lo = dk*log10_2lo + (lo+hi)*ivln10lo + lo*ivln10hi;
+ /* val_hi+val_lo ~ log10(1+f) + k*log10(2) */
+ val_hi = hi * ivln10hi;
+ dk = k;
+ y = dk * log10_2hi;
+ val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;
- /*
- * Extra precision in for adding y is not strictly needed
- * since there is no very large cancellation near x = sqrt(2) or
- * x = 1/sqrt(2), but we do it anyway since it costs little on CPUs
- * with some parallelism and it reduces the error for many args.
- */
- w = y + val_hi;
- val_lo += (y - w) + val_hi;
- val_hi = w;
+ /*
+ * Extra precision in for adding y is not strictly needed
+ * since there is no very large cancellation near x = sqrt(2) or
+ * x = 1/sqrt(2), but we do it anyway since it costs little on CPUs
+ * with some parallelism and it reduces the error for many args.
+ */
+ w = y + val_hi;
+ val_lo += (y - w) + val_hi;
+ val_hi = w;
- return val_lo + val_hi;
+ return val_lo + val_hi;
}
diff --git a/fusl/src/math/log10f.c b/fusl/src/math/log10f.c
index 9ca2f01..1958470 100644
--- a/fusl/src/math/log10f.c
+++ b/fusl/src/math/log10f.c
@@ -16,62 +16,64 @@
#include <math.h>
#include <stdint.h>
-static const float
-ivln10hi = 4.3432617188e-01, /* 0x3ede6000 */
-ivln10lo = -3.1689971365e-05, /* 0xb804ead9 */
-log10_2hi = 3.0102920532e-01, /* 0x3e9a2080 */
-log10_2lo = 7.9034151668e-07, /* 0x355427db */
-/* |(log(1+s)-log(1-s))/s - Lg(s)| < 2**-34.24 (~[-4.95e-11, 4.97e-11]). */
-Lg1 = 0xaaaaaa.0p-24, /* 0.66666662693 */
-Lg2 = 0xccce13.0p-25, /* 0.40000972152 */
-Lg3 = 0x91e9ee.0p-25, /* 0.28498786688 */
-Lg4 = 0xf89e26.0p-26; /* 0.24279078841 */
+static const float ivln10hi = 4.3432617188e-01, /* 0x3ede6000 */
+ ivln10lo = -3.1689971365e-05, /* 0xb804ead9 */
+ log10_2hi = 3.0102920532e-01, /* 0x3e9a2080 */
+ log10_2lo = 7.9034151668e-07, /* 0x355427db */
+ /* |(log(1+s)-log(1-s))/s - Lg(s)| < 2**-34.24 (~[-4.95e-11, 4.97e-11]). */
+ Lg1 = 0xaaaaaa.0p-24, /* 0.66666662693 */
+ Lg2 = 0xccce13.0p-25, /* 0.40000972152 */
+ Lg3 = 0x91e9ee.0p-25, /* 0.28498786688 */
+ Lg4 = 0xf89e26.0p-26; /* 0.24279078841 */
-float log10f(float x)
-{
- union {float f; uint32_t i;} u = {x};
- float_t hfsq,f,s,z,R,w,t1,t2,dk,hi,lo;
- uint32_t ix;
- int k;
+float log10f(float x) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {x};
+ float_t hfsq, f, s, z, R, w, t1, t2, dk, hi, lo;
+ uint32_t ix;
+ int k;
- ix = u.i;
- k = 0;
- if (ix < 0x00800000 || ix>>31) { /* x < 2**-126 */
- if (ix<<1 == 0)
- return -1/(x*x); /* log(+-0)=-inf */
- if (ix>>31)
- return (x-x)/0.0f; /* log(-#) = NaN */
- /* subnormal number, scale up x */
- k -= 25;
- x *= 0x1p25f;
- u.f = x;
- ix = u.i;
- } else if (ix >= 0x7f800000) {
- return x;
- } else if (ix == 0x3f800000)
- return 0;
+ ix = u.i;
+ k = 0;
+ if (ix < 0x00800000 || ix >> 31) { /* x < 2**-126 */
+ if (ix << 1 == 0)
+ return -1 / (x * x); /* log(+-0)=-inf */
+ if (ix >> 31)
+ return (x - x) / 0.0f; /* log(-#) = NaN */
+ /* subnormal number, scale up x */
+ k -= 25;
+ x *= 0x1p25f;
+ u.f = x;
+ ix = u.i;
+ } else if (ix >= 0x7f800000) {
+ return x;
+ } else if (ix == 0x3f800000)
+ return 0;
- /* reduce x into [sqrt(2)/2, sqrt(2)] */
- ix += 0x3f800000 - 0x3f3504f3;
- k += (int)(ix>>23) - 0x7f;
- ix = (ix&0x007fffff) + 0x3f3504f3;
- u.i = ix;
- x = u.f;
+ /* reduce x into [sqrt(2)/2, sqrt(2)] */
+ ix += 0x3f800000 - 0x3f3504f3;
+ k += (int)(ix >> 23) - 0x7f;
+ ix = (ix & 0x007fffff) + 0x3f3504f3;
+ u.i = ix;
+ x = u.f;
- f = x - 1.0f;
- s = f/(2.0f + f);
- z = s*s;
- w = z*z;
- t1= w*(Lg2+w*Lg4);
- t2= z*(Lg1+w*Lg3);
- R = t2 + t1;
- hfsq = 0.5f*f*f;
+ f = x - 1.0f;
+ s = f / (2.0f + f);
+ z = s * s;
+ w = z * z;
+ t1 = w * (Lg2 + w * Lg4);
+ t2 = z * (Lg1 + w * Lg3);
+ R = t2 + t1;
+ hfsq = 0.5f * f * f;
- hi = f - hfsq;
- u.f = hi;
- u.i &= 0xfffff000;
- hi = u.f;
- lo = f - hi - hfsq + s*(hfsq+R);
- dk = k;
- return dk*log10_2lo + (lo+hi)*ivln10lo + lo*ivln10hi + hi*ivln10hi + dk*log10_2hi;
+ hi = f - hfsq;
+ u.f = hi;
+ u.i &= 0xfffff000;
+ hi = u.f;
+ lo = f - hi - hfsq + s * (hfsq + R);
+ dk = k;
+ return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi +
+ dk * log10_2hi;
}
diff --git a/fusl/src/math/log10l.c b/fusl/src/math/log10l.c
index 63dcc28..30b4041 100644
--- a/fusl/src/math/log10l.c
+++ b/fusl/src/math/log10l.c
@@ -60,9 +60,8 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double log10l(long double x)
-{
- return log10(x);
+long double log10l(long double x) {
+ return log10(x);
}
#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
/* Coefficients for log(1+x) = x - x**2/2 + x**3 P(x)/Q(x)
@@ -70,23 +69,17 @@
* Theoretical peak relative error = 6.2e-22
*/
static const long double P[] = {
- 4.9962495940332550844739E-1L,
- 1.0767376367209449010438E1L,
- 7.7671073698359539859595E1L,
- 2.5620629828144409632571E2L,
- 4.2401812743503691187826E2L,
- 3.4258224542413922935104E2L,
- 1.0747524399916215149070E2L,
+ 4.9962495940332550844739E-1L, 1.0767376367209449010438E1L,
+ 7.7671073698359539859595E1L, 2.5620629828144409632571E2L,
+ 4.2401812743503691187826E2L, 3.4258224542413922935104E2L,
+ 1.0747524399916215149070E2L,
};
static const long double Q[] = {
-/* 1.0000000000000000000000E0,*/
- 2.3479774160285863271658E1L,
- 1.9444210022760132894510E2L,
- 7.7952888181207260646090E2L,
- 1.6911722418503949084863E3L,
- 2.0307734695595183428202E3L,
- 1.2695660352705325274404E3L,
- 3.2242573199748645407652E2L,
+ /* 1.0000000000000000000000E0,*/
+ 2.3479774160285863271658E1L, 1.9444210022760132894510E2L,
+ 7.7952888181207260646090E2L, 1.6911722418503949084863E3L,
+ 2.0307734695595183428202E3L, 1.2695660352705325274404E3L,
+ 3.2242573199748645407652E2L,
};
/* Coefficients for log(x) = z + z^3 P(z^2)/Q(z^2),
@@ -95,16 +88,13 @@
* Theoretical peak relative error = 6.16e-22
*/
static const long double R[4] = {
- 1.9757429581415468984296E-3L,
--7.1990767473014147232598E-1L,
- 1.0777257190312272158094E1L,
--3.5717684488096787370998E1L,
+ 1.9757429581415468984296E-3L, -7.1990767473014147232598E-1L,
+ 1.0777257190312272158094E1L, -3.5717684488096787370998E1L,
};
static const long double S[4] = {
-/* 1.00000000000000000000E0L,*/
--2.6201045551331104417768E1L,
- 1.9361891836232102174846E2L,
--4.2861221385716144629696E2L,
+ /* 1.00000000000000000000E0L,*/
+ -2.6201045551331104417768E1L, 1.9361891836232102174846E2L,
+ -4.2861221385716144629696E2L,
};
/* log10(2) */
#define L102A 0.3125L
@@ -115,77 +105,75 @@
#define SQRTH 0.70710678118654752440L
-long double log10l(long double x)
-{
- long double y, z;
- int e;
+long double log10l(long double x) {
+ long double y, z;
+ int e;
- if (isnan(x))
- return x;
- if(x <= 0.0) {
- if(x == 0.0)
- return -1.0 / (x*x);
- return (x - x) / 0.0;
- }
- if (x == INFINITY)
- return INFINITY;
- /* separate mantissa from exponent */
- /* Note, frexp is used so that denormal numbers
- * will be handled properly.
- */
- x = frexpl(x, &e);
+ if (isnan(x))
+ return x;
+ if (x <= 0.0) {
+ if (x == 0.0)
+ return -1.0 / (x * x);
+ return (x - x) / 0.0;
+ }
+ if (x == INFINITY)
+ return INFINITY;
+ /* 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.5;
- y = 0.5 * z + 0.5;
- } else { /* 2 (x-1)/(x+1) */
- z = x - 0.5;
- z -= 0.5;
- y = 0.5 * x + 0.5;
- }
- x = z / y;
- z = x*x;
- y = x * (z * __polevll(z, R, 3) / __p1evll(z, S, 3));
- goto done;
- }
+ /* 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.5;
+ y = 0.5 * z + 0.5;
+ } else { /* 2 (x-1)/(x+1) */
+ z = x - 0.5;
+ z -= 0.5;
+ y = 0.5 * x + 0.5;
+ }
+ x = z / y;
+ z = x * x;
+ y = x * (z * __polevll(z, R, 3) / __p1evll(z, S, 3));
+ 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.0;
- } else {
- x = x - 1.0;
- }
- z = x*x;
- y = x * (z * __polevll(x, P, 6) / __p1evll(x, Q, 7));
- y = y - 0.5*z;
+ /* logarithm using log(1+x) = x - .5x**2 + x**3 P(x)/Q(x) */
+ if (x < SQRTH) {
+ e -= 1;
+ x = 2.0 * x - 1.0;
+ } else {
+ x = x - 1.0;
+ }
+ z = x * x;
+ y = x * (z * __polevll(x, P, 6) / __p1evll(x, Q, 7));
+ y = y - 0.5 * z;
done:
- /* Multiply log of fraction by log10(e)
- * and base 2 exponent by log10(2).
- *
- * ***CAUTION***
- *
- * This sequence of operations is critical and it may
- * be horribly defeated by some compiler optimizers.
- */
- z = y * (L10EB);
- z += x * (L10EB);
- z += e * (L102B);
- z += y * (L10EA);
- z += x * (L10EA);
- z += e * (L102A);
- return z;
+ /* Multiply log of fraction by log10(e)
+ * and base 2 exponent by log10(2).
+ *
+ * ***CAUTION***
+ *
+ * This sequence of operations is critical and it may
+ * be horribly defeated by some compiler optimizers.
+ */
+ z = y * (L10EB);
+ z += x * (L10EB);
+ z += e * (L102B);
+ z += y * (L10EA);
+ z += x * (L10EA);
+ z += e * (L102A);
+ return z;
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
// TODO: broken implementation to make things compile
-long double log10l(long double x)
-{
- return log10(x);
+long double log10l(long double x) {
+ return log10(x);
}
#endif
diff --git a/fusl/src/math/log1p.c b/fusl/src/math/log1p.c
index 0097134..0fac0ca 100644
--- a/fusl/src/math/log1p.c
+++ b/fusl/src/math/log1p.c
@@ -55,68 +55,69 @@
#include "libm.h"
-static const double
-ln2_hi = 6.93147180369123816490e-01, /* 3fe62e42 fee00000 */
-ln2_lo = 1.90821492927058770002e-10, /* 3dea39ef 35793c76 */
-Lg1 = 6.666666666666735130e-01, /* 3FE55555 55555593 */
-Lg2 = 3.999999999940941908e-01, /* 3FD99999 9997FA04 */
-Lg3 = 2.857142874366239149e-01, /* 3FD24924 94229359 */
-Lg4 = 2.222219843214978396e-01, /* 3FCC71C5 1D8E78AF */
-Lg5 = 1.818357216161805012e-01, /* 3FC74664 96CB03DE */
-Lg6 = 1.531383769920937332e-01, /* 3FC39A09 D078C69F */
-Lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
+static const double ln2_hi = 6.93147180369123816490e-01, /* 3fe62e42 fee00000 */
+ ln2_lo = 1.90821492927058770002e-10, /* 3dea39ef 35793c76 */
+ Lg1 = 6.666666666666735130e-01, /* 3FE55555 55555593 */
+ Lg2 = 3.999999999940941908e-01, /* 3FD99999 9997FA04 */
+ Lg3 = 2.857142874366239149e-01, /* 3FD24924 94229359 */
+ Lg4 = 2.222219843214978396e-01, /* 3FCC71C5 1D8E78AF */
+ Lg5 = 1.818357216161805012e-01, /* 3FC74664 96CB03DE */
+ Lg6 = 1.531383769920937332e-01, /* 3FC39A09 D078C69F */
+ Lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
-double log1p(double x)
-{
- union {double f; uint64_t i;} u = {x};
- double_t hfsq,f,c,s,z,R,w,t1,t2,dk;
- uint32_t hx,hu;
- int k;
+double log1p(double x) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {x};
+ double_t hfsq, f, c, s, z, R, w, t1, t2, dk;
+ uint32_t hx, hu;
+ int k;
- hx = u.i>>32;
- k = 1;
- if (hx < 0x3fda827a || hx>>31) { /* 1+x < sqrt(2)+ */
- if (hx >= 0xbff00000) { /* x <= -1.0 */
- if (x == -1)
- return x/0.0; /* log1p(-1) = -inf */
- return (x-x)/0.0; /* log1p(x<-1) = NaN */
- }
- if (hx<<1 < 0x3ca00000<<1) { /* |x| < 2**-53 */
- /* underflow if subnormal */
- if ((hx&0x7ff00000) == 0)
- FORCE_EVAL((float)x);
- return x;
- }
- if (hx <= 0xbfd2bec4) { /* sqrt(2)/2- <= 1+x < sqrt(2)+ */
- k = 0;
- c = 0;
- f = x;
- }
- } else if (hx >= 0x7ff00000)
- return x;
- if (k) {
- u.f = 1 + x;
- hu = u.i>>32;
- hu += 0x3ff00000 - 0x3fe6a09e;
- k = (int)(hu>>20) - 0x3ff;
- /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */
- if (k < 54) {
- c = k >= 2 ? 1-(u.f-x) : x-(u.f-1);
- c /= u.f;
- } else
- c = 0;
- /* reduce u into [sqrt(2)/2, sqrt(2)] */
- hu = (hu&0x000fffff) + 0x3fe6a09e;
- u.i = (uint64_t)hu<<32 | (u.i&0xffffffff);
- f = u.f - 1;
- }
- hfsq = 0.5*f*f;
- s = f/(2.0+f);
- z = s*s;
- w = z*z;
- t1 = w*(Lg2+w*(Lg4+w*Lg6));
- t2 = z*(Lg1+w*(Lg3+w*(Lg5+w*Lg7)));
- R = t2 + t1;
- dk = k;
- return s*(hfsq+R) + (dk*ln2_lo+c) - hfsq + f + dk*ln2_hi;
+ hx = u.i >> 32;
+ k = 1;
+ if (hx < 0x3fda827a || hx >> 31) { /* 1+x < sqrt(2)+ */
+ if (hx >= 0xbff00000) { /* x <= -1.0 */
+ if (x == -1)
+ return x / 0.0; /* log1p(-1) = -inf */
+ return (x - x) / 0.0; /* log1p(x<-1) = NaN */
+ }
+ if (hx << 1 < 0x3ca00000 << 1) { /* |x| < 2**-53 */
+ /* underflow if subnormal */
+ if ((hx & 0x7ff00000) == 0)
+ FORCE_EVAL((float)x);
+ return x;
+ }
+ if (hx <= 0xbfd2bec4) { /* sqrt(2)/2- <= 1+x < sqrt(2)+ */
+ k = 0;
+ c = 0;
+ f = x;
+ }
+ } else if (hx >= 0x7ff00000)
+ return x;
+ if (k) {
+ u.f = 1 + x;
+ hu = u.i >> 32;
+ hu += 0x3ff00000 - 0x3fe6a09e;
+ k = (int)(hu >> 20) - 0x3ff;
+ /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */
+ if (k < 54) {
+ c = k >= 2 ? 1 - (u.f - x) : x - (u.f - 1);
+ c /= u.f;
+ } else
+ c = 0;
+ /* reduce u into [sqrt(2)/2, sqrt(2)] */
+ hu = (hu & 0x000fffff) + 0x3fe6a09e;
+ u.i = (uint64_t)hu << 32 | (u.i & 0xffffffff);
+ f = u.f - 1;
+ }
+ hfsq = 0.5 * f * f;
+ s = f / (2.0 + f);
+ z = s * s;
+ w = z * z;
+ t1 = w * (Lg2 + w * (Lg4 + w * Lg6));
+ t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));
+ R = t2 + t1;
+ dk = k;
+ return s * (hfsq + R) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;
}
diff --git a/fusl/src/math/log1pf.c b/fusl/src/math/log1pf.c
index 23985c3..e50ad82 100644
--- a/fusl/src/math/log1pf.c
+++ b/fusl/src/math/log1pf.c
@@ -12,66 +12,67 @@
#include "libm.h"
-static const float
-ln2_hi = 6.9313812256e-01, /* 0x3f317180 */
-ln2_lo = 9.0580006145e-06, /* 0x3717f7d1 */
-/* |(log(1+s)-log(1-s))/s - Lg(s)| < 2**-34.24 (~[-4.95e-11, 4.97e-11]). */
-Lg1 = 0xaaaaaa.0p-24, /* 0.66666662693 */
-Lg2 = 0xccce13.0p-25, /* 0.40000972152 */
-Lg3 = 0x91e9ee.0p-25, /* 0.28498786688 */
-Lg4 = 0xf89e26.0p-26; /* 0.24279078841 */
+static const float ln2_hi = 6.9313812256e-01, /* 0x3f317180 */
+ ln2_lo = 9.0580006145e-06, /* 0x3717f7d1 */
+ /* |(log(1+s)-log(1-s))/s - Lg(s)| < 2**-34.24 (~[-4.95e-11, 4.97e-11]). */
+ Lg1 = 0xaaaaaa.0p-24, /* 0.66666662693 */
+ Lg2 = 0xccce13.0p-25, /* 0.40000972152 */
+ Lg3 = 0x91e9ee.0p-25, /* 0.28498786688 */
+ Lg4 = 0xf89e26.0p-26; /* 0.24279078841 */
-float log1pf(float x)
-{
- union {float f; uint32_t i;} u = {x};
- float_t hfsq,f,c,s,z,R,w,t1,t2,dk;
- uint32_t ix,iu;
- int k;
+float log1pf(float x) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {x};
+ float_t hfsq, f, c, s, z, R, w, t1, t2, dk;
+ uint32_t ix, iu;
+ int k;
- ix = u.i;
- k = 1;
- if (ix < 0x3ed413d0 || ix>>31) { /* 1+x < sqrt(2)+ */
- if (ix >= 0xbf800000) { /* x <= -1.0 */
- if (x == -1)
- return x/0.0f; /* log1p(-1)=+inf */
- return (x-x)/0.0f; /* log1p(x<-1)=NaN */
- }
- if (ix<<1 < 0x33800000<<1) { /* |x| < 2**-24 */
- /* underflow if subnormal */
- if ((ix&0x7f800000) == 0)
- FORCE_EVAL(x*x);
- return x;
- }
- if (ix <= 0xbe95f619) { /* sqrt(2)/2- <= 1+x < sqrt(2)+ */
- k = 0;
- c = 0;
- f = x;
- }
- } else if (ix >= 0x7f800000)
- return x;
- if (k) {
- u.f = 1 + x;
- iu = u.i;
- iu += 0x3f800000 - 0x3f3504f3;
- k = (int)(iu>>23) - 0x7f;
- /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */
- if (k < 25) {
- c = k >= 2 ? 1-(u.f-x) : x-(u.f-1);
- c /= u.f;
- } else
- c = 0;
- /* reduce u into [sqrt(2)/2, sqrt(2)] */
- iu = (iu&0x007fffff) + 0x3f3504f3;
- u.i = iu;
- f = u.f - 1;
- }
- s = f/(2.0f + f);
- z = s*s;
- w = z*z;
- t1= w*(Lg2+w*Lg4);
- t2= z*(Lg1+w*Lg3);
- R = t2 + t1;
- hfsq = 0.5f*f*f;
- dk = k;
- return s*(hfsq+R) + (dk*ln2_lo+c) - hfsq + f + dk*ln2_hi;
+ ix = u.i;
+ k = 1;
+ if (ix < 0x3ed413d0 || ix >> 31) { /* 1+x < sqrt(2)+ */
+ if (ix >= 0xbf800000) { /* x <= -1.0 */
+ if (x == -1)
+ return x / 0.0f; /* log1p(-1)=+inf */
+ return (x - x) / 0.0f; /* log1p(x<-1)=NaN */
+ }
+ if (ix << 1 < 0x33800000 << 1) { /* |x| < 2**-24 */
+ /* underflow if subnormal */
+ if ((ix & 0x7f800000) == 0)
+ FORCE_EVAL(x * x);
+ return x;
+ }
+ if (ix <= 0xbe95f619) { /* sqrt(2)/2- <= 1+x < sqrt(2)+ */
+ k = 0;
+ c = 0;
+ f = x;
+ }
+ } else if (ix >= 0x7f800000)
+ return x;
+ if (k) {
+ u.f = 1 + x;
+ iu = u.i;
+ iu += 0x3f800000 - 0x3f3504f3;
+ k = (int)(iu >> 23) - 0x7f;
+ /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */
+ if (k < 25) {
+ c = k >= 2 ? 1 - (u.f - x) : x - (u.f - 1);
+ c /= u.f;
+ } else
+ c = 0;
+ /* reduce u into [sqrt(2)/2, sqrt(2)] */
+ iu = (iu & 0x007fffff) + 0x3f3504f3;
+ u.i = iu;
+ f = u.f - 1;
+ }
+ s = f / (2.0f + f);
+ z = s * s;
+ w = z * z;
+ t1 = w * (Lg2 + w * Lg4);
+ t2 = z * (Lg1 + w * Lg3);
+ R = t2 + t1;
+ hfsq = 0.5f * f * f;
+ dk = k;
+ return s * (hfsq + R) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;
}
diff --git a/fusl/src/math/log1pl.c b/fusl/src/math/log1pl.c
index 141b5f0..2e070cb 100644
--- a/fusl/src/math/log1pl.c
+++ b/fusl/src/math/log1pl.c
@@ -51,9 +51,8 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double log1pl(long double x)
-{
- return log1p(x);
+long double log1pl(long double x) {
+ return log1p(x);
}
#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
/* Coefficients for log(1+x) = x - x^2 / 2 + x^3 P(x)/Q(x)
@@ -61,22 +60,16 @@
* Theoretical peak relative error = 2.32e-20
*/
static const long double P[] = {
- 4.5270000862445199635215E-5L,
- 4.9854102823193375972212E-1L,
- 6.5787325942061044846969E0L,
- 2.9911919328553073277375E1L,
- 6.0949667980987787057556E1L,
- 5.7112963590585538103336E1L,
- 2.0039553499201281259648E1L,
+ 4.5270000862445199635215E-5L, 4.9854102823193375972212E-1L,
+ 6.5787325942061044846969E0L, 2.9911919328553073277375E1L,
+ 6.0949667980987787057556E1L, 5.7112963590585538103336E1L,
+ 2.0039553499201281259648E1L,
};
static const long double Q[] = {
-/* 1.0000000000000000000000E0,*/
- 1.5062909083469192043167E1L,
- 8.3047565967967209469434E1L,
- 2.2176239823732856465394E2L,
- 3.0909872225312059774938E2L,
- 2.1642788614495947685003E2L,
- 6.0118660497603843919306E1L,
+ /* 1.0000000000000000000000E0,*/
+ 1.5062909083469192043167E1L, 8.3047565967967209469434E1L,
+ 2.2176239823732856465394E2L, 3.0909872225312059774938E2L,
+ 2.1642788614495947685003E2L, 6.0118660497603843919306E1L,
};
/* Coefficients for log(x) = z + z^3 P(z^2)/Q(z^2),
@@ -85,93 +78,88 @@
* Theoretical peak relative error = 6.16e-22
*/
static const long double R[4] = {
- 1.9757429581415468984296E-3L,
--7.1990767473014147232598E-1L,
- 1.0777257190312272158094E1L,
--3.5717684488096787370998E1L,
+ 1.9757429581415468984296E-3L, -7.1990767473014147232598E-1L,
+ 1.0777257190312272158094E1L, -3.5717684488096787370998E1L,
};
static const long double S[4] = {
-/* 1.00000000000000000000E0L,*/
--2.6201045551331104417768E1L,
- 1.9361891836232102174846E2L,
--4.2861221385716144629696E2L,
+ /* 1.00000000000000000000E0L,*/
+ -2.6201045551331104417768E1L, 1.9361891836232102174846E2L,
+ -4.2861221385716144629696E2L,
};
static const long double C1 = 6.9314575195312500000000E-1L;
static const long double C2 = 1.4286068203094172321215E-6L;
#define SQRTH 0.70710678118654752440L
-long double log1pl(long double xm1)
-{
- long double x, y, z;
- int e;
+long double log1pl(long double xm1) {
+ long double x, y, z;
+ int e;
- if (isnan(xm1))
- return xm1;
- if (xm1 == INFINITY)
- return xm1;
- if (xm1 == 0.0)
- return xm1;
+ if (isnan(xm1))
+ return xm1;
+ if (xm1 == INFINITY)
+ return xm1;
+ if (xm1 == 0.0)
+ return xm1;
- x = xm1 + 1.0;
+ x = xm1 + 1.0;
- /* Test for domain errors. */
- if (x <= 0.0) {
- if (x == 0.0)
- return -1/(x*x); /* -inf with divbyzero */
- return 0/0.0f; /* nan with invalid */
- }
+ /* Test for domain errors. */
+ if (x <= 0.0) {
+ if (x == 0.0)
+ return -1 / (x * x); /* -inf with divbyzero */
+ return 0 / 0.0f; /* nan with invalid */
+ }
- /* Separate mantissa from exponent.
- Use frexp so that denormal numbers will be handled properly. */
- x = frexpl(x, &e);
+ /* Separate mantissa from exponent.
+ Use frexp 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.5;
- y = 0.5 * z + 0.5;
- } else { /* 2 (x-1)/(x+1) */
- z = x - 0.5;
- z -= 0.5;
- y = 0.5 * x + 0.5;
- }
- x = z / y;
- z = x*x;
- z = x * (z * __polevll(z, R, 3) / __p1evll(z, S, 3));
- z = z + e * C2;
- z = z + x;
- z = z + e * C1;
- return z;
- }
+ /* 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.5;
+ y = 0.5 * z + 0.5;
+ } else { /* 2 (x-1)/(x+1) */
+ z = x - 0.5;
+ z -= 0.5;
+ y = 0.5 * x + 0.5;
+ }
+ x = z / y;
+ z = x * x;
+ z = x * (z * __polevll(z, R, 3) / __p1evll(z, S, 3));
+ 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.0 * x - 1.0;
- else
- x = xm1;
- } else {
- if (e != 0)
- x = x - 1.0;
- else
- x = xm1;
- }
- z = x*x;
- y = x * (z * __polevll(x, P, 6) / __p1evll(x, Q, 6));
- y = y + e * C2;
- z = y - 0.5 * z;
- 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.0 * x - 1.0;
+ else
+ x = xm1;
+ } else {
+ if (e != 0)
+ x = x - 1.0;
+ else
+ x = xm1;
+ }
+ z = x * x;
+ y = x * (z * __polevll(x, P, 6) / __p1evll(x, Q, 6));
+ y = y + e * C2;
+ z = y - 0.5 * z;
+ z = z + x;
+ z = z + e * C1;
+ return z;
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
// TODO: broken implementation to make things compile
-long double log1pl(long double x)
-{
- return log1p(x);
+long double log1pl(long double x) {
+ return log1p(x);
}
#endif
diff --git a/fusl/src/math/log2.c b/fusl/src/math/log2.c
index 0aafad4..1ee2ea0 100644
--- a/fusl/src/math/log2.c
+++ b/fusl/src/math/log2.c
@@ -20,103 +20,105 @@
#include <math.h>
#include <stdint.h>
-static const double
-ivln2hi = 1.44269504072144627571e+00, /* 0x3ff71547, 0x65200000 */
-ivln2lo = 1.67517131648865118353e-10, /* 0x3de705fc, 0x2eefa200 */
-Lg1 = 6.666666666666735130e-01, /* 3FE55555 55555593 */
-Lg2 = 3.999999999940941908e-01, /* 3FD99999 9997FA04 */
-Lg3 = 2.857142874366239149e-01, /* 3FD24924 94229359 */
-Lg4 = 2.222219843214978396e-01, /* 3FCC71C5 1D8E78AF */
-Lg5 = 1.818357216161805012e-01, /* 3FC74664 96CB03DE */
-Lg6 = 1.531383769920937332e-01, /* 3FC39A09 D078C69F */
-Lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
+static const double ivln2hi =
+ 1.44269504072144627571e+00, /* 0x3ff71547, 0x65200000 */
+ ivln2lo = 1.67517131648865118353e-10, /* 0x3de705fc, 0x2eefa200 */
+ Lg1 = 6.666666666666735130e-01, /* 3FE55555 55555593 */
+ Lg2 = 3.999999999940941908e-01, /* 3FD99999 9997FA04 */
+ Lg3 = 2.857142874366239149e-01, /* 3FD24924 94229359 */
+ Lg4 = 2.222219843214978396e-01, /* 3FCC71C5 1D8E78AF */
+ Lg5 = 1.818357216161805012e-01, /* 3FC74664 96CB03DE */
+ Lg6 = 1.531383769920937332e-01, /* 3FC39A09 D078C69F */
+ Lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
-double log2(double x)
-{
- union {double f; uint64_t i;} u = {x};
- double_t hfsq,f,s,z,R,w,t1,t2,y,hi,lo,val_hi,val_lo;
- uint32_t hx;
- int k;
+double log2(double x) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {x};
+ double_t hfsq, f, s, z, R, w, t1, t2, y, hi, lo, val_hi, val_lo;
+ uint32_t hx;
+ int k;
- hx = u.i>>32;
- k = 0;
- if (hx < 0x00100000 || hx>>31) {
- if (u.i<<1 == 0)
- return -1/(x*x); /* log(+-0)=-inf */
- if (hx>>31)
- return (x-x)/0.0; /* log(-#) = NaN */
- /* subnormal number, scale x up */
- k -= 54;
- x *= 0x1p54;
- u.f = x;
- hx = u.i>>32;
- } else if (hx >= 0x7ff00000) {
- return x;
- } else if (hx == 0x3ff00000 && u.i<<32 == 0)
- return 0;
+ hx = u.i >> 32;
+ k = 0;
+ if (hx < 0x00100000 || hx >> 31) {
+ if (u.i << 1 == 0)
+ return -1 / (x * x); /* log(+-0)=-inf */
+ if (hx >> 31)
+ return (x - x) / 0.0; /* log(-#) = NaN */
+ /* subnormal number, scale x up */
+ k -= 54;
+ x *= 0x1p54;
+ u.f = x;
+ hx = u.i >> 32;
+ } else if (hx >= 0x7ff00000) {
+ return x;
+ } else if (hx == 0x3ff00000 && u.i << 32 == 0)
+ return 0;
- /* reduce x into [sqrt(2)/2, sqrt(2)] */
- hx += 0x3ff00000 - 0x3fe6a09e;
- k += (int)(hx>>20) - 0x3ff;
- hx = (hx&0x000fffff) + 0x3fe6a09e;
- u.i = (uint64_t)hx<<32 | (u.i&0xffffffff);
- x = u.f;
+ /* reduce x into [sqrt(2)/2, sqrt(2)] */
+ hx += 0x3ff00000 - 0x3fe6a09e;
+ k += (int)(hx >> 20) - 0x3ff;
+ hx = (hx & 0x000fffff) + 0x3fe6a09e;
+ u.i = (uint64_t)hx << 32 | (u.i & 0xffffffff);
+ x = u.f;
- f = x - 1.0;
- hfsq = 0.5*f*f;
- s = f/(2.0+f);
- z = s*s;
- w = z*z;
- t1 = w*(Lg2+w*(Lg4+w*Lg6));
- t2 = z*(Lg1+w*(Lg3+w*(Lg5+w*Lg7)));
- R = t2 + t1;
+ f = x - 1.0;
+ hfsq = 0.5 * f * f;
+ s = f / (2.0 + f);
+ z = s * s;
+ w = z * z;
+ t1 = w * (Lg2 + w * (Lg4 + w * Lg6));
+ t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));
+ R = t2 + t1;
- /*
- * f-hfsq must (for args near 1) be evaluated in extra precision
- * to avoid a large cancellation when x is near sqrt(2) or 1/sqrt(2).
- * This is fairly efficient since f-hfsq only depends on f, so can
- * be evaluated in parallel with R. Not combining hfsq with R also
- * keeps R small (though not as small as a true `lo' term would be),
- * so that extra precision is not needed for terms involving R.
- *
- * Compiler bugs involving extra precision used to break Dekker's
- * theorem for spitting f-hfsq as hi+lo, unless double_t was used
- * or the multi-precision calculations were avoided when double_t
- * has extra precision. These problems are now automatically
- * avoided as a side effect of the optimization of combining the
- * Dekker splitting step with the clear-low-bits step.
- *
- * y must (for args near sqrt(2) and 1/sqrt(2)) be added in extra
- * precision to avoid a very large cancellation when x is very near
- * these values. Unlike the above cancellations, this problem is
- * specific to base 2. It is strange that adding +-1 is so much
- * harder than adding +-ln2 or +-log10_2.
- *
- * This uses Dekker's theorem to normalize y+val_hi, so the
- * compiler bugs are back in some configurations, sigh. And I
- * don't want to used double_t to avoid them, since that gives a
- * pessimization and the support for avoiding the pessimization
- * is not yet available.
- *
- * The multi-precision calculations for the multiplications are
- * routine.
- */
+ /*
+ * f-hfsq must (for args near 1) be evaluated in extra precision
+ * to avoid a large cancellation when x is near sqrt(2) or 1/sqrt(2).
+ * This is fairly efficient since f-hfsq only depends on f, so can
+ * be evaluated in parallel with R. Not combining hfsq with R also
+ * keeps R small (though not as small as a true `lo' term would be),
+ * so that extra precision is not needed for terms involving R.
+ *
+ * Compiler bugs involving extra precision used to break Dekker's
+ * theorem for spitting f-hfsq as hi+lo, unless double_t was used
+ * or the multi-precision calculations were avoided when double_t
+ * has extra precision. These problems are now automatically
+ * avoided as a side effect of the optimization of combining the
+ * Dekker splitting step with the clear-low-bits step.
+ *
+ * y must (for args near sqrt(2) and 1/sqrt(2)) be added in extra
+ * precision to avoid a very large cancellation when x is very near
+ * these values. Unlike the above cancellations, this problem is
+ * specific to base 2. It is strange that adding +-1 is so much
+ * harder than adding +-ln2 or +-log10_2.
+ *
+ * This uses Dekker's theorem to normalize y+val_hi, so the
+ * compiler bugs are back in some configurations, sigh. And I
+ * don't want to used double_t to avoid them, since that gives a
+ * pessimization and the support for avoiding the pessimization
+ * is not yet available.
+ *
+ * The multi-precision calculations for the multiplications are
+ * routine.
+ */
- /* hi+lo = f - hfsq + s*(hfsq+R) ~ log(1+f) */
- hi = f - hfsq;
- u.f = hi;
- u.i &= (uint64_t)-1<<32;
- hi = u.f;
- lo = f - hi - hfsq + s*(hfsq+R);
+ /* hi+lo = f - hfsq + s*(hfsq+R) ~ log(1+f) */
+ hi = f - hfsq;
+ u.f = hi;
+ u.i &= (uint64_t)-1 << 32;
+ hi = u.f;
+ lo = f - hi - hfsq + s * (hfsq + R);
- val_hi = hi*ivln2hi;
- val_lo = (lo+hi)*ivln2lo + lo*ivln2hi;
+ val_hi = hi * ivln2hi;
+ val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;
- /* spadd(val_hi, val_lo, y), except for not using double_t: */
- y = k;
- w = y + val_hi;
- val_lo += (y - w) + val_hi;
- val_hi = w;
+ /* spadd(val_hi, val_lo, y), except for not using double_t: */
+ y = k;
+ w = y + val_hi;
+ val_lo += (y - w) + val_hi;
+ val_hi = w;
- return val_lo + val_hi;
+ return val_lo + val_hi;
}
diff --git a/fusl/src/math/log2f.c b/fusl/src/math/log2f.c
index b3e305f..1e7e75a 100644
--- a/fusl/src/math/log2f.c
+++ b/fusl/src/math/log2f.c
@@ -16,59 +16,60 @@
#include <math.h>
#include <stdint.h>
-static const float
-ivln2hi = 1.4428710938e+00, /* 0x3fb8b000 */
-ivln2lo = -1.7605285393e-04, /* 0xb9389ad4 */
-/* |(log(1+s)-log(1-s))/s - Lg(s)| < 2**-34.24 (~[-4.95e-11, 4.97e-11]). */
-Lg1 = 0xaaaaaa.0p-24, /* 0.66666662693 */
-Lg2 = 0xccce13.0p-25, /* 0.40000972152 */
-Lg3 = 0x91e9ee.0p-25, /* 0.28498786688 */
-Lg4 = 0xf89e26.0p-26; /* 0.24279078841 */
+static const float ivln2hi = 1.4428710938e+00, /* 0x3fb8b000 */
+ ivln2lo = -1.7605285393e-04, /* 0xb9389ad4 */
+ /* |(log(1+s)-log(1-s))/s - Lg(s)| < 2**-34.24 (~[-4.95e-11, 4.97e-11]). */
+ Lg1 = 0xaaaaaa.0p-24, /* 0.66666662693 */
+ Lg2 = 0xccce13.0p-25, /* 0.40000972152 */
+ Lg3 = 0x91e9ee.0p-25, /* 0.28498786688 */
+ Lg4 = 0xf89e26.0p-26; /* 0.24279078841 */
-float log2f(float x)
-{
- union {float f; uint32_t i;} u = {x};
- float_t hfsq,f,s,z,R,w,t1,t2,hi,lo;
- uint32_t ix;
- int k;
+float log2f(float x) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {x};
+ float_t hfsq, f, s, z, R, w, t1, t2, hi, lo;
+ uint32_t ix;
+ int k;
- ix = u.i;
- k = 0;
- if (ix < 0x00800000 || ix>>31) { /* x < 2**-126 */
- if (ix<<1 == 0)
- return -1/(x*x); /* log(+-0)=-inf */
- if (ix>>31)
- return (x-x)/0.0f; /* log(-#) = NaN */
- /* subnormal number, scale up x */
- k -= 25;
- x *= 0x1p25f;
- u.f = x;
- ix = u.i;
- } else if (ix >= 0x7f800000) {
- return x;
- } else if (ix == 0x3f800000)
- return 0;
+ ix = u.i;
+ k = 0;
+ if (ix < 0x00800000 || ix >> 31) { /* x < 2**-126 */
+ if (ix << 1 == 0)
+ return -1 / (x * x); /* log(+-0)=-inf */
+ if (ix >> 31)
+ return (x - x) / 0.0f; /* log(-#) = NaN */
+ /* subnormal number, scale up x */
+ k -= 25;
+ x *= 0x1p25f;
+ u.f = x;
+ ix = u.i;
+ } else if (ix >= 0x7f800000) {
+ return x;
+ } else if (ix == 0x3f800000)
+ return 0;
- /* reduce x into [sqrt(2)/2, sqrt(2)] */
- ix += 0x3f800000 - 0x3f3504f3;
- k += (int)(ix>>23) - 0x7f;
- ix = (ix&0x007fffff) + 0x3f3504f3;
- u.i = ix;
- x = u.f;
+ /* reduce x into [sqrt(2)/2, sqrt(2)] */
+ ix += 0x3f800000 - 0x3f3504f3;
+ k += (int)(ix >> 23) - 0x7f;
+ ix = (ix & 0x007fffff) + 0x3f3504f3;
+ u.i = ix;
+ x = u.f;
- f = x - 1.0f;
- s = f/(2.0f + f);
- z = s*s;
- w = z*z;
- t1= w*(Lg2+w*Lg4);
- t2= z*(Lg1+w*Lg3);
- R = t2 + t1;
- hfsq = 0.5f*f*f;
+ f = x - 1.0f;
+ s = f / (2.0f + f);
+ z = s * s;
+ w = z * z;
+ t1 = w * (Lg2 + w * Lg4);
+ t2 = z * (Lg1 + w * Lg3);
+ R = t2 + t1;
+ hfsq = 0.5f * f * f;
- hi = f - hfsq;
- u.f = hi;
- u.i &= 0xfffff000;
- hi = u.f;
- lo = f - hi - hfsq + s*(hfsq+R);
- return (lo+hi)*ivln2lo + lo*ivln2hi + hi*ivln2hi + k;
+ hi = f - hfsq;
+ u.f = hi;
+ u.i &= 0xfffff000;
+ hi = u.f;
+ lo = f - hi - hfsq + s * (hfsq + R);
+ return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + k;
}
diff --git a/fusl/src/math/log2l.c b/fusl/src/math/log2l.c
index 722b451..5041251 100644
--- a/fusl/src/math/log2l.c
+++ b/fusl/src/math/log2l.c
@@ -55,9 +55,8 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double log2l(long double x)
-{
- return log2(x);
+long double log2l(long double x) {
+ return log2(x);
}
#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
/* Coefficients for ln(1+x) = x - x**2/2 + x**3 P(x)/Q(x)
@@ -65,23 +64,17 @@
* Theoretical peak relative error = 6.2e-22
*/
static const long double P[] = {
- 4.9962495940332550844739E-1L,
- 1.0767376367209449010438E1L,
- 7.7671073698359539859595E1L,
- 2.5620629828144409632571E2L,
- 4.2401812743503691187826E2L,
- 3.4258224542413922935104E2L,
- 1.0747524399916215149070E2L,
+ 4.9962495940332550844739E-1L, 1.0767376367209449010438E1L,
+ 7.7671073698359539859595E1L, 2.5620629828144409632571E2L,
+ 4.2401812743503691187826E2L, 3.4258224542413922935104E2L,
+ 1.0747524399916215149070E2L,
};
static const long double Q[] = {
-/* 1.0000000000000000000000E0,*/
- 2.3479774160285863271658E1L,
- 1.9444210022760132894510E2L,
- 7.7952888181207260646090E2L,
- 1.6911722418503949084863E3L,
- 2.0307734695595183428202E3L,
- 1.2695660352705325274404E3L,
- 3.2242573199748645407652E2L,
+ /* 1.0000000000000000000000E0,*/
+ 2.3479774160285863271658E1L, 1.9444210022760132894510E2L,
+ 7.7952888181207260646090E2L, 1.6911722418503949084863E3L,
+ 2.0307734695595183428202E3L, 1.2695660352705325274404E3L,
+ 3.2242573199748645407652E2L,
};
/* Coefficients for log(x) = z + z^3 P(z^2)/Q(z^2),
@@ -90,93 +83,88 @@
* Theoretical peak relative error = 6.16e-22
*/
static const long double R[4] = {
- 1.9757429581415468984296E-3L,
--7.1990767473014147232598E-1L,
- 1.0777257190312272158094E1L,
--3.5717684488096787370998E1L,
+ 1.9757429581415468984296E-3L, -7.1990767473014147232598E-1L,
+ 1.0777257190312272158094E1L, -3.5717684488096787370998E1L,
};
static const long double S[4] = {
-/* 1.00000000000000000000E0L,*/
--2.6201045551331104417768E1L,
- 1.9361891836232102174846E2L,
--4.2861221385716144629696E2L,
+ /* 1.00000000000000000000E0L,*/
+ -2.6201045551331104417768E1L, 1.9361891836232102174846E2L,
+ -4.2861221385716144629696E2L,
};
/* log2(e) - 1 */
#define LOG2EA 4.4269504088896340735992e-1L
#define SQRTH 0.70710678118654752440L
-long double log2l(long double x)
-{
- long double y, z;
- int e;
+long double log2l(long double x) {
+ long double y, z;
+ int e;
- if (isnan(x))
- return x;
- if (x == INFINITY)
- return x;
- if (x <= 0.0) {
- if (x == 0.0)
- return -1/(x*x); /* -inf with divbyzero */
- return 0/0.0f; /* nan with invalid */
- }
+ if (isnan(x))
+ return x;
+ if (x == INFINITY)
+ return x;
+ if (x <= 0.0) {
+ if (x == 0.0)
+ return -1 / (x * x); /* -inf with divbyzero */
+ return 0 / 0.0f; /* nan with invalid */
+ }
- /* separate mantissa from exponent */
- /* Note, frexp is used so that denormal numbers
- * will be handled properly.
- */
- x = frexpl(x, &e);
+ /* 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.5;
- y = 0.5 * z + 0.5;
- } else { /* 2 (x-1)/(x+1) */
- z = x - 0.5;
- z -= 0.5;
- y = 0.5 * x + 0.5;
- }
- x = z / y;
- z = x*x;
- y = x * (z * __polevll(z, R, 3) / __p1evll(z, S, 3));
- goto done;
- }
+ /* 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.5;
+ y = 0.5 * z + 0.5;
+ } else { /* 2 (x-1)/(x+1) */
+ z = x - 0.5;
+ z -= 0.5;
+ y = 0.5 * x + 0.5;
+ }
+ x = z / y;
+ z = x * x;
+ y = x * (z * __polevll(z, R, 3) / __p1evll(z, S, 3));
+ 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.0;
- } else {
- x = x - 1.0;
- }
- z = x*x;
- y = x * (z * __polevll(x, P, 6) / __p1evll(x, Q, 7));
- y = y - 0.5*z;
+ /* logarithm using log(1+x) = x - .5x**2 + x**3 P(x)/Q(x) */
+ if (x < SQRTH) {
+ e -= 1;
+ x = 2.0 * x - 1.0;
+ } else {
+ x = x - 1.0;
+ }
+ z = x * x;
+ y = x * (z * __polevll(x, P, 6) / __p1evll(x, Q, 7));
+ y = y - 0.5 * z;
done:
- /* Multiply log of fraction by log2(e)
- * and base 2 exponent by 1
- *
- * ***CAUTION***
- *
- * This sequence of operations is critical and it may
- * be horribly defeated by some compiler optimizers.
- */
- z = y * LOG2EA;
- z += x * LOG2EA;
- z += y;
- z += x;
- z += e;
- return z;
+ /* Multiply log of fraction by log2(e)
+ * and base 2 exponent by 1
+ *
+ * ***CAUTION***
+ *
+ * This sequence of operations is critical and it may
+ * be horribly defeated by some compiler optimizers.
+ */
+ z = y * LOG2EA;
+ z += x * LOG2EA;
+ z += y;
+ z += x;
+ z += e;
+ return z;
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
// TODO: broken implementation to make things compile
-long double log2l(long double x)
-{
- return log2(x);
+long double log2l(long double x) {
+ return log2(x);
}
#endif
diff --git a/fusl/src/math/logb.c b/fusl/src/math/logb.c
index 7f8bdfa..bff5101 100644
--- a/fusl/src/math/logb.c
+++ b/fusl/src/math/logb.c
@@ -2,16 +2,15 @@
/*
special cases:
- logb(+-0) = -inf, and raise divbyzero
- logb(+-inf) = +inf
- logb(nan) = nan
+ logb(+-0) = -inf, and raise divbyzero
+ logb(+-inf) = +inf
+ logb(nan) = nan
*/
-double logb(double x)
-{
- if (!isfinite(x))
- return x * x;
- if (x == 0)
- return -1/(x*x);
- return ilogb(x);
+double logb(double x) {
+ if (!isfinite(x))
+ return x * x;
+ if (x == 0)
+ return -1 / (x * x);
+ return ilogb(x);
}
diff --git a/fusl/src/math/logbf.c b/fusl/src/math/logbf.c
index a0a0b5e..9c42fc7 100644
--- a/fusl/src/math/logbf.c
+++ b/fusl/src/math/logbf.c
@@ -1,10 +1,9 @@
#include <math.h>
-float logbf(float x)
-{
- if (!isfinite(x))
- return x * x;
- if (x == 0)
- return -1/(x*x);
- return ilogbf(x);
+float logbf(float x) {
+ if (!isfinite(x))
+ return x * x;
+ if (x == 0)
+ return -1 / (x * x);
+ return ilogbf(x);
}
diff --git a/fusl/src/math/logbl.c b/fusl/src/math/logbl.c
index 962973a..cfb84c5 100644
--- a/fusl/src/math/logbl.c
+++ b/fusl/src/math/logbl.c
@@ -1,16 +1,14 @@
#include <math.h>
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double logbl(long double x)
-{
- return logb(x);
+long double logbl(long double x) {
+ return logb(x);
}
#else
-long double logbl(long double x)
-{
- if (!isfinite(x))
- return x * x;
- if (x == 0)
- return -1/(x*x);
- return ilogbl(x);
+long double logbl(long double x) {
+ if (!isfinite(x))
+ return x * x;
+ if (x == 0)
+ return -1 / (x * x);
+ return ilogbl(x);
}
#endif
diff --git a/fusl/src/math/logf.c b/fusl/src/math/logf.c
index 52230a1..ae5e6ba 100644
--- a/fusl/src/math/logf.c
+++ b/fusl/src/math/logf.c
@@ -16,54 +16,55 @@
#include <math.h>
#include <stdint.h>
-static const float
-ln2_hi = 6.9313812256e-01, /* 0x3f317180 */
-ln2_lo = 9.0580006145e-06, /* 0x3717f7d1 */
-/* |(log(1+s)-log(1-s))/s - Lg(s)| < 2**-34.24 (~[-4.95e-11, 4.97e-11]). */
-Lg1 = 0xaaaaaa.0p-24, /* 0.66666662693 */
-Lg2 = 0xccce13.0p-25, /* 0.40000972152 */
-Lg3 = 0x91e9ee.0p-25, /* 0.28498786688 */
-Lg4 = 0xf89e26.0p-26; /* 0.24279078841 */
+static const float ln2_hi = 6.9313812256e-01, /* 0x3f317180 */
+ ln2_lo = 9.0580006145e-06, /* 0x3717f7d1 */
+ /* |(log(1+s)-log(1-s))/s - Lg(s)| < 2**-34.24 (~[-4.95e-11, 4.97e-11]). */
+ Lg1 = 0xaaaaaa.0p-24, /* 0.66666662693 */
+ Lg2 = 0xccce13.0p-25, /* 0.40000972152 */
+ Lg3 = 0x91e9ee.0p-25, /* 0.28498786688 */
+ Lg4 = 0xf89e26.0p-26; /* 0.24279078841 */
-float logf(float x)
-{
- union {float f; uint32_t i;} u = {x};
- float_t hfsq,f,s,z,R,w,t1,t2,dk;
- uint32_t ix;
- int k;
+float logf(float x) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {x};
+ float_t hfsq, f, s, z, R, w, t1, t2, dk;
+ uint32_t ix;
+ int k;
- ix = u.i;
- k = 0;
- if (ix < 0x00800000 || ix>>31) { /* x < 2**-126 */
- if (ix<<1 == 0)
- return -1/(x*x); /* log(+-0)=-inf */
- if (ix>>31)
- return (x-x)/0.0f; /* log(-#) = NaN */
- /* subnormal number, scale up x */
- k -= 25;
- x *= 0x1p25f;
- u.f = x;
- ix = u.i;
- } else if (ix >= 0x7f800000) {
- return x;
- } else if (ix == 0x3f800000)
- return 0;
+ ix = u.i;
+ k = 0;
+ if (ix < 0x00800000 || ix >> 31) { /* x < 2**-126 */
+ if (ix << 1 == 0)
+ return -1 / (x * x); /* log(+-0)=-inf */
+ if (ix >> 31)
+ return (x - x) / 0.0f; /* log(-#) = NaN */
+ /* subnormal number, scale up x */
+ k -= 25;
+ x *= 0x1p25f;
+ u.f = x;
+ ix = u.i;
+ } else if (ix >= 0x7f800000) {
+ return x;
+ } else if (ix == 0x3f800000)
+ return 0;
- /* reduce x into [sqrt(2)/2, sqrt(2)] */
- ix += 0x3f800000 - 0x3f3504f3;
- k += (int)(ix>>23) - 0x7f;
- ix = (ix&0x007fffff) + 0x3f3504f3;
- u.i = ix;
- x = u.f;
+ /* reduce x into [sqrt(2)/2, sqrt(2)] */
+ ix += 0x3f800000 - 0x3f3504f3;
+ k += (int)(ix >> 23) - 0x7f;
+ ix = (ix & 0x007fffff) + 0x3f3504f3;
+ u.i = ix;
+ x = u.f;
- f = x - 1.0f;
- s = f/(2.0f + f);
- z = s*s;
- w = z*z;
- t1= w*(Lg2+w*Lg4);
- t2= z*(Lg1+w*Lg3);
- R = t2 + t1;
- hfsq = 0.5f*f*f;
- dk = k;
- return s*(hfsq+R) + dk*ln2_lo - hfsq + f + dk*ln2_hi;
+ f = x - 1.0f;
+ s = f / (2.0f + f);
+ z = s * s;
+ w = z * z;
+ t1 = w * (Lg2 + w * Lg4);
+ t2 = z * (Lg1 + w * Lg3);
+ R = t2 + t1;
+ hfsq = 0.5f * f * f;
+ dk = k;
+ return s * (hfsq + R) + dk * ln2_lo - hfsq + f + dk * ln2_hi;
}
diff --git a/fusl/src/math/logl.c b/fusl/src/math/logl.c
index 5d53659..b01c9e6 100644
--- a/fusl/src/math/logl.c
+++ b/fusl/src/math/logl.c
@@ -55,9 +55,8 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double logl(long double x)
-{
- return log(x);
+long double logl(long double x) {
+ return log(x);
}
#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
/* Coefficients for log(1+x) = x - x**2/2 + x**3 P(x)/Q(x)
@@ -65,22 +64,16 @@
* Theoretical peak relative error = 2.32e-20
*/
static const long double P[] = {
- 4.5270000862445199635215E-5L,
- 4.9854102823193375972212E-1L,
- 6.5787325942061044846969E0L,
- 2.9911919328553073277375E1L,
- 6.0949667980987787057556E1L,
- 5.7112963590585538103336E1L,
- 2.0039553499201281259648E1L,
+ 4.5270000862445199635215E-5L, 4.9854102823193375972212E-1L,
+ 6.5787325942061044846969E0L, 2.9911919328553073277375E1L,
+ 6.0949667980987787057556E1L, 5.7112963590585538103336E1L,
+ 2.0039553499201281259648E1L,
};
static const long double Q[] = {
-/* 1.0000000000000000000000E0,*/
- 1.5062909083469192043167E1L,
- 8.3047565967967209469434E1L,
- 2.2176239823732856465394E2L,
- 3.0909872225312059774938E2L,
- 2.1642788614495947685003E2L,
- 6.0118660497603843919306E1L,
+ /* 1.0000000000000000000000E0,*/
+ 1.5062909083469192043167E1L, 8.3047565967967209469434E1L,
+ 2.2176239823732856465394E2L, 3.0909872225312059774938E2L,
+ 2.1642788614495947685003E2L, 6.0118660497603843919306E1L,
};
/* Coefficients for log(x) = z + z^3 P(z^2)/Q(z^2),
@@ -89,87 +82,82 @@
* Theoretical peak relative error = 6.16e-22
*/
static const long double R[4] = {
- 1.9757429581415468984296E-3L,
--7.1990767473014147232598E-1L,
- 1.0777257190312272158094E1L,
--3.5717684488096787370998E1L,
+ 1.9757429581415468984296E-3L, -7.1990767473014147232598E-1L,
+ 1.0777257190312272158094E1L, -3.5717684488096787370998E1L,
};
static const long double S[4] = {
-/* 1.00000000000000000000E0L,*/
--2.6201045551331104417768E1L,
- 1.9361891836232102174846E2L,
--4.2861221385716144629696E2L,
+ /* 1.00000000000000000000E0L,*/
+ -2.6201045551331104417768E1L, 1.9361891836232102174846E2L,
+ -4.2861221385716144629696E2L,
};
static const long double C1 = 6.9314575195312500000000E-1L;
static const long double C2 = 1.4286068203094172321215E-6L;
#define SQRTH 0.70710678118654752440L
-long double logl(long double x)
-{
- long double y, z;
- int e;
+long double logl(long double x) {
+ long double y, z;
+ int e;
- if (isnan(x))
- return x;
- if (x == INFINITY)
- return x;
- if (x <= 0.0) {
- if (x == 0.0)
- return -1/(x*x); /* -inf with divbyzero */
- return 0/0.0f; /* nan with invalid */
- }
+ if (isnan(x))
+ return x;
+ if (x == INFINITY)
+ return x;
+ if (x <= 0.0) {
+ if (x == 0.0)
+ return -1 / (x * x); /* -inf with divbyzero */
+ return 0 / 0.0f; /* nan with invalid */
+ }
- /* separate mantissa from exponent */
- /* Note, frexp is used so that denormal numbers
- * will be handled properly.
- */
- x = frexpl(x, &e);
+ /* 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.5;
- y = 0.5 * z + 0.5;
- } else { /* 2 (x-1)/(x+1) */
- z = x - 0.5;
- z -= 0.5;
- y = 0.5 * x + 0.5;
- }
- x = z / y;
- z = x*x;
- z = x * (z * __polevll(z, R, 3) / __p1evll(z, S, 3));
- z = z + e * C2;
- z = z + x;
- z = z + e * C1;
- return z;
- }
+ /* 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.5;
+ y = 0.5 * z + 0.5;
+ } else { /* 2 (x-1)/(x+1) */
+ z = x - 0.5;
+ z -= 0.5;
+ y = 0.5 * x + 0.5;
+ }
+ x = z / y;
+ z = x * x;
+ z = x * (z * __polevll(z, R, 3) / __p1evll(z, S, 3));
+ 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;
- x = 2.0*x - 1.0;
- } else {
- x = x - 1.0;
- }
- z = x*x;
- y = x * (z * __polevll(x, P, 6) / __p1evll(x, Q, 6));
- y = y + e * C2;
- z = y - 0.5*z;
- /* Note, the sum of above terms does not exceed x/4,
- * so it contributes at most about 1/4 lsb to the error.
- */
- z = z + x;
- z = z + e * C1; /* This sum has an error of 1/2 lsb. */
- return z;
+ /* logarithm using log(1+x) = x - .5x**2 + x**3 P(x)/Q(x) */
+ if (x < SQRTH) {
+ e -= 1;
+ x = 2.0 * x - 1.0;
+ } else {
+ x = x - 1.0;
+ }
+ z = x * x;
+ y = x * (z * __polevll(x, P, 6) / __p1evll(x, Q, 6));
+ y = y + e * C2;
+ z = y - 0.5 * z;
+ /* Note, the sum of above terms does not exceed x/4,
+ * so it contributes at most about 1/4 lsb to the error.
+ */
+ z = z + x;
+ z = z + e * C1; /* This sum has an error of 1/2 lsb. */
+ return z;
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
// TODO: broken implementation to make things compile
-long double logl(long double x)
-{
- return log(x);
+long double logl(long double x) {
+ return log(x);
}
#endif
diff --git a/fusl/src/math/lrint.c b/fusl/src/math/lrint.c
index bdca8b7..9df34eb 100644
--- a/fusl/src/math/lrint.c
+++ b/fusl/src/math/lrint.c
@@ -25,22 +25,20 @@
as a double.
*/
-#if LONG_MAX < 1U<<53 && defined(FE_INEXACT)
-long lrint(double x)
-{
- #pragma STDC FENV_ACCESS ON
- int e;
+#if LONG_MAX < 1U << 53 && defined(FE_INEXACT)
+long lrint(double x) {
+#pragma STDC FENV_ACCESS ON
+ int e;
- e = fetestexcept(FE_INEXACT);
- x = rint(x);
- if (!e && (x > LONG_MAX || x < LONG_MIN))
- feclearexcept(FE_INEXACT);
- /* conversion */
- return x;
+ e = fetestexcept(FE_INEXACT);
+ x = rint(x);
+ if (!e && (x > LONG_MAX || x < LONG_MIN))
+ feclearexcept(FE_INEXACT);
+ /* conversion */
+ return x;
}
#else
-long lrint(double x)
-{
- return rint(x);
+long lrint(double x) {
+ return rint(x);
}
#endif
diff --git a/fusl/src/math/lrintf.c b/fusl/src/math/lrintf.c
index ca0b6a4..f67deb6 100644
--- a/fusl/src/math/lrintf.c
+++ b/fusl/src/math/lrintf.c
@@ -2,7 +2,6 @@
/* uses LONG_MAX > 2^24, see comments in lrint.c */
-long lrintf(float x)
-{
- return rintf(x);
+long lrintf(float x) {
+ return rintf(x);
}
diff --git a/fusl/src/math/lrintl.c b/fusl/src/math/lrintl.c
index 08cc1ab..36e4bfc 100644
--- a/fusl/src/math/lrintl.c
+++ b/fusl/src/math/lrintl.c
@@ -2,11 +2,9 @@
#include <fenv.h>
#include "libm.h"
-
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long lrintl(long double x)
-{
- return lrint(x);
+long lrintl(long double x) {
+ return lrint(x);
}
#elif defined(FE_INEXACT)
/*
@@ -16,21 +14,19 @@
then x == 2**63 - 0.5 is the only input that overflows and
raises inexact (with tonearest or upward rounding mode)
*/
-long lrintl(long double x)
-{
- PRAGMA_STDC_FENV_ACCESS_ON
- int e;
+long lrintl(long double x) {
+ PRAGMA_STDC_FENV_ACCESS_ON
+ int e;
- e = fetestexcept(FE_INEXACT);
- x = rintl(x);
- if (!e && (x > LONG_MAX || x < LONG_MIN))
- feclearexcept(FE_INEXACT);
- /* conversion */
- return x;
+ e = fetestexcept(FE_INEXACT);
+ x = rintl(x);
+ if (!e && (x > LONG_MAX || x < LONG_MIN))
+ feclearexcept(FE_INEXACT);
+ /* conversion */
+ return x;
}
#else
-long lrintl(long double x)
-{
- return rintl(x);
+long lrintl(long double x) {
+ return rintl(x);
}
#endif
diff --git a/fusl/src/math/lround.c b/fusl/src/math/lround.c
index b8b7954..d283026 100644
--- a/fusl/src/math/lround.c
+++ b/fusl/src/math/lround.c
@@ -1,6 +1,5 @@
#include <math.h>
-long lround(double x)
-{
- return round(x);
+long lround(double x) {
+ return round(x);
}
diff --git a/fusl/src/math/lroundf.c b/fusl/src/math/lroundf.c
index c4707e7..01178aa 100644
--- a/fusl/src/math/lroundf.c
+++ b/fusl/src/math/lroundf.c
@@ -1,6 +1,5 @@
#include <math.h>
-long lroundf(float x)
-{
- return roundf(x);
+long lroundf(float x) {
+ return roundf(x);
}
diff --git a/fusl/src/math/lroundl.c b/fusl/src/math/lroundl.c
index 094fdf6..5bb9107 100644
--- a/fusl/src/math/lroundl.c
+++ b/fusl/src/math/lroundl.c
@@ -1,6 +1,5 @@
#include <math.h>
-long lroundl(long double x)
-{
- return roundl(x);
+long lroundl(long double x) {
+ return roundl(x);
}
diff --git a/fusl/src/math/modf.c b/fusl/src/math/modf.c
index 1c8a1db..01a1941 100644
--- a/fusl/src/math/modf.c
+++ b/fusl/src/math/modf.c
@@ -1,34 +1,36 @@
#include "libm.h"
-double modf(double x, double *iptr)
-{
- union {double f; uint64_t i;} u = {x};
- uint64_t mask;
- int e = (int)(u.i>>52 & 0x7ff) - 0x3ff;
+double modf(double x, double* iptr) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {x};
+ uint64_t mask;
+ int e = (int)(u.i >> 52 & 0x7ff) - 0x3ff;
- /* no fractional part */
- if (e >= 52) {
- *iptr = x;
- if (e == 0x400 && u.i<<12 != 0) /* nan */
- return x;
- u.i &= 1ULL<<63;
- return u.f;
- }
+ /* no fractional part */
+ if (e >= 52) {
+ *iptr = x;
+ if (e == 0x400 && u.i << 12 != 0) /* nan */
+ return x;
+ u.i &= 1ULL << 63;
+ return u.f;
+ }
- /* no integral part*/
- if (e < 0) {
- u.i &= 1ULL<<63;
- *iptr = u.f;
- return x;
- }
+ /* no integral part*/
+ if (e < 0) {
+ u.i &= 1ULL << 63;
+ *iptr = u.f;
+ return x;
+ }
- mask = -1ULL>>12>>e;
- if ((u.i & mask) == 0) {
- *iptr = x;
- u.i &= 1ULL<<63;
- return u.f;
- }
- u.i &= ~mask;
- *iptr = u.f;
- return x - u.f;
+ mask = -1ULL >> 12 >> e;
+ if ((u.i & mask) == 0) {
+ *iptr = x;
+ u.i &= 1ULL << 63;
+ return u.f;
+ }
+ u.i &= ~mask;
+ *iptr = u.f;
+ return x - u.f;
}
diff --git a/fusl/src/math/modff.c b/fusl/src/math/modff.c
index 639514e..eae990e 100644
--- a/fusl/src/math/modff.c
+++ b/fusl/src/math/modff.c
@@ -1,34 +1,36 @@
#include "libm.h"
-float modff(float x, float *iptr)
-{
- union {float f; uint32_t i;} u = {x};
- uint32_t mask;
- int e = (int)(u.i>>23 & 0xff) - 0x7f;
+float modff(float x, float* iptr) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {x};
+ uint32_t mask;
+ int e = (int)(u.i >> 23 & 0xff) - 0x7f;
- /* no fractional part */
- if (e >= 23) {
- *iptr = x;
- if (e == 0x80 && u.i<<9 != 0) { /* nan */
- return x;
- }
- u.i &= 0x80000000;
- return u.f;
- }
- /* no integral part */
- if (e < 0) {
- u.i &= 0x80000000;
- *iptr = u.f;
- return x;
- }
+ /* no fractional part */
+ if (e >= 23) {
+ *iptr = x;
+ if (e == 0x80 && u.i << 9 != 0) { /* nan */
+ return x;
+ }
+ u.i &= 0x80000000;
+ return u.f;
+ }
+ /* no integral part */
+ if (e < 0) {
+ u.i &= 0x80000000;
+ *iptr = u.f;
+ return x;
+ }
- mask = 0x007fffff>>e;
- if ((u.i & mask) == 0) {
- *iptr = x;
- u.i &= 0x80000000;
- return u.f;
- }
- u.i &= ~mask;
- *iptr = u.f;
- return x - u.f;
+ mask = 0x007fffff >> e;
+ if ((u.i & mask) == 0) {
+ *iptr = x;
+ u.i &= 0x80000000;
+ return u.f;
+ }
+ u.i &= ~mask;
+ *iptr = u.f;
+ return x - u.f;
}
diff --git a/fusl/src/math/modfl.c b/fusl/src/math/modfl.c
index a47b192..0736e96 100644
--- a/fusl/src/math/modfl.c
+++ b/fusl/src/math/modfl.c
@@ -1,53 +1,51 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double modfl(long double x, long double *iptr)
-{
- double d;
- long double r;
+long double modfl(long double x, long double* iptr) {
+ double d;
+ long double r;
- r = modf(x, &d);
- *iptr = d;
- return r;
+ r = modf(x, &d);
+ *iptr = d;
+ return r;
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-static const long double toint = 1/LDBL_EPSILON;
+static const long double toint = 1 / LDBL_EPSILON;
-long double modfl(long double x, long double *iptr)
-{
- union ldshape u = {x};
- int e = (u.i.se & 0x7fff) - 0x3fff;
- int s = u.i.se >> 15;
- long double absx;
- long double y;
+long double modfl(long double x, long double* iptr) {
+ union ldshape u = {x};
+ int e = (u.i.se & 0x7fff) - 0x3fff;
+ int s = u.i.se >> 15;
+ long double absx;
+ long double y;
- /* no fractional part */
- if (e >= LDBL_MANT_DIG-1) {
- *iptr = x;
- if (isnan(x))
- return x;
- return s ? -0.0 : 0.0;
- }
+ /* no fractional part */
+ if (e >= LDBL_MANT_DIG - 1) {
+ *iptr = x;
+ if (isnan(x))
+ return x;
+ return s ? -0.0 : 0.0;
+ }
- /* no integral part*/
- if (e < 0) {
- *iptr = s ? -0.0 : 0.0;
- return x;
- }
+ /* no integral part*/
+ if (e < 0) {
+ *iptr = s ? -0.0 : 0.0;
+ return x;
+ }
- /* raises spurious inexact */
- absx = s ? -x : x;
- y = absx + toint - toint - absx;
- if (y == 0) {
- *iptr = x;
- return s ? -0.0 : 0.0;
- }
- if (y > 0)
- y -= 1;
- if (s)
- y = -y;
- *iptr = x + y;
- return -y;
+ /* raises spurious inexact */
+ absx = s ? -x : x;
+ y = absx + toint - toint - absx;
+ if (y == 0) {
+ *iptr = x;
+ return s ? -0.0 : 0.0;
+ }
+ if (y > 0)
+ y -= 1;
+ if (s)
+ y = -y;
+ *iptr = x + y;
+ return -y;
}
#endif
diff --git a/fusl/src/math/nan.c b/fusl/src/math/nan.c
index 9e0826c..a25ee75 100644
--- a/fusl/src/math/nan.c
+++ b/fusl/src/math/nan.c
@@ -1,6 +1,5 @@
#include <math.h>
-double nan(const char *s)
-{
- return NAN;
+double nan(const char* s) {
+ return NAN;
}
diff --git a/fusl/src/math/nanf.c b/fusl/src/math/nanf.c
index 752ce54..dafe127 100644
--- a/fusl/src/math/nanf.c
+++ b/fusl/src/math/nanf.c
@@ -1,6 +1,5 @@
#include <math.h>
-float nanf(const char *s)
-{
- return NAN;
+float nanf(const char* s) {
+ return NAN;
}
diff --git a/fusl/src/math/nanl.c b/fusl/src/math/nanl.c
index 969af56..692645f 100644
--- a/fusl/src/math/nanl.c
+++ b/fusl/src/math/nanl.c
@@ -1,6 +1,5 @@
#include <math.h>
-long double nanl(const char *s)
-{
- return NAN;
+long double nanl(const char* s) {
+ return NAN;
}
diff --git a/fusl/src/math/nearbyint.c b/fusl/src/math/nearbyint.c
index b1c867f..6fc574e 100644
--- a/fusl/src/math/nearbyint.c
+++ b/fusl/src/math/nearbyint.c
@@ -4,18 +4,17 @@
/* nearbyint is the same as rint, but it must not raise the inexact exception */
-double nearbyint(double x)
-{
+double nearbyint(double x) {
#ifdef FE_INEXACT
- PRAGMA_STDC_FENV_ACCESS_ON
- int e;
+ PRAGMA_STDC_FENV_ACCESS_ON
+ int e;
- e = fetestexcept(FE_INEXACT);
+ e = fetestexcept(FE_INEXACT);
#endif
- x = rint(x);
+ x = rint(x);
#ifdef FE_INEXACT
- if (!e)
- feclearexcept(FE_INEXACT);
+ if (!e)
+ feclearexcept(FE_INEXACT);
#endif
- return x;
+ return x;
}
diff --git a/fusl/src/math/nearbyintf.c b/fusl/src/math/nearbyintf.c
index 7c0d374..d8dc470 100644
--- a/fusl/src/math/nearbyintf.c
+++ b/fusl/src/math/nearbyintf.c
@@ -2,18 +2,17 @@
#include <math.h>
#include "libm.h"
-float nearbyintf(float x)
-{
+float nearbyintf(float x) {
#ifdef FE_INEXACT
- PRAGMA_STDC_FENV_ACCESS_ON
- int e;
+ PRAGMA_STDC_FENV_ACCESS_ON
+ int e;
- e = fetestexcept(FE_INEXACT);
+ e = fetestexcept(FE_INEXACT);
#endif
- x = rintf(x);
+ x = rintf(x);
#ifdef FE_INEXACT
- if (!e)
- feclearexcept(FE_INEXACT);
+ if (!e)
+ feclearexcept(FE_INEXACT);
#endif
- return x;
+ return x;
}
diff --git a/fusl/src/math/nearbyintl.c b/fusl/src/math/nearbyintl.c
index 82aeadd..89f6700 100644
--- a/fusl/src/math/nearbyintl.c
+++ b/fusl/src/math/nearbyintl.c
@@ -3,25 +3,23 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double nearbyintl(long double x)
-{
- return nearbyint(x);
+long double nearbyintl(long double x) {
+ return nearbyint(x);
}
#else
#include <fenv.h>
-long double nearbyintl(long double x)
-{
+long double nearbyintl(long double x) {
#ifdef FE_INEXACT
- PRAGMA_STDC_FENV_ACCESS_ON
- int e;
+ PRAGMA_STDC_FENV_ACCESS_ON
+ int e;
- e = fetestexcept(FE_INEXACT);
+ e = fetestexcept(FE_INEXACT);
#endif
- x = rintl(x);
+ x = rintl(x);
#ifdef FE_INEXACT
- if (!e)
- feclearexcept(FE_INEXACT);
+ if (!e)
+ feclearexcept(FE_INEXACT);
#endif
- return x;
+ return x;
}
#endif
diff --git a/fusl/src/math/nextafter.c b/fusl/src/math/nextafter.c
index ab5795a..8f51f95 100644
--- a/fusl/src/math/nextafter.c
+++ b/fusl/src/math/nextafter.c
@@ -1,31 +1,33 @@
#include "libm.h"
-double nextafter(double x, double y)
-{
- union {double f; uint64_t i;} ux={x}, uy={y};
- uint64_t ax, ay;
- int e;
+double nextafter(double x, double y) {
+ union {
+ double f;
+ uint64_t i;
+ } ux = {x}, uy = {y};
+ uint64_t ax, ay;
+ int e;
- if (isnan(x) || isnan(y))
- return x + y;
- if (ux.i == uy.i)
- return y;
- ax = ux.i & -1ULL/2;
- ay = uy.i & -1ULL/2;
- if (ax == 0) {
- if (ay == 0)
- return y;
- ux.i = (uy.i & 1ULL<<63) | 1;
- } else if (ax > ay || ((ux.i ^ uy.i) & 1ULL<<63))
- ux.i--;
- else
- ux.i++;
- e = ux.i >> 52 & 0x7ff;
- /* raise overflow if ux.f is infinite and x is finite */
- if (e == 0x7ff)
- FORCE_EVAL(x+x);
- /* raise underflow if ux.f is subnormal or zero */
- if (e == 0)
- FORCE_EVAL(x*x + ux.f*ux.f);
- return ux.f;
+ if (isnan(x) || isnan(y))
+ return x + y;
+ if (ux.i == uy.i)
+ return y;
+ ax = ux.i & -1ULL / 2;
+ ay = uy.i & -1ULL / 2;
+ if (ax == 0) {
+ if (ay == 0)
+ return y;
+ ux.i = (uy.i & 1ULL << 63) | 1;
+ } else if (ax > ay || ((ux.i ^ uy.i) & 1ULL << 63))
+ ux.i--;
+ else
+ ux.i++;
+ e = ux.i >> 52 & 0x7ff;
+ /* raise overflow if ux.f is infinite and x is finite */
+ if (e == 0x7ff)
+ FORCE_EVAL(x + x);
+ /* raise underflow if ux.f is subnormal or zero */
+ if (e == 0)
+ FORCE_EVAL(x * x + ux.f * ux.f);
+ return ux.f;
}
diff --git a/fusl/src/math/nextafterf.c b/fusl/src/math/nextafterf.c
index 75a09f7..57ec9f0 100644
--- a/fusl/src/math/nextafterf.c
+++ b/fusl/src/math/nextafterf.c
@@ -1,30 +1,32 @@
#include "libm.h"
-float nextafterf(float x, float y)
-{
- union {float f; uint32_t i;} ux={x}, uy={y};
- uint32_t ax, ay, e;
+float nextafterf(float x, float y) {
+ union {
+ float f;
+ uint32_t i;
+ } ux = {x}, uy = {y};
+ uint32_t ax, ay, e;
- if (isnan(x) || isnan(y))
- return x + y;
- if (ux.i == uy.i)
- return y;
- ax = ux.i & 0x7fffffff;
- ay = uy.i & 0x7fffffff;
- if (ax == 0) {
- if (ay == 0)
- return y;
- ux.i = (uy.i & 0x80000000) | 1;
- } else if (ax > ay || ((ux.i ^ uy.i) & 0x80000000))
- ux.i--;
- else
- ux.i++;
- e = ux.i & 0x7f800000;
- /* raise overflow if ux.f is infinite and x is finite */
- if (e == 0x7f800000)
- FORCE_EVAL(x+x);
- /* raise underflow if ux.f is subnormal or zero */
- if (e == 0)
- FORCE_EVAL(x*x + ux.f*ux.f);
- return ux.f;
+ if (isnan(x) || isnan(y))
+ return x + y;
+ if (ux.i == uy.i)
+ return y;
+ ax = ux.i & 0x7fffffff;
+ ay = uy.i & 0x7fffffff;
+ if (ax == 0) {
+ if (ay == 0)
+ return y;
+ ux.i = (uy.i & 0x80000000) | 1;
+ } else if (ax > ay || ((ux.i ^ uy.i) & 0x80000000))
+ ux.i--;
+ else
+ ux.i++;
+ e = ux.i & 0x7f800000;
+ /* raise overflow if ux.f is infinite and x is finite */
+ if (e == 0x7f800000)
+ FORCE_EVAL(x + x);
+ /* raise underflow if ux.f is subnormal or zero */
+ if (e == 0)
+ FORCE_EVAL(x * x + ux.f * ux.f);
+ return ux.f;
}
diff --git a/fusl/src/math/nextafterl.c b/fusl/src/math/nextafterl.c
index 37e858f..3394b75 100644
--- a/fusl/src/math/nextafterl.c
+++ b/fusl/src/math/nextafterl.c
@@ -1,75 +1,72 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double nextafterl(long double x, long double y)
-{
- return nextafter(x, y);
+long double nextafterl(long double x, long double y) {
+ return nextafter(x, y);
}
#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
-long double nextafterl(long double x, long double y)
-{
- union ldshape ux, uy;
+long double nextafterl(long double x, long double y) {
+ union ldshape ux, uy;
- if (isnan(x) || isnan(y))
- return x + y;
- if (x == y)
- return y;
- ux.f = x;
- if (x == 0) {
- uy.f = y;
- ux.i.m = 1;
- ux.i.se = uy.i.se & 0x8000;
- } else if ((x < y) == !(ux.i.se & 0x8000)) {
- ux.i.m++;
- if (ux.i.m << 1 == 0) {
- ux.i.m = 1ULL << 63;
- ux.i.se++;
- }
- } else {
- if (ux.i.m << 1 == 0) {
- ux.i.se--;
- if (ux.i.se)
- ux.i.m = 0;
- }
- ux.i.m--;
- }
- /* raise overflow if ux is infinite and x is finite */
- if ((ux.i.se & 0x7fff) == 0x7fff)
- return x + x;
- /* raise underflow if ux is subnormal or zero */
- if ((ux.i.se & 0x7fff) == 0)
- FORCE_EVAL(x*x + ux.f*ux.f);
- return ux.f;
+ if (isnan(x) || isnan(y))
+ return x + y;
+ if (x == y)
+ return y;
+ ux.f = x;
+ if (x == 0) {
+ uy.f = y;
+ ux.i.m = 1;
+ ux.i.se = uy.i.se & 0x8000;
+ } else if ((x < y) == !(ux.i.se & 0x8000)) {
+ ux.i.m++;
+ if (ux.i.m << 1 == 0) {
+ ux.i.m = 1ULL << 63;
+ ux.i.se++;
+ }
+ } else {
+ if (ux.i.m << 1 == 0) {
+ ux.i.se--;
+ if (ux.i.se)
+ ux.i.m = 0;
+ }
+ ux.i.m--;
+ }
+ /* raise overflow if ux is infinite and x is finite */
+ if ((ux.i.se & 0x7fff) == 0x7fff)
+ return x + x;
+ /* raise underflow if ux is subnormal or zero */
+ if ((ux.i.se & 0x7fff) == 0)
+ FORCE_EVAL(x * x + ux.f * ux.f);
+ return ux.f;
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
-long double nextafterl(long double x, long double y)
-{
- union ldshape ux, uy;
+long double nextafterl(long double x, long double y) {
+ union ldshape ux, uy;
- if (isnan(x) || isnan(y))
- return x + y;
- if (x == y)
- return y;
- ux.f = x;
- if (x == 0) {
- uy.f = y;
- ux.i.lo = 1;
- ux.i.se = uy.i.se & 0x8000;
- } else if ((x < y) == !(ux.i.se & 0x8000)) {
- ux.i2.lo++;
- if (ux.i2.lo == 0)
- ux.i2.hi++;
- } else {
- if (ux.i2.lo == 0)
- ux.i2.hi--;
- ux.i2.lo--;
- }
- /* raise overflow if ux is infinite and x is finite */
- if ((ux.i.se & 0x7fff) == 0x7fff)
- return x + x;
- /* raise underflow if ux is subnormal or zero */
- if ((ux.i.se & 0x7fff) == 0)
- FORCE_EVAL(x*x + ux.f*ux.f);
- return ux.f;
+ if (isnan(x) || isnan(y))
+ return x + y;
+ if (x == y)
+ return y;
+ ux.f = x;
+ if (x == 0) {
+ uy.f = y;
+ ux.i.lo = 1;
+ ux.i.se = uy.i.se & 0x8000;
+ } else if ((x < y) == !(ux.i.se & 0x8000)) {
+ ux.i2.lo++;
+ if (ux.i2.lo == 0)
+ ux.i2.hi++;
+ } else {
+ if (ux.i2.lo == 0)
+ ux.i2.hi--;
+ ux.i2.lo--;
+ }
+ /* raise overflow if ux is infinite and x is finite */
+ if ((ux.i.se & 0x7fff) == 0x7fff)
+ return x + x;
+ /* raise underflow if ux is subnormal or zero */
+ if ((ux.i.se & 0x7fff) == 0)
+ FORCE_EVAL(x * x + ux.f * ux.f);
+ return ux.f;
}
#endif
diff --git a/fusl/src/math/nexttoward.c b/fusl/src/math/nexttoward.c
index 827ee5c..7cdee83 100644
--- a/fusl/src/math/nexttoward.c
+++ b/fusl/src/math/nexttoward.c
@@ -1,42 +1,43 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-double nexttoward(double x, long double y)
-{
- return nextafter(x, y);
+double nexttoward(double x, long double y) {
+ return nextafter(x, y);
}
#else
-double nexttoward(double x, long double y)
-{
- union {double f; uint64_t i;} ux = {x};
- int e;
+double nexttoward(double x, long double y) {
+ union {
+ double f;
+ uint64_t i;
+ } ux = {x};
+ int e;
- if (isnan(x) || isnan(y))
- return x + y;
- if (x == y)
- return y;
- if (x == 0) {
- ux.i = 1;
- if (signbit(y))
- ux.i |= 1ULL<<63;
- } else if (x < y) {
- if (signbit(x))
- ux.i--;
- else
- ux.i++;
- } else {
- if (signbit(x))
- ux.i++;
- else
- ux.i--;
- }
- e = ux.i>>52 & 0x7ff;
- /* raise overflow if ux.f is infinite and x is finite */
- if (e == 0x7ff)
- FORCE_EVAL(x+x);
- /* raise underflow if ux.f is subnormal or zero */
- if (e == 0)
- FORCE_EVAL(x*x + ux.f*ux.f);
- return ux.f;
+ if (isnan(x) || isnan(y))
+ return x + y;
+ if (x == y)
+ return y;
+ if (x == 0) {
+ ux.i = 1;
+ if (signbit(y))
+ ux.i |= 1ULL << 63;
+ } else if (x < y) {
+ if (signbit(x))
+ ux.i--;
+ else
+ ux.i++;
+ } else {
+ if (signbit(x))
+ ux.i++;
+ else
+ ux.i--;
+ }
+ e = ux.i >> 52 & 0x7ff;
+ /* raise overflow if ux.f is infinite and x is finite */
+ if (e == 0x7ff)
+ FORCE_EVAL(x + x);
+ /* raise underflow if ux.f is subnormal or zero */
+ if (e == 0)
+ FORCE_EVAL(x * x + ux.f * ux.f);
+ return ux.f;
}
#endif
diff --git a/fusl/src/math/nexttowardf.c b/fusl/src/math/nexttowardf.c
index bbf172f..f004e99 100644
--- a/fusl/src/math/nexttowardf.c
+++ b/fusl/src/math/nexttowardf.c
@@ -1,35 +1,37 @@
#include "libm.h"
-float nexttowardf(float x, long double y)
-{
- union {float f; uint32_t i;} ux = {x};
- uint32_t e;
+float nexttowardf(float x, long double y) {
+ union {
+ float f;
+ uint32_t i;
+ } ux = {x};
+ uint32_t e;
- if (isnan(x) || isnan(y))
- return x + y;
- if (x == y)
- return y;
- if (x == 0) {
- ux.i = 1;
- if (signbit(y))
- ux.i |= 0x80000000;
- } else if (x < y) {
- if (signbit(x))
- ux.i--;
- else
- ux.i++;
- } else {
- if (signbit(x))
- ux.i++;
- else
- ux.i--;
- }
- e = ux.i & 0x7f800000;
- /* raise overflow if ux.f is infinite and x is finite */
- if (e == 0x7f800000)
- FORCE_EVAL(x+x);
- /* raise underflow if ux.f is subnormal or zero */
- if (e == 0)
- FORCE_EVAL(x*x + ux.f*ux.f);
- return ux.f;
+ if (isnan(x) || isnan(y))
+ return x + y;
+ if (x == y)
+ return y;
+ if (x == 0) {
+ ux.i = 1;
+ if (signbit(y))
+ ux.i |= 0x80000000;
+ } else if (x < y) {
+ if (signbit(x))
+ ux.i--;
+ else
+ ux.i++;
+ } else {
+ if (signbit(x))
+ ux.i++;
+ else
+ ux.i--;
+ }
+ e = ux.i & 0x7f800000;
+ /* raise overflow if ux.f is infinite and x is finite */
+ if (e == 0x7f800000)
+ FORCE_EVAL(x + x);
+ /* raise underflow if ux.f is subnormal or zero */
+ if (e == 0)
+ FORCE_EVAL(x * x + ux.f * ux.f);
+ return ux.f;
}
diff --git a/fusl/src/math/nexttowardl.c b/fusl/src/math/nexttowardl.c
index 67a6340..132909d 100644
--- a/fusl/src/math/nexttowardl.c
+++ b/fusl/src/math/nexttowardl.c
@@ -1,6 +1,5 @@
#include <math.h>
-long double nexttowardl(long double x, long double y)
-{
- return nextafterl(x, y);
+long double nexttowardl(long double x, long double y) {
+ return nextafterl(x, y);
}
diff --git a/fusl/src/math/pow.c b/fusl/src/math/pow.c
index b66f632..7a9f1a6 100644
--- a/fusl/src/math/pow.c
+++ b/fusl/src/math/pow.c
@@ -31,14 +31,17 @@
* 9. -1 ** +-INF is 1
* 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, raise divbyzero
- * 13. -0 ** (-anything except 0, NAN, odd integer) is +INF, raise divbyzero
+ * 12. +0 ** (-anything except 0, NAN) is +INF, raise
+ * divbyzero
+ * 13. -0 ** (-anything except 0, NAN, odd integer) is +INF, raise
+ * divbyzero
* 14. -0 ** (+odd integer) is -0
* 15. -0 ** (-odd integer) is -INF, raise divbyzero
* 16. +INF ** (+anything except 0,NAN) is +INF
* 17. +INF ** (-anything except 0,NAN) is +0
* 18. -INF ** (+odd integer) is -INF
- * 19. -INF ** (anything) = -0 ** (-anything), (anything except odd integer)
+ * 19. -INF ** (anything) = -0 ** (-anything), (anything except odd
+ * integer)
* 20. (anything) ** 1 is (anything)
* 21. (anything) ** -1 is 1/(anything)
* 22. (-anything) ** (integer) is (-1)**(integer)*(+anything**integer)
@@ -59,270 +62,285 @@
#include "libm.h"
-static const double
-bp[] = {1.0, 1.5,},
-dp_h[] = { 0.0, 5.84962487220764160156e-01,}, /* 0x3FE2B803, 0x40000000 */
-dp_l[] = { 0.0, 1.35003920212974897128e-08,}, /* 0x3E4CFDEB, 0x43CFD006 */
-two53 = 9007199254740992.0, /* 0x43400000, 0x00000000 */
-huge = 1.0e300,
-tiny = 1.0e-300,
-/* poly coefs for (3/2)*(log(x)-2s-2/3*s**3 */
-L1 = 5.99999999999994648725e-01, /* 0x3FE33333, 0x33333303 */
-L2 = 4.28571428578550184252e-01, /* 0x3FDB6DB6, 0xDB6FABFF */
-L3 = 3.33333329818377432918e-01, /* 0x3FD55555, 0x518F264D */
-L4 = 2.72728123808534006489e-01, /* 0x3FD17460, 0xA91D4101 */
-L5 = 2.30660745775561754067e-01, /* 0x3FCD864A, 0x93C9DB65 */
-L6 = 2.06975017800338417784e-01, /* 0x3FCA7E28, 0x4A454EEF */
-P1 = 1.66666666666666019037e-01, /* 0x3FC55555, 0x5555553E */
-P2 = -2.77777777770155933842e-03, /* 0xBF66C16C, 0x16BEBD93 */
-P3 = 6.61375632143793436117e-05, /* 0x3F11566A, 0xAF25DE2C */
-P4 = -1.65339022054652515390e-06, /* 0xBEBBBD41, 0xC5D26BF1 */
-P5 = 4.13813679705723846039e-08, /* 0x3E663769, 0x72BEA4D0 */
-lg2 = 6.93147180559945286227e-01, /* 0x3FE62E42, 0xFEFA39EF */
-lg2_h = 6.93147182464599609375e-01, /* 0x3FE62E43, 0x00000000 */
-lg2_l = -1.90465429995776804525e-09, /* 0xBE205C61, 0x0CA86C39 */
-ovt = 8.0085662595372944372e-017, /* -(1024-log2(ovfl+.5ulp)) */
-cp = 9.61796693925975554329e-01, /* 0x3FEEC709, 0xDC3A03FD =2/(3ln2) */
-cp_h = 9.61796700954437255859e-01, /* 0x3FEEC709, 0xE0000000 =(float)cp */
-cp_l = -7.02846165095275826516e-09, /* 0xBE3E2FE0, 0x145B01F5 =tail of cp_h*/
-ivln2 = 1.44269504088896338700e+00, /* 0x3FF71547, 0x652B82FE =1/ln2 */
-ivln2_h = 1.44269502162933349609e+00, /* 0x3FF71547, 0x60000000 =24b 1/ln2*/
-ivln2_l = 1.92596299112661746887e-08; /* 0x3E54AE0B, 0xF85DDF44 =1/ln2 tail*/
+static const double bp[] =
+ {
+ 1.0, 1.5,
+},
+ dp_h[] =
+ {
+ 0.0, 5.84962487220764160156e-01,
+}, /* 0x3FE2B803, 0x40000000 */
+ dp_l[] =
+ {
+ 0.0, 1.35003920212974897128e-08,
+}, /* 0x3E4CFDEB, 0x43CFD006 */
+ two53 = 9007199254740992.0, /* 0x43400000, 0x00000000 */
+ huge = 1.0e300,
+ tiny = 1.0e-300,
+ /* poly coefs for (3/2)*(log(x)-2s-2/3*s**3 */
+ L1 = 5.99999999999994648725e-01, /* 0x3FE33333, 0x33333303 */
+ L2 = 4.28571428578550184252e-01, /* 0x3FDB6DB6, 0xDB6FABFF */
+ L3 = 3.33333329818377432918e-01, /* 0x3FD55555, 0x518F264D */
+ L4 = 2.72728123808534006489e-01, /* 0x3FD17460, 0xA91D4101 */
+ L5 = 2.30660745775561754067e-01, /* 0x3FCD864A, 0x93C9DB65 */
+ L6 = 2.06975017800338417784e-01, /* 0x3FCA7E28, 0x4A454EEF */
+ P1 = 1.66666666666666019037e-01, /* 0x3FC55555, 0x5555553E */
+ P2 = -2.77777777770155933842e-03, /* 0xBF66C16C, 0x16BEBD93 */
+ P3 = 6.61375632143793436117e-05, /* 0x3F11566A, 0xAF25DE2C */
+ P4 = -1.65339022054652515390e-06, /* 0xBEBBBD41, 0xC5D26BF1 */
+ P5 = 4.13813679705723846039e-08, /* 0x3E663769, 0x72BEA4D0 */
+ lg2 = 6.93147180559945286227e-01, /* 0x3FE62E42, 0xFEFA39EF */
+ lg2_h = 6.93147182464599609375e-01, /* 0x3FE62E43, 0x00000000 */
+ lg2_l = -1.90465429995776804525e-09, /* 0xBE205C61, 0x0CA86C39 */
+ ovt = 8.0085662595372944372e-017, /* -(1024-log2(ovfl+.5ulp)) */
+ cp = 9.61796693925975554329e-01, /* 0x3FEEC709, 0xDC3A03FD =2/(3ln2) */
+ cp_h = 9.61796700954437255859e-01, /* 0x3FEEC709, 0xE0000000 =(float)cp */
+ cp_l =
+ -7.02846165095275826516e-09, /* 0xBE3E2FE0, 0x145B01F5 =tail of cp_h*/
+ ivln2 = 1.44269504088896338700e+00, /* 0x3FF71547, 0x652B82FE =1/ln2 */
+ ivln2_h = 1.44269502162933349609e+00, /* 0x3FF71547, 0x60000000 =24b 1/ln2*/
+ ivln2_l =
+ 1.92596299112661746887e-08; /* 0x3E54AE0B, 0xF85DDF44 =1/ln2 tail*/
-double pow(double x, double y)
-{
- double z,ax,z_h,z_l,p_h,p_l;
- double y1,t1,t2,r,s,t,u,v,w;
- int32_t i,j,k,yisint,n;
- int32_t hx,hy,ix,iy;
- uint32_t lx,ly;
+double pow(double x, double y) {
+ double z, ax, z_h, z_l, p_h, p_l;
+ double y1, t1, t2, r, s, t, u, v, w;
+ int32_t i, j, k, yisint, n;
+ int32_t hx, hy, ix, iy;
+ uint32_t lx, ly;
- EXTRACT_WORDS(hx, lx, x);
- EXTRACT_WORDS(hy, ly, y);
- ix = hx & 0x7fffffff;
- iy = hy & 0x7fffffff;
+ EXTRACT_WORDS(hx, lx, x);
+ EXTRACT_WORDS(hy, ly, y);
+ ix = hx & 0x7fffffff;
+ iy = hy & 0x7fffffff;
- /* x**0 = 1, even if x is NaN */
- if ((iy|ly) == 0)
- return 1.0;
- /* 1**y = 1, even if y is NaN */
- if (hx == 0x3ff00000 && lx == 0)
- return 1.0;
- /* NaN if either arg is NaN */
- if (ix > 0x7ff00000 || (ix == 0x7ff00000 && lx != 0) ||
- iy > 0x7ff00000 || (iy == 0x7ff00000 && ly != 0))
- return x + y;
+ /* x**0 = 1, even if x is NaN */
+ if ((iy | ly) == 0)
+ return 1.0;
+ /* 1**y = 1, even if y is NaN */
+ if (hx == 0x3ff00000 && lx == 0)
+ return 1.0;
+ /* NaN if either arg is NaN */
+ if (ix > 0x7ff00000 || (ix == 0x7ff00000 && lx != 0) || iy > 0x7ff00000 ||
+ (iy == 0x7ff00000 && ly != 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 (iy >= 0x43400000)
- yisint = 2; /* even integer y */
- else if (iy >= 0x3ff00000) {
- k = (iy>>20) - 0x3ff; /* exponent */
- if (k > 20) {
- j = ly>>(52-k);
- if ((j<<(52-k)) == ly)
- yisint = 2 - (j&1);
- } else if (ly == 0) {
- j = iy>>(20-k);
- if ((j<<(20-k)) == iy)
- yisint = 2 - (j&1);
- }
- }
- }
+ /* 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 (iy >= 0x43400000)
+ yisint = 2; /* even integer y */
+ else if (iy >= 0x3ff00000) {
+ k = (iy >> 20) - 0x3ff; /* exponent */
+ if (k > 20) {
+ j = ly >> (52 - k);
+ if ((j << (52 - k)) == ly)
+ yisint = 2 - (j & 1);
+ } else if (ly == 0) {
+ j = iy >> (20 - k);
+ if ((j << (20 - k)) == iy)
+ yisint = 2 - (j & 1);
+ }
+ }
+ }
- /* special value of y */
- if (ly == 0) {
- if (iy == 0x7ff00000) { /* y is +-inf */
- if (((ix-0x3ff00000)|lx) == 0) /* (-1)**+-inf is 1 */
- return 1.0;
- else if (ix >= 0x3ff00000) /* (|x|>1)**+-inf = inf,0 */
- return hy >= 0 ? y : 0.0;
- else /* (|x|<1)**+-inf = 0,inf */
- return hy >= 0 ? 0.0 : -y;
- }
- if (iy == 0x3ff00000) { /* y is +-1 */
- if (hy >= 0)
- return x;
- y = 1/x;
-#if FLT_EVAL_METHOD!=0
- {
- union {double f; uint64_t i;} u = {y};
- uint64_t i = u.i & -1ULL/2;
- if (i>>52 == 0 && (i&(i-1)))
- FORCE_EVAL((float)y);
- }
+ /* special value of y */
+ if (ly == 0) {
+ if (iy == 0x7ff00000) { /* y is +-inf */
+ if (((ix - 0x3ff00000) | lx) == 0) /* (-1)**+-inf is 1 */
+ return 1.0;
+ else if (ix >= 0x3ff00000) /* (|x|>1)**+-inf = inf,0 */
+ return hy >= 0 ? y : 0.0;
+ else /* (|x|<1)**+-inf = 0,inf */
+ return hy >= 0 ? 0.0 : -y;
+ }
+ if (iy == 0x3ff00000) { /* y is +-1 */
+ if (hy >= 0)
+ return x;
+ y = 1 / x;
+#if FLT_EVAL_METHOD != 0
+ {
+ union {
+ double f;
+ uint64_t i;
+ } u = {y};
+ uint64_t i = u.i & -1ULL / 2;
+ if (i >> 52 == 0 && (i & (i - 1)))
+ FORCE_EVAL((float)y);
+ }
#endif
- return y;
- }
- if (hy == 0x40000000) /* y is 2 */
- return x*x;
- if (hy == 0x3fe00000) { /* y is 0.5 */
- if (hx >= 0) /* x >= +0 */
- return sqrt(x);
- }
- }
+ return y;
+ }
+ if (hy == 0x40000000) /* y is 2 */
+ return x * x;
+ if (hy == 0x3fe00000) { /* y is 0.5 */
+ if (hx >= 0) /* x >= +0 */
+ return sqrt(x);
+ }
+ }
- ax = fabs(x);
- /* special value of x */
- if (lx == 0) {
- if (ix == 0x7ff00000 || ix == 0 || ix == 0x3ff00000) { /* x is +-0,+-inf,+-1 */
- z = ax;
- if (hy < 0) /* z = (1/|x|) */
- z = 1.0/z;
- 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;
- }
- }
+ ax = fabs(x);
+ /* special value of x */
+ if (lx == 0) {
+ if (ix == 0x7ff00000 || ix == 0 ||
+ ix == 0x3ff00000) { /* x is +-0,+-inf,+-1 */
+ z = ax;
+ if (hy < 0) /* z = (1/|x|) */
+ z = 1.0 / z;
+ 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;
+ }
+ }
- s = 1.0; /* sign of result */
- if (hx < 0) {
- if (yisint == 0) /* (x<0)**(non-int) is NaN */
- return (x-x)/(x-x);
- if (yisint == 1) /* (x<0)**(odd int) */
- s = -1.0;
- }
+ s = 1.0; /* sign of result */
+ if (hx < 0) {
+ if (yisint == 0) /* (x<0)**(non-int) is NaN */
+ return (x - x) / (x - x);
+ if (yisint == 1) /* (x<0)**(odd int) */
+ s = -1.0;
+ }
- /* |y| is huge */
- if (iy > 0x41e00000) { /* if |y| > 2**31 */
- if (iy > 0x43f00000) { /* if |y| > 2**64, must o/uflow */
- 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 ? s*huge*huge : s*tiny*tiny;
- if (ix > 0x3ff00000)
- return hy > 0 ? s*huge*huge : s*tiny*tiny;
- /* now |1-x| is tiny <= 2**-20, suffice to compute
- log(x) by x-x^2/2+x^3/3-x^4/4 */
- t = ax - 1.0; /* t has 20 trailing zeros */
- w = (t*t)*(0.5 - t*(0.3333333333333333333333-t*0.25));
- u = ivln2_h*t; /* ivln2_h has 21 sig. bits */
- v = t*ivln2_l - w*ivln2;
- t1 = u + v;
- SET_LOW_WORD(t1, 0);
- t2 = v - (t1-u);
- } else {
- double ss,s2,s_h,s_l,t_h,t_l;
- n = 0;
- /* take care subnormal number */
- if (ix < 0x00100000) {
- ax *= two53;
- n -= 53;
- GET_HIGH_WORD(ix,ax);
- }
- n += ((ix)>>20) - 0x3ff;
- j = ix & 0x000fffff;
- /* determine interval */
- ix = j | 0x3ff00000; /* normalize ix */
- if (j <= 0x3988E) /* |x|<sqrt(3/2) */
- k = 0;
- else if (j < 0xBB67A) /* |x|<sqrt(3) */
- k = 1;
- else {
- k = 0;
- n += 1;
- ix -= 0x00100000;
- }
- SET_HIGH_WORD(ax, ix);
+ /* |y| is huge */
+ if (iy > 0x41e00000) { /* if |y| > 2**31 */
+ if (iy > 0x43f00000) { /* if |y| > 2**64, must o/uflow */
+ 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 ? s * huge * huge : s * tiny * tiny;
+ if (ix > 0x3ff00000)
+ return hy > 0 ? s * huge * huge : s * tiny * tiny;
+ /* now |1-x| is tiny <= 2**-20, suffice to compute
+ log(x) by x-x^2/2+x^3/3-x^4/4 */
+ t = ax - 1.0; /* t has 20 trailing zeros */
+ w = (t * t) * (0.5 - t * (0.3333333333333333333333 - t * 0.25));
+ u = ivln2_h * t; /* ivln2_h has 21 sig. bits */
+ v = t * ivln2_l - w * ivln2;
+ t1 = u + v;
+ SET_LOW_WORD(t1, 0);
+ t2 = v - (t1 - u);
+ } else {
+ double ss, s2, s_h, s_l, t_h, t_l;
+ n = 0;
+ /* take care subnormal number */
+ if (ix < 0x00100000) {
+ ax *= two53;
+ n -= 53;
+ GET_HIGH_WORD(ix, ax);
+ }
+ n += ((ix) >> 20) - 0x3ff;
+ j = ix & 0x000fffff;
+ /* determine interval */
+ ix = j | 0x3ff00000; /* normalize ix */
+ if (j <= 0x3988E) /* |x|<sqrt(3/2) */
+ k = 0;
+ else if (j < 0xBB67A) /* |x|<sqrt(3) */
+ k = 1;
+ else {
+ k = 0;
+ n += 1;
+ ix -= 0x00100000;
+ }
+ SET_HIGH_WORD(ax, ix);
- /* compute ss = 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 = 1.0/(ax+bp[k]);
- ss = u*v;
- s_h = ss;
- SET_LOW_WORD(s_h, 0);
- /* t_h=ax+bp[k] High */
- t_h = 0.0;
- SET_HIGH_WORD(t_h, ((ix>>1)|0x20000000) + 0x00080000 + (k<<18));
- t_l = ax - (t_h-bp[k]);
- s_l = v*((u-s_h*t_h)-s_h*t_l);
- /* compute log(ax) */
- s2 = ss*ss;
- r = s2*s2*(L1+s2*(L2+s2*(L3+s2*(L4+s2*(L5+s2*L6)))));
- r += s_l*(s_h+ss);
- s2 = s_h*s_h;
- t_h = 3.0 + s2 + r;
- SET_LOW_WORD(t_h, 0);
- t_l = r - ((t_h-3.0)-s2);
- /* u+v = ss*(1+...) */
- u = s_h*t_h;
- v = s_l*t_h + t_l*ss;
- /* 2/(3log2)*(ss+...) */
- p_h = u + v;
- SET_LOW_WORD(p_h, 0);
- 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) = (ss+..)*2/(3*log2) = n + dp_h + z_h + z_l */
- t = (double)n;
- t1 = ((z_h + z_l) + dp_h[k]) + t;
- SET_LOW_WORD(t1, 0);
- t2 = z_l - (((t1 - t) - dp_h[k]) - z_h);
- }
+ /* compute ss = 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 = 1.0 / (ax + bp[k]);
+ ss = u * v;
+ s_h = ss;
+ SET_LOW_WORD(s_h, 0);
+ /* t_h=ax+bp[k] High */
+ t_h = 0.0;
+ SET_HIGH_WORD(t_h, ((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18));
+ t_l = ax - (t_h - bp[k]);
+ s_l = v * ((u - s_h * t_h) - s_h * t_l);
+ /* compute log(ax) */
+ s2 = ss * ss;
+ r = s2 * s2 *
+ (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));
+ r += s_l * (s_h + ss);
+ s2 = s_h * s_h;
+ t_h = 3.0 + s2 + r;
+ SET_LOW_WORD(t_h, 0);
+ t_l = r - ((t_h - 3.0) - s2);
+ /* u+v = ss*(1+...) */
+ u = s_h * t_h;
+ v = s_l * t_h + t_l * ss;
+ /* 2/(3log2)*(ss+...) */
+ p_h = u + v;
+ SET_LOW_WORD(p_h, 0);
+ 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) = (ss+..)*2/(3*log2) = n + dp_h + z_h + z_l */
+ t = (double)n;
+ t1 = ((z_h + z_l) + dp_h[k]) + t;
+ SET_LOW_WORD(t1, 0);
+ t2 = z_l - (((t1 - t) - dp_h[k]) - z_h);
+ }
- /* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */
- y1 = y;
- SET_LOW_WORD(y1, 0);
- p_l = (y-y1)*t1 + y*t2;
- p_h = y1*t1;
- z = p_l + p_h;
- EXTRACT_WORDS(j, i, z);
- if (j >= 0x40900000) { /* z >= 1024 */
- if (((j-0x40900000)|i) != 0) /* if z > 1024 */
- return s*huge*huge; /* overflow */
- if (p_l + ovt > z - p_h)
- return s*huge*huge; /* overflow */
- } else if ((j&0x7fffffff) >= 0x4090cc00) { /* z <= -1075 */ // FIXME: instead of abs(j) use unsigned j
- if (((j-0xc090cc00)|i) != 0) /* z < -1075 */
- return s*tiny*tiny; /* underflow */
- 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 = j + (0x00100000>>(k+1));
- k = ((n&0x7fffffff)>>20) - 0x3ff; /* new k for n */
- t = 0.0;
- SET_HIGH_WORD(t, n & ~(0x000fffff>>k));
- n = ((n&0x000fffff)|0x00100000)>>(20-k);
- if (j < 0)
- n = -n;
- p_h -= t;
- }
- t = p_l + p_h;
- SET_LOW_WORD(t, 0);
- u = t*lg2_h;
- v = (p_l-(t-p_h))*lg2 + t*lg2_l;
- z = u + v;
- w = v - (z-u);
- t = z*z;
- t1 = z - t*(P1+t*(P2+t*(P3+t*(P4+t*P5))));
- r = (z*t1)/(t1-2.0) - (w + z*w);
- z = 1.0 - (r-z);
- GET_HIGH_WORD(j, z);
- j += n<<20;
- if ((j>>20) <= 0) /* subnormal output */
- z = scalbn(z,n);
- else
- SET_HIGH_WORD(z, j);
- return s*z;
+ /* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */
+ y1 = y;
+ SET_LOW_WORD(y1, 0);
+ p_l = (y - y1) * t1 + y * t2;
+ p_h = y1 * t1;
+ z = p_l + p_h;
+ EXTRACT_WORDS(j, i, z);
+ if (j >= 0x40900000) { /* z >= 1024 */
+ if (((j - 0x40900000) | i) != 0) /* if z > 1024 */
+ return s * huge * huge; /* overflow */
+ if (p_l + ovt > z - p_h)
+ return s * huge * huge; /* overflow */
+ } else if ((j & 0x7fffffff) >= 0x4090cc00) {
+ /* z <= -1075 */ // FIXME: instead of abs(j) use unsigned j
+ if (((j - 0xc090cc00) | i) != 0) /* z < -1075 */
+ return s * tiny * tiny; /* underflow */
+ 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 = j + (0x00100000 >> (k + 1));
+ k = ((n & 0x7fffffff) >> 20) - 0x3ff; /* new k for n */
+ t = 0.0;
+ SET_HIGH_WORD(t, n & ~(0x000fffff >> k));
+ n = ((n & 0x000fffff) | 0x00100000) >> (20 - k);
+ if (j < 0)
+ n = -n;
+ p_h -= t;
+ }
+ t = p_l + p_h;
+ SET_LOW_WORD(t, 0);
+ u = t * lg2_h;
+ v = (p_l - (t - p_h)) * lg2 + t * lg2_l;
+ z = u + v;
+ w = v - (z - u);
+ t = z * z;
+ t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));
+ r = (z * t1) / (t1 - 2.0) - (w + z * w);
+ z = 1.0 - (r - z);
+ GET_HIGH_WORD(j, z);
+ j += n << 20;
+ if ((j >> 20) <= 0) /* subnormal output */
+ z = scalbn(z, n);
+ else
+ SET_HIGH_WORD(z, j);
+ return s * z;
}
diff --git a/fusl/src/math/powf.c b/fusl/src/math/powf.c
index 427c896..ee4bd98 100644
--- a/fusl/src/math/powf.c
+++ b/fusl/src/math/powf.c
@@ -15,245 +15,257 @@
#include "libm.h"
-static const float
-bp[] = {1.0, 1.5,},
-dp_h[] = { 0.0, 5.84960938e-01,}, /* 0x3f15c000 */
-dp_l[] = { 0.0, 1.56322085e-06,}, /* 0x35d1cfdc */
-two24 = 16777216.0, /* 0x4b800000 */
-huge = 1.0e30,
-tiny = 1.0e-30,
-/* poly coefs for (3/2)*(log(x)-2s-2/3*s**3 */
-L1 = 6.0000002384e-01, /* 0x3f19999a */
-L2 = 4.2857143283e-01, /* 0x3edb6db7 */
-L3 = 3.3333334327e-01, /* 0x3eaaaaab */
-L4 = 2.7272811532e-01, /* 0x3e8ba305 */
-L5 = 2.3066075146e-01, /* 0x3e6c3255 */
-L6 = 2.0697501302e-01, /* 0x3e53f142 */
-P1 = 1.6666667163e-01, /* 0x3e2aaaab */
-P2 = -2.7777778450e-03, /* 0xbb360b61 */
-P3 = 6.6137559770e-05, /* 0x388ab355 */
-P4 = -1.6533901999e-06, /* 0xb5ddea0e */
-P5 = 4.1381369442e-08, /* 0x3331bb4c */
-lg2 = 6.9314718246e-01, /* 0x3f317218 */
-lg2_h = 6.93145752e-01, /* 0x3f317200 */
-lg2_l = 1.42860654e-06, /* 0x35bfbe8c */
-ovt = 4.2995665694e-08, /* -(128-log2(ovfl+.5ulp)) */
-cp = 9.6179670095e-01, /* 0x3f76384f =2/(3ln2) */
-cp_h = 9.6191406250e-01, /* 0x3f764000 =12b cp */
-cp_l = -1.1736857402e-04, /* 0xb8f623c6 =tail of cp_h */
-ivln2 = 1.4426950216e+00, /* 0x3fb8aa3b =1/ln2 */
-ivln2_h = 1.4426879883e+00, /* 0x3fb8aa00 =16b 1/ln2*/
-ivln2_l = 7.0526075433e-06; /* 0x36eca570 =1/ln2 tail*/
+static const float bp[] =
+ {
+ 1.0, 1.5,
+},
+ dp_h[] =
+ {
+ 0.0, 5.84960938e-01,
+}, /* 0x3f15c000 */
+ dp_l[] =
+ {
+ 0.0, 1.56322085e-06,
+}, /* 0x35d1cfdc */
+ two24 = 16777216.0, /* 0x4b800000 */
+ huge = 1.0e30,
+ tiny = 1.0e-30,
+ /* poly coefs for (3/2)*(log(x)-2s-2/3*s**3 */
+ L1 = 6.0000002384e-01, /* 0x3f19999a */
+ L2 = 4.2857143283e-01, /* 0x3edb6db7 */
+ L3 = 3.3333334327e-01, /* 0x3eaaaaab */
+ L4 = 2.7272811532e-01, /* 0x3e8ba305 */
+ L5 = 2.3066075146e-01, /* 0x3e6c3255 */
+ L6 = 2.0697501302e-01, /* 0x3e53f142 */
+ P1 = 1.6666667163e-01, /* 0x3e2aaaab */
+ P2 = -2.7777778450e-03, /* 0xbb360b61 */
+ P3 = 6.6137559770e-05, /* 0x388ab355 */
+ P4 = -1.6533901999e-06, /* 0xb5ddea0e */
+ P5 = 4.1381369442e-08, /* 0x3331bb4c */
+ lg2 = 6.9314718246e-01, /* 0x3f317218 */
+ lg2_h = 6.93145752e-01, /* 0x3f317200 */
+ lg2_l = 1.42860654e-06, /* 0x35bfbe8c */
+ ovt = 4.2995665694e-08, /* -(128-log2(ovfl+.5ulp)) */
+ cp = 9.6179670095e-01, /* 0x3f76384f =2/(3ln2) */
+ cp_h = 9.6191406250e-01, /* 0x3f764000 =12b cp */
+ cp_l = -1.1736857402e-04, /* 0xb8f623c6 =tail of cp_h */
+ ivln2 = 1.4426950216e+00, /* 0x3fb8aa3b =1/ln2 */
+ ivln2_h = 1.4426879883e+00, /* 0x3fb8aa00 =16b 1/ln2*/
+ ivln2_l = 7.0526075433e-06; /* 0x36eca570 =1/ln2 tail*/
-float powf(float x, float y)
-{
- float z,ax,z_h,z_l,p_h,p_l;
- float y1,t1,t2,r,s,sn,t,u,v,w;
- int32_t i,j,k,yisint,n;
- int32_t hx,hy,ix,iy,is;
+float powf(float x, float y) {
+ float z, ax, z_h, z_l, p_h, p_l;
+ float y1, t1, t2, r, s, sn, t, u, v, w;
+ int32_t i, j, k, yisint, n;
+ int32_t hx, hy, ix, iy, is;
- GET_FLOAT_WORD(hx, x);
- GET_FLOAT_WORD(hy, y);
- ix = hx & 0x7fffffff;
- iy = hy & 0x7fffffff;
+ GET_FLOAT_WORD(hx, x);
+ GET_FLOAT_WORD(hy, y);
+ ix = hx & 0x7fffffff;
+ iy = hy & 0x7fffffff;
- /* x**0 = 1, even if x is NaN */
- if (iy == 0)
- return 1.0f;
- /* 1**y = 1, even if y is NaN */
- if (hx == 0x3f800000)
- return 1.0f;
- /* NaN if either arg is NaN */
- if (ix > 0x7f800000 || iy > 0x7f800000)
- return x + y;
+ /* x**0 = 1, even if x is NaN */
+ if (iy == 0)
+ return 1.0f;
+ /* 1**y = 1, even if y is NaN */
+ if (hx == 0x3f800000)
+ return 1.0f;
+ /* NaN if either arg is NaN */
+ if (ix > 0x7f800000 || iy > 0x7f800000)
+ 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 (iy >= 0x4b800000)
- yisint = 2; /* even integer y */
- else if (iy >= 0x3f800000) {
- k = (iy>>23) - 0x7f; /* exponent */
- j = iy>>(23-k);
- if ((j<<(23-k)) == iy)
- yisint = 2 - (j & 1);
- }
- }
+ /* 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 (iy >= 0x4b800000)
+ yisint = 2; /* even integer y */
+ else if (iy >= 0x3f800000) {
+ k = (iy >> 23) - 0x7f; /* exponent */
+ j = iy >> (23 - k);
+ if ((j << (23 - k)) == iy)
+ yisint = 2 - (j & 1);
+ }
+ }
- /* special value of y */
- if (iy == 0x7f800000) { /* y is +-inf */
- if (ix == 0x3f800000) /* (-1)**+-inf is 1 */
- return 1.0f;
- else if (ix > 0x3f800000) /* (|x|>1)**+-inf = inf,0 */
- return hy >= 0 ? y : 0.0f;
- else /* (|x|<1)**+-inf = 0,inf */
- return hy >= 0 ? 0.0f: -y;
- }
- if (iy == 0x3f800000) /* y is +-1 */
- return hy >= 0 ? x : 1.0f/x;
- if (hy == 0x40000000) /* y is 2 */
- return x*x;
- if (hy == 0x3f000000) { /* y is 0.5 */
- if (hx >= 0) /* x >= +0 */
- return sqrtf(x);
- }
+ /* special value of y */
+ if (iy == 0x7f800000) { /* y is +-inf */
+ if (ix == 0x3f800000) /* (-1)**+-inf is 1 */
+ return 1.0f;
+ else if (ix > 0x3f800000) /* (|x|>1)**+-inf = inf,0 */
+ return hy >= 0 ? y : 0.0f;
+ else /* (|x|<1)**+-inf = 0,inf */
+ return hy >= 0 ? 0.0f : -y;
+ }
+ if (iy == 0x3f800000) /* y is +-1 */
+ return hy >= 0 ? x : 1.0f / x;
+ if (hy == 0x40000000) /* y is 2 */
+ return x * x;
+ if (hy == 0x3f000000) { /* y is 0.5 */
+ if (hx >= 0) /* x >= +0 */
+ return sqrtf(x);
+ }
- ax = fabsf(x);
- /* special value of x */
- if (ix == 0x7f800000 || ix == 0 || ix == 0x3f800000) { /* x is +-0,+-inf,+-1 */
- z = ax;
- if (hy < 0) /* z = (1/|x|) */
- z = 1.0f/z;
- if (hx < 0) {
- if (((ix-0x3f800000)|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;
- }
+ ax = fabsf(x);
+ /* special value of x */
+ if (ix == 0x7f800000 || ix == 0 ||
+ ix == 0x3f800000) { /* x is +-0,+-inf,+-1 */
+ z = ax;
+ if (hy < 0) /* z = (1/|x|) */
+ z = 1.0f / z;
+ if (hx < 0) {
+ if (((ix - 0x3f800000) | 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;
+ }
- sn = 1.0f; /* sign of result */
- if (hx < 0) {
- if (yisint == 0) /* (x<0)**(non-int) is NaN */
- return (x-x)/(x-x);
- if (yisint == 1) /* (x<0)**(odd int) */
- sn = -1.0f;
- }
+ sn = 1.0f; /* sign of result */
+ if (hx < 0) {
+ if (yisint == 0) /* (x<0)**(non-int) is NaN */
+ return (x - x) / (x - x);
+ if (yisint == 1) /* (x<0)**(odd int) */
+ sn = -1.0f;
+ }
- /* |y| is huge */
- if (iy > 0x4d000000) { /* if |y| > 2**27 */
- /* over/underflow if x is not close to one */
- if (ix < 0x3f7ffff8)
- return hy < 0 ? sn*huge*huge : sn*tiny*tiny;
- if (ix > 0x3f800007)
- return hy > 0 ? sn*huge*huge : sn*tiny*tiny;
- /* now |1-x| is tiny <= 2**-20, suffice to compute
- log(x) by x-x^2/2+x^3/3-x^4/4 */
- t = ax - 1; /* t has 20 trailing zeros */
- w = (t*t)*(0.5f - t*(0.333333333333f - t*0.25f));
- u = ivln2_h*t; /* ivln2_h has 16 sig. bits */
- v = t*ivln2_l - w*ivln2;
- t1 = u + v;
- GET_FLOAT_WORD(is, t1);
- SET_FLOAT_WORD(t1, is & 0xfffff000);
- t2 = v - (t1-u);
- } else {
- float s2,s_h,s_l,t_h,t_l;
- n = 0;
- /* take care subnormal number */
- if (ix < 0x00800000) {
- ax *= two24;
- n -= 24;
- GET_FLOAT_WORD(ix, ax);
- }
- n += ((ix)>>23) - 0x7f;
- j = ix & 0x007fffff;
- /* determine interval */
- ix = j | 0x3f800000; /* normalize ix */
- if (j <= 0x1cc471) /* |x|<sqrt(3/2) */
- k = 0;
- else if (j < 0x5db3d7) /* |x|<sqrt(3) */
- k = 1;
- else {
- k = 0;
- n += 1;
- ix -= 0x00800000;
- }
- SET_FLOAT_WORD(ax, ix);
+ /* |y| is huge */
+ if (iy > 0x4d000000) { /* if |y| > 2**27 */
+ /* over/underflow if x is not close to one */
+ if (ix < 0x3f7ffff8)
+ return hy < 0 ? sn * huge * huge : sn * tiny * tiny;
+ if (ix > 0x3f800007)
+ return hy > 0 ? sn * huge * huge : sn * tiny * tiny;
+ /* now |1-x| is tiny <= 2**-20, suffice to compute
+ log(x) by x-x^2/2+x^3/3-x^4/4 */
+ t = ax - 1; /* t has 20 trailing zeros */
+ w = (t * t) * (0.5f - t * (0.333333333333f - t * 0.25f));
+ u = ivln2_h * t; /* ivln2_h has 16 sig. bits */
+ v = t * ivln2_l - w * ivln2;
+ t1 = u + v;
+ GET_FLOAT_WORD(is, t1);
+ SET_FLOAT_WORD(t1, is & 0xfffff000);
+ t2 = v - (t1 - u);
+ } else {
+ float s2, s_h, s_l, t_h, t_l;
+ n = 0;
+ /* take care subnormal number */
+ if (ix < 0x00800000) {
+ ax *= two24;
+ n -= 24;
+ GET_FLOAT_WORD(ix, ax);
+ }
+ n += ((ix) >> 23) - 0x7f;
+ j = ix & 0x007fffff;
+ /* determine interval */
+ ix = j | 0x3f800000; /* normalize ix */
+ if (j <= 0x1cc471) /* |x|<sqrt(3/2) */
+ k = 0;
+ else if (j < 0x5db3d7) /* |x|<sqrt(3) */
+ k = 1;
+ else {
+ k = 0;
+ n += 1;
+ ix -= 0x00800000;
+ }
+ SET_FLOAT_WORD(ax, ix);
- /* 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 = 1.0f/(ax+bp[k]);
- s = u*v;
- s_h = s;
- GET_FLOAT_WORD(is, s_h);
- SET_FLOAT_WORD(s_h, is & 0xfffff000);
- /* t_h=ax+bp[k] High */
- is = ((ix>>1) & 0xfffff000) | 0x20000000;
- SET_FLOAT_WORD(t_h, is + 0x00400000 + (k<<21));
- 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;
- r = s2*s2*(L1+s2*(L2+s2*(L3+s2*(L4+s2*(L5+s2*L6)))));
- r += s_l*(s_h+s);
- s2 = s_h*s_h;
- t_h = 3.0f + s2 + r;
- GET_FLOAT_WORD(is, t_h);
- SET_FLOAT_WORD(t_h, is & 0xfffff000);
- t_l = r - ((t_h - 3.0f) - 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;
- GET_FLOAT_WORD(is, p_h);
- SET_FLOAT_WORD(p_h, is & 0xfffff000);
- 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 = (float)n;
- t1 = (((z_h + z_l) + dp_h[k]) + t);
- GET_FLOAT_WORD(is, t1);
- SET_FLOAT_WORD(t1, is & 0xfffff000);
- t2 = z_l - (((t1 - t) - dp_h[k]) - z_h);
- }
+ /* 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 = 1.0f / (ax + bp[k]);
+ s = u * v;
+ s_h = s;
+ GET_FLOAT_WORD(is, s_h);
+ SET_FLOAT_WORD(s_h, is & 0xfffff000);
+ /* t_h=ax+bp[k] High */
+ is = ((ix >> 1) & 0xfffff000) | 0x20000000;
+ SET_FLOAT_WORD(t_h, is + 0x00400000 + (k << 21));
+ 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;
+ r = s2 * s2 *
+ (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));
+ r += s_l * (s_h + s);
+ s2 = s_h * s_h;
+ t_h = 3.0f + s2 + r;
+ GET_FLOAT_WORD(is, t_h);
+ SET_FLOAT_WORD(t_h, is & 0xfffff000);
+ t_l = r - ((t_h - 3.0f) - 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;
+ GET_FLOAT_WORD(is, p_h);
+ SET_FLOAT_WORD(p_h, is & 0xfffff000);
+ 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 = (float)n;
+ t1 = (((z_h + z_l) + dp_h[k]) + t);
+ GET_FLOAT_WORD(is, t1);
+ SET_FLOAT_WORD(t1, is & 0xfffff000);
+ t2 = z_l - (((t1 - t) - dp_h[k]) - z_h);
+ }
- /* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */
- GET_FLOAT_WORD(is, y);
- SET_FLOAT_WORD(y1, is & 0xfffff000);
- p_l = (y-y1)*t1 + y*t2;
- p_h = y1*t1;
- z = p_l + p_h;
- GET_FLOAT_WORD(j, z);
- if (j > 0x43000000) /* if z > 128 */
- return sn*huge*huge; /* overflow */
- else if (j == 0x43000000) { /* if z == 128 */
- if (p_l + ovt > z - p_h)
- return sn*huge*huge; /* overflow */
- } else if ((j&0x7fffffff) > 0x43160000) /* z < -150 */ // FIXME: check should be (uint32_t)j > 0xc3160000
- return sn*tiny*tiny; /* underflow */
- else if (j == 0xc3160000) { /* z == -150 */
- if (p_l <= z-p_h)
- return sn*tiny*tiny; /* underflow */
- }
- /*
- * compute 2**(p_h+p_l)
- */
- i = j & 0x7fffffff;
- k = (i>>23) - 0x7f;
- n = 0;
- if (i > 0x3f000000) { /* if |z| > 0.5, set n = [z+0.5] */
- n = j + (0x00800000>>(k+1));
- k = ((n&0x7fffffff)>>23) - 0x7f; /* new k for n */
- SET_FLOAT_WORD(t, n & ~(0x007fffff>>k));
- n = ((n&0x007fffff)|0x00800000)>>(23-k);
- if (j < 0)
- n = -n;
- p_h -= t;
- }
- t = p_l + p_h;
- GET_FLOAT_WORD(is, t);
- SET_FLOAT_WORD(t, is & 0xffff8000);
- u = t*lg2_h;
- v = (p_l-(t-p_h))*lg2 + t*lg2_l;
- z = u + v;
- w = v - (z - u);
- t = z*z;
- t1 = z - t*(P1+t*(P2+t*(P3+t*(P4+t*P5))));
- r = (z*t1)/(t1-2.0f) - (w+z*w);
- z = 1.0f - (r - z);
- GET_FLOAT_WORD(j, z);
- j += n<<23;
- if ((j>>23) <= 0) /* subnormal output */
- z = scalbnf(z, n);
- else
- SET_FLOAT_WORD(z, j);
- return sn*z;
+ /* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */
+ GET_FLOAT_WORD(is, y);
+ SET_FLOAT_WORD(y1, is & 0xfffff000);
+ p_l = (y - y1) * t1 + y * t2;
+ p_h = y1 * t1;
+ z = p_l + p_h;
+ GET_FLOAT_WORD(j, z);
+ if (j > 0x43000000) /* if z > 128 */
+ return sn * huge * huge; /* overflow */
+ else if (j == 0x43000000) { /* if z == 128 */
+ if (p_l + ovt > z - p_h)
+ return sn * huge * huge; /* overflow */
+ } else if ((j & 0x7fffffff) > 0x43160000) /* z < -150 */ // FIXME: check
+ // should be
+ // (uint32_t)j >
+ // 0xc3160000
+ return sn * tiny * tiny; /* underflow */
+ else if (j == 0xc3160000) { /* z == -150 */
+ if (p_l <= z - p_h)
+ return sn * tiny * tiny; /* underflow */
+ }
+ /*
+ * compute 2**(p_h+p_l)
+ */
+ i = j & 0x7fffffff;
+ k = (i >> 23) - 0x7f;
+ n = 0;
+ if (i > 0x3f000000) { /* if |z| > 0.5, set n = [z+0.5] */
+ n = j + (0x00800000 >> (k + 1));
+ k = ((n & 0x7fffffff) >> 23) - 0x7f; /* new k for n */
+ SET_FLOAT_WORD(t, n & ~(0x007fffff >> k));
+ n = ((n & 0x007fffff) | 0x00800000) >> (23 - k);
+ if (j < 0)
+ n = -n;
+ p_h -= t;
+ }
+ t = p_l + p_h;
+ GET_FLOAT_WORD(is, t);
+ SET_FLOAT_WORD(t, is & 0xffff8000);
+ u = t * lg2_h;
+ v = (p_l - (t - p_h)) * lg2 + t * lg2_l;
+ z = u + v;
+ w = v - (z - u);
+ t = z * z;
+ t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));
+ r = (z * t1) / (t1 - 2.0f) - (w + z * w);
+ z = 1.0f - (r - z);
+ GET_FLOAT_WORD(j, z);
+ j += n << 23;
+ if ((j >> 23) <= 0) /* subnormal output */
+ z = scalbnf(z, n);
+ else
+ SET_FLOAT_WORD(z, j);
+ return sn * z;
}
diff --git a/fusl/src/math/powl.c b/fusl/src/math/powl.c
index 5b6da07..d7737b0 100644
--- a/fusl/src/math/powl.c
+++ b/fusl/src/math/powl.c
@@ -70,9 +70,8 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double powl(long double x, long double y)
-{
- return pow(x, y);
+long double powl(long double x, long double y) {
+ return pow(x, y);
}
#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
@@ -83,91 +82,61 @@
* on the domain 2^(-1/32) - 1 <= x <= 2^(1/32) - 1
*/
static const long double P[] = {
- 8.3319510773868690346226E-4L,
- 4.9000050881978028599627E-1L,
- 1.7500123722550302671919E0L,
- 1.4000100839971580279335E0L,
+ 8.3319510773868690346226E-4L, 4.9000050881978028599627E-1L,
+ 1.7500123722550302671919E0L, 1.4000100839971580279335E0L,
};
static const long double Q[] = {
-/* 1.0000000000000000000000E0L,*/
- 5.2500282295834889175431E0L,
- 8.4000598057587009834666E0L,
- 4.2000302519914740834728E0L,
+ /* 1.0000000000000000000000E0L,*/
+ 5.2500282295834889175431E0L, 8.4000598057587009834666E0L,
+ 4.2000302519914740834728E0L,
};
/* A[i] = 2^(-i/32), rounded to IEEE long double precision.
* If i is even, A[i] + B[i/2] gives additional accuracy.
*/
static const long double A[33] = {
- 1.0000000000000000000000E0L,
- 9.7857206208770013448287E-1L,
- 9.5760328069857364691013E-1L,
- 9.3708381705514995065011E-1L,
- 9.1700404320467123175367E-1L,
- 8.9735453750155359320742E-1L,
- 8.7812608018664974155474E-1L,
- 8.5930964906123895780165E-1L,
- 8.4089641525371454301892E-1L,
- 8.2287773907698242225554E-1L,
- 8.0524516597462715409607E-1L,
- 7.8799042255394324325455E-1L,
- 7.7110541270397041179298E-1L,
- 7.5458221379671136985669E-1L,
- 7.3841307296974965571198E-1L,
- 7.2259040348852331001267E-1L,
- 7.0710678118654752438189E-1L,
- 6.9195494098191597746178E-1L,
- 6.7712777346844636413344E-1L,
- 6.6261832157987064729696E-1L,
- 6.4841977732550483296079E-1L,
- 6.3452547859586661129850E-1L,
- 6.2092890603674202431705E-1L,
- 6.0762367999023443907803E-1L,
- 5.9460355750136053334378E-1L,
- 5.8186242938878875689693E-1L,
- 5.6939431737834582684856E-1L,
- 5.5719337129794626814472E-1L,
- 5.4525386633262882960438E-1L,
- 5.3357020033841180906486E-1L,
- 5.2213689121370692017331E-1L,
- 5.1094857432705833910408E-1L,
- 5.0000000000000000000000E-1L,
+ 1.0000000000000000000000E0L, 9.7857206208770013448287E-1L,
+ 9.5760328069857364691013E-1L, 9.3708381705514995065011E-1L,
+ 9.1700404320467123175367E-1L, 8.9735453750155359320742E-1L,
+ 8.7812608018664974155474E-1L, 8.5930964906123895780165E-1L,
+ 8.4089641525371454301892E-1L, 8.2287773907698242225554E-1L,
+ 8.0524516597462715409607E-1L, 7.8799042255394324325455E-1L,
+ 7.7110541270397041179298E-1L, 7.5458221379671136985669E-1L,
+ 7.3841307296974965571198E-1L, 7.2259040348852331001267E-1L,
+ 7.0710678118654752438189E-1L, 6.9195494098191597746178E-1L,
+ 6.7712777346844636413344E-1L, 6.6261832157987064729696E-1L,
+ 6.4841977732550483296079E-1L, 6.3452547859586661129850E-1L,
+ 6.2092890603674202431705E-1L, 6.0762367999023443907803E-1L,
+ 5.9460355750136053334378E-1L, 5.8186242938878875689693E-1L,
+ 5.6939431737834582684856E-1L, 5.5719337129794626814472E-1L,
+ 5.4525386633262882960438E-1L, 5.3357020033841180906486E-1L,
+ 5.2213689121370692017331E-1L, 5.1094857432705833910408E-1L,
+ 5.0000000000000000000000E-1L,
};
static const long double B[17] = {
- 0.0000000000000000000000E0L,
- 2.6176170809902549338711E-20L,
--1.0126791927256478897086E-20L,
- 1.3438228172316276937655E-21L,
- 1.2207982955417546912101E-20L,
--6.3084814358060867200133E-21L,
- 1.3164426894366316434230E-20L,
--1.8527916071632873716786E-20L,
- 1.8950325588932570796551E-20L,
- 1.5564775779538780478155E-20L,
- 6.0859793637556860974380E-21L,
--2.0208749253662532228949E-20L,
- 1.4966292219224761844552E-20L,
- 3.3540909728056476875639E-21L,
--8.6987564101742849540743E-22L,
--1.2327176863327626135542E-20L,
- 0.0000000000000000000000E0L,
+ 0.0000000000000000000000E0L, 2.6176170809902549338711E-20L,
+ -1.0126791927256478897086E-20L, 1.3438228172316276937655E-21L,
+ 1.2207982955417546912101E-20L, -6.3084814358060867200133E-21L,
+ 1.3164426894366316434230E-20L, -1.8527916071632873716786E-20L,
+ 1.8950325588932570796551E-20L, 1.5564775779538780478155E-20L,
+ 6.0859793637556860974380E-21L, -2.0208749253662532228949E-20L,
+ 1.4966292219224761844552E-20L, 3.3540909728056476875639E-21L,
+ -8.6987564101742849540743E-22L, -1.2327176863327626135542E-20L,
+ 0.0000000000000000000000E0L,
};
/* 2^x = 1 + x P(x),
* on the interval -1/32 <= x <= 0
*/
static const long double R[] = {
- 1.5089970579127659901157E-5L,
- 1.5402715328927013076125E-4L,
- 1.3333556028915671091390E-3L,
- 9.6181291046036762031786E-3L,
- 5.5504108664798463044015E-2L,
- 2.4022650695910062854352E-1L,
- 6.9314718055994530931447E-1L,
+ 1.5089970579127659901157E-5L, 1.5402715328927013076125E-4L,
+ 1.3333556028915671091390E-3L, 9.6181291046036762031786E-3L,
+ 5.5504108664798463044015E-2L, 2.4022650695910062854352E-1L,
+ 6.9314718055994530931447E-1L,
};
-#define MEXP (NXT*16384.0L)
+#define MEXP (NXT * 16384.0L)
/* The following if denormal numbers are supported, else -MEXP: */
-#define MNEXP (-NXT*(16384.0L+64.0L))
+#define MNEXP (-NXT * (16384.0L + 64.0L))
/* log2(e) - 1 */
#define LOG2EA 0.44269504088896340735992L
@@ -191,231 +160,228 @@
static long double reducl(long double);
static long double powil(long double, int);
-long double powl(long double x, long double y)
-{
- /* double F, Fa, Fb, G, Ga, Gb, H, Ha, Hb */
- int i, nflg, iyflg, yoddint;
- long e;
- volatile long double z=0;
- long double w=0, W=0, Wa=0, Wb=0, ya=0, yb=0, u=0;
+long double powl(long double x, long double y) {
+ /* double F, Fa, Fb, G, Ga, Gb, H, Ha, Hb */
+ int i, nflg, iyflg, yoddint;
+ long e;
+ volatile long double z = 0;
+ long double w = 0, W = 0, Wa = 0, Wb = 0, ya = 0, yb = 0, u = 0;
- /* make sure no invalid exception is raised by nan comparision */
- if (isnan(x)) {
- if (!isnan(y) && y == 0.0)
- return 1.0;
- return x;
- }
- if (isnan(y)) {
- if (x == 1.0)
- return 1.0;
- return y;
- }
- if (x == 1.0)
- return 1.0; /* 1**y = 1, even if y is nan */
- if (x == -1.0 && !isfinite(y))
- return 1.0; /* -1**inf = 1 */
- if (y == 0.0)
- return 1.0; /* x**0 = 1, even if x is nan */
- if (y == 1.0)
- return x;
- if (y >= LDBL_MAX) {
- if (x > 1.0 || x < -1.0)
- return INFINITY;
- if (x != 0.0)
- return 0.0;
- }
- if (y <= -LDBL_MAX) {
- if (x > 1.0 || x < -1.0)
- return 0.0;
- if (x != 0.0 || y == -INFINITY)
- return INFINITY;
- }
- if (x >= LDBL_MAX) {
- if (y > 0.0)
- return INFINITY;
- return 0.0;
- }
+ /* make sure no invalid exception is raised by nan comparision */
+ if (isnan(x)) {
+ if (!isnan(y) && y == 0.0)
+ return 1.0;
+ return x;
+ }
+ if (isnan(y)) {
+ if (x == 1.0)
+ return 1.0;
+ return y;
+ }
+ if (x == 1.0)
+ return 1.0; /* 1**y = 1, even if y is nan */
+ if (x == -1.0 && !isfinite(y))
+ return 1.0; /* -1**inf = 1 */
+ if (y == 0.0)
+ return 1.0; /* x**0 = 1, even if x is nan */
+ if (y == 1.0)
+ return x;
+ if (y >= LDBL_MAX) {
+ if (x > 1.0 || x < -1.0)
+ return INFINITY;
+ if (x != 0.0)
+ return 0.0;
+ }
+ if (y <= -LDBL_MAX) {
+ if (x > 1.0 || x < -1.0)
+ return 0.0;
+ if (x != 0.0 || y == -INFINITY)
+ return INFINITY;
+ }
+ if (x >= LDBL_MAX) {
+ if (y > 0.0)
+ return INFINITY;
+ return 0.0;
+ }
- w = floorl(y);
+ w = floorl(y);
- /* Set iyflg to 1 if y is an integer. */
- iyflg = 0;
- if (w == y)
- iyflg = 1;
+ /* Set iyflg to 1 if y is an integer. */
+ iyflg = 0;
+ if (w == y)
+ iyflg = 1;
- /* Test for odd integer y. */
- yoddint = 0;
- if (iyflg) {
- ya = fabsl(y);
- ya = floorl(0.5 * ya);
- yb = 0.5 * fabsl(w);
- if( ya != yb )
- yoddint = 1;
- }
+ /* Test for odd integer y. */
+ yoddint = 0;
+ if (iyflg) {
+ ya = fabsl(y);
+ ya = floorl(0.5 * ya);
+ yb = 0.5 * fabsl(w);
+ if (ya != yb)
+ yoddint = 1;
+ }
- if (x <= -LDBL_MAX) {
- if (y > 0.0) {
- if (yoddint)
- return -INFINITY;
- return INFINITY;
- }
- if (y < 0.0) {
- if (yoddint)
- return -0.0;
- return 0.0;
- }
- }
- nflg = 0; /* (x<0)**(odd int) */
- if (x <= 0.0) {
- if (x == 0.0) {
- if (y < 0.0) {
- if (signbit(x) && yoddint)
- /* (-0.0)**(-odd int) = -inf, divbyzero */
- return -1.0/0.0;
- /* (+-0.0)**(negative) = inf, divbyzero */
- return 1.0/0.0;
- }
- if (signbit(x) && yoddint)
- return -0.0;
- return 0.0;
- }
- if (iyflg == 0)
- return (x - x) / (x - x); /* (x<0)**(non-int) is NaN */
- /* (x<0)**(integer) */
- if (yoddint)
- nflg = 1; /* negate result */
- x = -x;
- }
- /* (+integer)**(integer) */
- if (iyflg && floorl(x) == x && fabsl(y) < 32768.0) {
- w = powil(x, (int)y);
- return nflg ? -w : w;
- }
+ if (x <= -LDBL_MAX) {
+ if (y > 0.0) {
+ if (yoddint)
+ return -INFINITY;
+ return INFINITY;
+ }
+ if (y < 0.0) {
+ if (yoddint)
+ return -0.0;
+ return 0.0;
+ }
+ }
+ nflg = 0; /* (x<0)**(odd int) */
+ if (x <= 0.0) {
+ if (x == 0.0) {
+ if (y < 0.0) {
+ if (signbit(x) && yoddint)
+ /* (-0.0)**(-odd int) = -inf, divbyzero */
+ return -1.0 / 0.0;
+ /* (+-0.0)**(negative) = inf, divbyzero */
+ return 1.0 / 0.0;
+ }
+ if (signbit(x) && yoddint)
+ return -0.0;
+ return 0.0;
+ }
+ if (iyflg == 0)
+ return (x - x) / (x - x); /* (x<0)**(non-int) is NaN */
+ /* (x<0)**(integer) */
+ if (yoddint)
+ nflg = 1; /* negate result */
+ x = -x;
+ }
+ /* (+integer)**(integer) */
+ if (iyflg && floorl(x) == x && fabsl(y) < 32768.0) {
+ w = powil(x, (int)y);
+ return nflg ? -w : w;
+ }
- /* separate significand from exponent */
- x = frexpl(x, &i);
- e = i;
+ /* separate significand from exponent */
+ x = frexpl(x, &i);
+ e = i;
- /* find significand in antilog table A[] */
- i = 1;
- if (x <= A[17])
- i = 17;
- if (x <= A[i+8])
- i += 8;
- if (x <= A[i+4])
- i += 4;
- if (x <= A[i+2])
- i += 2;
- if (x >= A[1])
- i = -1;
- i += 1;
+ /* find significand in antilog table A[] */
+ i = 1;
+ if (x <= A[17])
+ i = 17;
+ if (x <= A[i + 8])
+ i += 8;
+ if (x <= A[i + 4])
+ i += 4;
+ if (x <= A[i + 2])
+ i += 2;
+ if (x >= A[1])
+ i = -1;
+ i += 1;
- /* Find (x - A[i])/A[i]
- * in order to compute log(x/A[i]):
- *
- * log(x) = log( a x/a ) = log(a) + log(x/a)
- *
- * log(x/a) = log(1+v), v = x/a - 1 = (x-a)/a
- */
- x -= A[i];
- x -= B[i/2];
- x /= A[i];
+ /* Find (x - A[i])/A[i]
+ * in order to compute log(x/A[i]):
+ *
+ * log(x) = log( a x/a ) = log(a) + log(x/a)
+ *
+ * log(x/a) = log(1+v), v = x/a - 1 = (x-a)/a
+ */
+ x -= A[i];
+ x -= B[i / 2];
+ x /= A[i];
- /* rational approximation for log(1+v):
- *
- * log(1+v) = v - v**2/2 + v**3 P(v) / Q(v)
- */
- z = x*x;
- w = x * (z * __polevll(x, P, 3) / __p1evll(x, Q, 3));
- w = w - 0.5*z;
+ /* rational approximation for log(1+v):
+ *
+ * log(1+v) = v - v**2/2 + v**3 P(v) / Q(v)
+ */
+ z = x * x;
+ w = x * (z * __polevll(x, P, 3) / __p1evll(x, Q, 3));
+ w = w - 0.5 * z;
- /* Convert to base 2 logarithm:
- * multiply by log2(e) = 1 + LOG2EA
- */
- z = LOG2EA * w;
- z += w;
- z += LOG2EA * x;
- z += x;
+ /* Convert to base 2 logarithm:
+ * multiply by log2(e) = 1 + LOG2EA
+ */
+ z = LOG2EA * w;
+ z += w;
+ z += LOG2EA * x;
+ z += x;
- /* Compute exponent term of the base 2 logarithm. */
- w = -i;
- w /= NXT;
- w += e;
- /* Now base 2 log of x is w + z. */
+ /* Compute exponent term of the base 2 logarithm. */
+ w = -i;
+ w /= NXT;
+ w += e;
+ /* Now base 2 log of x is w + z. */
- /* Multiply base 2 log by y, in extended precision. */
+ /* Multiply base 2 log by y, in extended precision. */
- /* separate y into large part ya
- * and small part yb less than 1/NXT
- */
- ya = reducl(y);
- yb = y - ya;
+ /* separate y into large part ya
+ * and small part yb less than 1/NXT
+ */
+ ya = reducl(y);
+ yb = y - ya;
- /* (w+z)(ya+yb)
- * = w*ya + w*yb + z*y
- */
- F = z * y + w * yb;
- Fa = reducl(F);
- Fb = F - Fa;
+ /* (w+z)(ya+yb)
+ * = w*ya + w*yb + z*y
+ */
+ F = z * y + w * yb;
+ Fa = reducl(F);
+ Fb = F - Fa;
- G = Fa + w * ya;
- Ga = reducl(G);
- Gb = G - Ga;
+ G = Fa + w * ya;
+ Ga = reducl(G);
+ Gb = G - Ga;
- H = Fb + Gb;
- Ha = reducl(H);
- w = (Ga + Ha) * NXT;
+ H = Fb + Gb;
+ Ha = reducl(H);
+ w = (Ga + Ha) * NXT;
- /* Test the power of 2 for overflow */
- if (w > MEXP)
- return huge * huge; /* overflow */
- if (w < MNEXP)
- return twom10000 * twom10000; /* underflow */
+ /* Test the power of 2 for overflow */
+ if (w > MEXP)
+ return huge * huge; /* overflow */
+ if (w < MNEXP)
+ return twom10000 * twom10000; /* underflow */
- e = w;
- Hb = H - Ha;
+ e = w;
+ Hb = H - Ha;
- if (Hb > 0.0) {
- e += 1;
- Hb -= 1.0/NXT; /*0.0625L;*/
- }
+ if (Hb > 0.0) {
+ e += 1;
+ Hb -= 1.0 / NXT; /*0.0625L;*/
+ }
- /* Now the product y * log2(x) = Hb + e/NXT.
- *
- * Compute base 2 exponential of Hb,
- * where -0.0625 <= Hb <= 0.
- */
- z = Hb * __polevll(Hb, R, 6); /* z = 2**Hb - 1 */
+ /* Now the product y * log2(x) = Hb + e/NXT.
+ *
+ * Compute base 2 exponential of Hb,
+ * where -0.0625 <= Hb <= 0.
+ */
+ z = Hb * __polevll(Hb, R, 6); /* z = 2**Hb - 1 */
- /* Express e/NXT as an integer plus a negative number of (1/NXT)ths.
- * Find lookup table entry for the fractional power of 2.
- */
- if (e < 0)
- i = 0;
- else
- i = 1;
- i = e/NXT + i;
- e = NXT*i - e;
- w = A[e];
- z = w * z; /* 2**-e * ( 1 + (2**Hb-1) ) */
- z = z + w;
- z = scalbnl(z, i); /* multiply by integer power of 2 */
+ /* Express e/NXT as an integer plus a negative number of (1/NXT)ths.
+ * Find lookup table entry for the fractional power of 2.
+ */
+ if (e < 0)
+ i = 0;
+ else
+ i = 1;
+ i = e / NXT + i;
+ e = NXT * i - e;
+ w = A[e];
+ z = w * z; /* 2**-e * ( 1 + (2**Hb-1) ) */
+ z = z + w;
+ z = scalbnl(z, i); /* multiply by integer power of 2 */
- if (nflg)
- z = -z;
- return z;
+ if (nflg)
+ z = -z;
+ return z;
}
-
/* Find a multiple of 1/NXT that is within 1/NXT of x. */
-static long double reducl(long double x)
-{
- long double t;
+static long double reducl(long double x) {
+ long double t;
- t = x * NXT;
- t = floorl(t);
- t = t / NXT;
- return t;
+ t = x * NXT;
+ t = floorl(t);
+ t = t / NXT;
+ return t;
}
/*
@@ -450,73 +416,71 @@
* Returns MAXNUM on overflow, zero on underflow.
*/
-static long double powil(long double x, int nn)
-{
- long double ww, y;
- long double s;
- int n, e, sign, lx;
+static long double powil(long double x, int nn) {
+ long double ww, y;
+ long double s;
+ int n, e, sign, lx;
- if (nn == 0)
- return 1.0;
+ if (nn == 0)
+ return 1.0;
- if (nn < 0) {
- sign = -1;
- n = -nn;
- } else {
- sign = 1;
- n = nn;
- }
+ if (nn < 0) {
+ sign = -1;
+ n = -nn;
+ } else {
+ sign = 1;
+ n = nn;
+ }
- /* Overflow detection */
+ /* Overflow detection */
- /* Calculate approximate logarithm of answer */
- s = x;
- s = frexpl( s, &lx);
- e = (lx - 1)*n;
- if ((e == 0) || (e > 64) || (e < -64)) {
- s = (s - 7.0710678118654752e-1L) / (s + 7.0710678118654752e-1L);
- s = (2.9142135623730950L * s - 0.5 + lx) * nn * LOGE2L;
- } else {
- s = LOGE2L * e;
- }
+ /* Calculate approximate logarithm of answer */
+ s = x;
+ s = frexpl(s, &lx);
+ e = (lx - 1) * n;
+ if ((e == 0) || (e > 64) || (e < -64)) {
+ s = (s - 7.0710678118654752e-1L) / (s + 7.0710678118654752e-1L);
+ s = (2.9142135623730950L * s - 0.5 + lx) * nn * LOGE2L;
+ } else {
+ s = LOGE2L * e;
+ }
- if (s > MAXLOGL)
- return huge * huge; /* overflow */
+ if (s > MAXLOGL)
+ return huge * huge; /* overflow */
- if (s < MINLOGL)
- return twom10000 * twom10000; /* underflow */
- /* Handle tiny denormal answer, but with less accuracy
- * since roundoff error in 1.0/x will be amplified.
- * The precise demarcation should be the gradual underflow threshold.
- */
- if (s < -MAXLOGL+2.0) {
- x = 1.0/x;
- sign = -sign;
- }
+ if (s < MINLOGL)
+ return twom10000 * twom10000; /* underflow */
+ /* Handle tiny denormal answer, but with less accuracy
+ * since roundoff error in 1.0/x will be amplified.
+ * The precise demarcation should be the gradual underflow threshold.
+ */
+ if (s < -MAXLOGL + 2.0) {
+ x = 1.0 / x;
+ sign = -sign;
+ }
- /* First bit of the power */
- if (n & 1)
- y = x;
- else
- y = 1.0;
+ /* First bit of the power */
+ if (n & 1)
+ y = x;
+ else
+ y = 1.0;
- ww = x;
- n >>= 1;
- while (n) {
- ww = ww * ww; /* arg to the 2-to-the-kth power */
- if (n & 1) /* if that bit is set, then include in product */
- y *= ww;
- n >>= 1;
- }
+ ww = x;
+ n >>= 1;
+ while (n) {
+ ww = ww * ww; /* arg to the 2-to-the-kth power */
+ if (n & 1) /* if that bit is set, then include in product */
+ y *= ww;
+ n >>= 1;
+ }
- if (sign < 0)
- y = 1.0/y;
- return y;
+ if (sign < 0)
+ y = 1.0 / y;
+ return y;
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
// TODO: broken implementation to make things compile
-long double powl(long double x, long double y)
-{
- return pow(x, y);
+long double powl(long double x, long double y) {
+ return pow(x, y);
}
#endif
diff --git a/fusl/src/math/remainder.c b/fusl/src/math/remainder.c
index 6cd089c..ac85ee7 100644
--- a/fusl/src/math/remainder.c
+++ b/fusl/src/math/remainder.c
@@ -1,10 +1,9 @@
#include <math.h>
#include "libc.h"
-double remainder(double x, double y)
-{
- int q;
- return remquo(x, y, &q);
+double remainder(double x, double y) {
+ int q;
+ return remquo(x, y, &q);
}
weak_alias(remainder, drem);
diff --git a/fusl/src/math/remainderf.c b/fusl/src/math/remainderf.c
index 420d3bf..e336961 100644
--- a/fusl/src/math/remainderf.c
+++ b/fusl/src/math/remainderf.c
@@ -1,10 +1,9 @@
#include <math.h>
#include "libc.h"
-float remainderf(float x, float y)
-{
- int q;
- return remquof(x, y, &q);
+float remainderf(float x, float y) {
+ int q;
+ return remquof(x, y, &q);
}
weak_alias(remainderf, dremf);
diff --git a/fusl/src/math/remainderl.c b/fusl/src/math/remainderl.c
index 2a13c1d..039926c 100644
--- a/fusl/src/math/remainderl.c
+++ b/fusl/src/math/remainderl.c
@@ -2,14 +2,12 @@
#include <float.h>
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double remainderl(long double x, long double y)
-{
- return remainder(x, y);
+long double remainderl(long double x, long double y) {
+ return remainder(x, y);
}
#else
-long double remainderl(long double x, long double y)
-{
- int q;
- return remquol(x, y, &q);
+long double remainderl(long double x, long double y) {
+ int q;
+ return remquol(x, y, &q);
}
#endif
diff --git a/fusl/src/math/remquo.c b/fusl/src/math/remquo.c
index 59d5ad5..9436d29 100644
--- a/fusl/src/math/remquo.c
+++ b/fusl/src/math/remquo.c
@@ -1,82 +1,87 @@
#include <math.h>
#include <stdint.h>
-double remquo(double x, double y, int *quo)
-{
- union {double f; uint64_t i;} ux = {x}, uy = {y};
- int ex = ux.i>>52 & 0x7ff;
- int ey = uy.i>>52 & 0x7ff;
- int sx = ux.i>>63;
- int sy = uy.i>>63;
- uint32_t q;
- uint64_t i;
- uint64_t uxi = ux.i;
+double remquo(double x, double y, int* quo) {
+ union {
+ double f;
+ uint64_t i;
+ } ux = {x}, uy = {y};
+ int ex = ux.i >> 52 & 0x7ff;
+ int ey = uy.i >> 52 & 0x7ff;
+ int sx = ux.i >> 63;
+ int sy = uy.i >> 63;
+ uint32_t q;
+ uint64_t i;
+ uint64_t uxi = ux.i;
- *quo = 0;
- if (uy.i<<1 == 0 || isnan(y) || ex == 0x7ff)
- return (x*y)/(x*y);
- if (ux.i<<1 == 0)
- return x;
+ *quo = 0;
+ if (uy.i << 1 == 0 || isnan(y) || ex == 0x7ff)
+ return (x * y) / (x * y);
+ if (ux.i << 1 == 0)
+ return x;
- /* normalize x and y */
- if (!ex) {
- for (i = uxi<<12; i>>63 == 0; ex--, i <<= 1);
- uxi <<= -ex + 1;
- } else {
- uxi &= -1ULL >> 12;
- uxi |= 1ULL << 52;
- }
- if (!ey) {
- for (i = uy.i<<12; i>>63 == 0; ey--, i <<= 1);
- uy.i <<= -ey + 1;
- } else {
- uy.i &= -1ULL >> 12;
- uy.i |= 1ULL << 52;
- }
+ /* normalize x and y */
+ if (!ex) {
+ for (i = uxi << 12; i >> 63 == 0; ex--, i <<= 1)
+ ;
+ uxi <<= -ex + 1;
+ } else {
+ uxi &= -1ULL >> 12;
+ uxi |= 1ULL << 52;
+ }
+ if (!ey) {
+ for (i = uy.i << 12; i >> 63 == 0; ey--, i <<= 1)
+ ;
+ uy.i <<= -ey + 1;
+ } else {
+ uy.i &= -1ULL >> 12;
+ uy.i |= 1ULL << 52;
+ }
- q = 0;
- if (ex < ey) {
- if (ex+1 == ey)
- goto end;
- return x;
- }
+ q = 0;
+ if (ex < ey) {
+ if (ex + 1 == ey)
+ goto end;
+ return x;
+ }
- /* x mod y */
- for (; ex > ey; ex--) {
- i = uxi - uy.i;
- if (i >> 63 == 0) {
- uxi = i;
- q++;
- }
- uxi <<= 1;
- q <<= 1;
- }
- i = uxi - uy.i;
- if (i >> 63 == 0) {
- uxi = i;
- q++;
- }
- if (uxi == 0)
- ex = -60;
- else
- for (; uxi>>52 == 0; uxi <<= 1, ex--);
+ /* x mod y */
+ for (; ex > ey; ex--) {
+ i = uxi - uy.i;
+ if (i >> 63 == 0) {
+ uxi = i;
+ q++;
+ }
+ uxi <<= 1;
+ q <<= 1;
+ }
+ i = uxi - uy.i;
+ if (i >> 63 == 0) {
+ uxi = i;
+ q++;
+ }
+ if (uxi == 0)
+ ex = -60;
+ else
+ for (; uxi >> 52 == 0; uxi <<= 1, ex--)
+ ;
end:
- /* scale result and decide between |x| and |x|-|y| */
- if (ex > 0) {
- uxi -= 1ULL << 52;
- uxi |= (uint64_t)ex << 52;
- } else {
- uxi >>= -ex + 1;
- }
- ux.i = uxi;
- x = ux.f;
- if (sy)
- y = -y;
- if (ex == ey || (ex+1 == ey && (2*x > y || (2*x == y && q%2)))) {
- x -= y;
- q++;
- }
- q &= 0x7fffffff;
- *quo = sx^sy ? -(int)q : (int)q;
- return sx ? -x : x;
+ /* scale result and decide between |x| and |x|-|y| */
+ if (ex > 0) {
+ uxi -= 1ULL << 52;
+ uxi |= (uint64_t)ex << 52;
+ } else {
+ uxi >>= -ex + 1;
+ }
+ ux.i = uxi;
+ x = ux.f;
+ if (sy)
+ y = -y;
+ if (ex == ey || (ex + 1 == ey && (2 * x > y || (2 * x == y && q % 2)))) {
+ x -= y;
+ q++;
+ }
+ q &= 0x7fffffff;
+ *quo = sx ^ sy ? -(int)q : (int)q;
+ return sx ? -x : x;
}
diff --git a/fusl/src/math/remquof.c b/fusl/src/math/remquof.c
index 2f41ff7..0725096 100644
--- a/fusl/src/math/remquof.c
+++ b/fusl/src/math/remquof.c
@@ -1,82 +1,87 @@
#include <math.h>
#include <stdint.h>
-float remquof(float x, float y, int *quo)
-{
- union {float f; uint32_t i;} ux = {x}, uy = {y};
- int ex = ux.i>>23 & 0xff;
- int ey = uy.i>>23 & 0xff;
- int sx = ux.i>>31;
- int sy = uy.i>>31;
- uint32_t q;
- uint32_t i;
- uint32_t uxi = ux.i;
+float remquof(float x, float y, int* quo) {
+ union {
+ float f;
+ uint32_t i;
+ } ux = {x}, uy = {y};
+ int ex = ux.i >> 23 & 0xff;
+ int ey = uy.i >> 23 & 0xff;
+ int sx = ux.i >> 31;
+ int sy = uy.i >> 31;
+ uint32_t q;
+ uint32_t i;
+ uint32_t uxi = ux.i;
- *quo = 0;
- if (uy.i<<1 == 0 || isnan(y) || ex == 0xff)
- return (x*y)/(x*y);
- if (ux.i<<1 == 0)
- return x;
+ *quo = 0;
+ if (uy.i << 1 == 0 || isnan(y) || ex == 0xff)
+ return (x * y) / (x * y);
+ if (ux.i << 1 == 0)
+ return x;
- /* normalize x and y */
- if (!ex) {
- for (i = uxi<<9; i>>31 == 0; ex--, i <<= 1);
- uxi <<= -ex + 1;
- } else {
- uxi &= -1U >> 9;
- uxi |= 1U << 23;
- }
- if (!ey) {
- for (i = uy.i<<9; i>>31 == 0; ey--, i <<= 1);
- uy.i <<= -ey + 1;
- } else {
- uy.i &= -1U >> 9;
- uy.i |= 1U << 23;
- }
+ /* normalize x and y */
+ if (!ex) {
+ for (i = uxi << 9; i >> 31 == 0; ex--, i <<= 1)
+ ;
+ uxi <<= -ex + 1;
+ } else {
+ uxi &= -1U >> 9;
+ uxi |= 1U << 23;
+ }
+ if (!ey) {
+ for (i = uy.i << 9; i >> 31 == 0; ey--, i <<= 1)
+ ;
+ uy.i <<= -ey + 1;
+ } else {
+ uy.i &= -1U >> 9;
+ uy.i |= 1U << 23;
+ }
- q = 0;
- if (ex < ey) {
- if (ex+1 == ey)
- goto end;
- return x;
- }
+ q = 0;
+ if (ex < ey) {
+ if (ex + 1 == ey)
+ goto end;
+ return x;
+ }
- /* x mod y */
- for (; ex > ey; ex--) {
- i = uxi - uy.i;
- if (i >> 31 == 0) {
- uxi = i;
- q++;
- }
- uxi <<= 1;
- q <<= 1;
- }
- i = uxi - uy.i;
- if (i >> 31 == 0) {
- uxi = i;
- q++;
- }
- if (uxi == 0)
- ex = -30;
- else
- for (; uxi>>23 == 0; uxi <<= 1, ex--);
+ /* x mod y */
+ for (; ex > ey; ex--) {
+ i = uxi - uy.i;
+ if (i >> 31 == 0) {
+ uxi = i;
+ q++;
+ }
+ uxi <<= 1;
+ q <<= 1;
+ }
+ i = uxi - uy.i;
+ if (i >> 31 == 0) {
+ uxi = i;
+ q++;
+ }
+ if (uxi == 0)
+ ex = -30;
+ else
+ for (; uxi >> 23 == 0; uxi <<= 1, ex--)
+ ;
end:
- /* scale result and decide between |x| and |x|-|y| */
- if (ex > 0) {
- uxi -= 1U << 23;
- uxi |= (uint32_t)ex << 23;
- } else {
- uxi >>= -ex + 1;
- }
- ux.i = uxi;
- x = ux.f;
- if (sy)
- y = -y;
- if (ex == ey || (ex+1 == ey && (2*x > y || (2*x == y && q%2)))) {
- x -= y;
- q++;
- }
- q &= 0x7fffffff;
- *quo = sx^sy ? -(int)q : (int)q;
- return sx ? -x : x;
+ /* scale result and decide between |x| and |x|-|y| */
+ if (ex > 0) {
+ uxi -= 1U << 23;
+ uxi |= (uint32_t)ex << 23;
+ } else {
+ uxi >>= -ex + 1;
+ }
+ ux.i = uxi;
+ x = ux.f;
+ if (sy)
+ y = -y;
+ if (ex == ey || (ex + 1 == ey && (2 * x > y || (2 * x == y && q % 2)))) {
+ x -= y;
+ q++;
+ }
+ q &= 0x7fffffff;
+ *quo = sx ^ sy ? -(int)q : (int)q;
+ return sx ? -x : x;
}
diff --git a/fusl/src/math/remquol.c b/fusl/src/math/remquol.c
index 9b065c0..d4cf47f 100644
--- a/fusl/src/math/remquol.c
+++ b/fusl/src/math/remquol.c
@@ -1,124 +1,124 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double remquol(long double x, long double y, int *quo)
-{
- return remquo(x, y, quo);
+long double remquol(long double x, long double y, int* quo) {
+ return remquo(x, y, quo);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-long double remquol(long double x, long double y, int *quo)
-{
- union ldshape ux = {x}, uy = {y};
- int ex = ux.i.se & 0x7fff;
- int ey = uy.i.se & 0x7fff;
- int sx = ux.i.se >> 15;
- int sy = uy.i.se >> 15;
- uint32_t q;
+long double remquol(long double x, long double y, int* quo) {
+ union ldshape ux = {x}, uy = {y};
+ int ex = ux.i.se & 0x7fff;
+ int ey = uy.i.se & 0x7fff;
+ int sx = ux.i.se >> 15;
+ int sy = uy.i.se >> 15;
+ uint32_t q;
- *quo = 0;
- if (y == 0 || isnan(y) || ex == 0x7fff)
- return (x*y)/(x*y);
- if (x == 0)
- return x;
+ *quo = 0;
+ if (y == 0 || isnan(y) || ex == 0x7fff)
+ return (x * y) / (x * y);
+ if (x == 0)
+ return x;
- /* normalize x and y */
- if (!ex) {
- ux.i.se = ex;
- ux.f *= 0x1p120f;
- ex = ux.i.se - 120;
- }
- if (!ey) {
- uy.i.se = ey;
- uy.f *= 0x1p120f;
- ey = uy.i.se - 120;
- }
+ /* normalize x and y */
+ if (!ex) {
+ ux.i.se = ex;
+ ux.f *= 0x1p120f;
+ ex = ux.i.se - 120;
+ }
+ if (!ey) {
+ uy.i.se = ey;
+ uy.f *= 0x1p120f;
+ ey = uy.i.se - 120;
+ }
- q = 0;
- if (ex >= ey) {
- /* x mod y */
+ q = 0;
+ if (ex >= ey) {
+/* x mod y */
#if LDBL_MANT_DIG == 64
- uint64_t i, mx, my;
- mx = ux.i.m;
- my = uy.i.m;
- for (; ex > ey; ex--) {
- i = mx - my;
- if (mx >= my) {
- mx = 2*i;
- q++;
- q <<= 1;
- } else if (2*mx < mx) {
- mx = 2*mx - my;
- q <<= 1;
- q++;
- } else {
- mx = 2*mx;
- q <<= 1;
- }
- }
- i = mx - my;
- if (mx >= my) {
- mx = i;
- q++;
- }
- if (mx == 0)
- ex = -120;
- else
- for (; mx >> 63 == 0; mx *= 2, ex--);
- ux.i.m = mx;
+ uint64_t i, mx, my;
+ mx = ux.i.m;
+ my = uy.i.m;
+ for (; ex > ey; ex--) {
+ i = mx - my;
+ if (mx >= my) {
+ mx = 2 * i;
+ q++;
+ q <<= 1;
+ } else if (2 * mx < mx) {
+ mx = 2 * mx - my;
+ q <<= 1;
+ q++;
+ } else {
+ mx = 2 * mx;
+ q <<= 1;
+ }
+ }
+ i = mx - my;
+ if (mx >= my) {
+ mx = i;
+ q++;
+ }
+ if (mx == 0)
+ ex = -120;
+ else
+ for (; mx >> 63 == 0; mx *= 2, ex--)
+ ;
+ ux.i.m = mx;
#elif LDBL_MANT_DIG == 113
- uint64_t hi, lo, xhi, xlo, yhi, ylo;
- xhi = (ux.i2.hi & -1ULL>>16) | 1ULL<<48;
- yhi = (uy.i2.hi & -1ULL>>16) | 1ULL<<48;
- xlo = ux.i2.lo;
- ylo = ux.i2.lo;
- for (; ex > ey; ex--) {
- hi = xhi - yhi;
- lo = xlo - ylo;
- if (xlo < ylo)
- hi -= 1;
- if (hi >> 63 == 0) {
- xhi = 2*hi + (lo>>63);
- xlo = 2*lo;
- q++;
- } else {
- xhi = 2*xhi + (xlo>>63);
- xlo = 2*xlo;
- }
- q <<= 1;
- }
- hi = xhi - yhi;
- lo = xlo - ylo;
- if (xlo < ylo)
- hi -= 1;
- if (hi >> 63 == 0) {
- xhi = hi;
- xlo = lo;
- q++;
- }
- if ((xhi|xlo) == 0)
- ex = -120;
- else
- for (; xhi >> 48 == 0; xhi = 2*xhi + (xlo>>63), xlo = 2*xlo, ex--);
- ux.i2.hi = xhi;
- ux.i2.lo = xlo;
+ uint64_t hi, lo, xhi, xlo, yhi, ylo;
+ xhi = (ux.i2.hi & -1ULL >> 16) | 1ULL << 48;
+ yhi = (uy.i2.hi & -1ULL >> 16) | 1ULL << 48;
+ xlo = ux.i2.lo;
+ ylo = ux.i2.lo;
+ for (; ex > ey; ex--) {
+ hi = xhi - yhi;
+ lo = xlo - ylo;
+ if (xlo < ylo)
+ hi -= 1;
+ if (hi >> 63 == 0) {
+ xhi = 2 * hi + (lo >> 63);
+ xlo = 2 * lo;
+ q++;
+ } else {
+ xhi = 2 * xhi + (xlo >> 63);
+ xlo = 2 * xlo;
+ }
+ q <<= 1;
+ }
+ hi = xhi - yhi;
+ lo = xlo - ylo;
+ if (xlo < ylo)
+ hi -= 1;
+ if (hi >> 63 == 0) {
+ xhi = hi;
+ xlo = lo;
+ q++;
+ }
+ if ((xhi | xlo) == 0)
+ ex = -120;
+ else
+ for (; xhi >> 48 == 0; xhi = 2 * xhi + (xlo >> 63), xlo = 2 * xlo, ex--)
+ ;
+ ux.i2.hi = xhi;
+ ux.i2.lo = xlo;
#endif
- }
+ }
- /* scale result and decide between |x| and |x|-|y| */
- if (ex <= 0) {
- ux.i.se = ex + 120;
- ux.f *= 0x1p-120f;
- } else
- ux.i.se = ex;
- x = ux.f;
- if (sy)
- y = -y;
- if (ex == ey || (ex+1 == ey && (2*x > y || (2*x == y && q%2)))) {
- x -= y;
- q++;
- }
- q &= 0x7fffffff;
- *quo = sx^sy ? -(int)q : (int)q;
- return sx ? -x : x;
+ /* scale result and decide between |x| and |x|-|y| */
+ if (ex <= 0) {
+ ux.i.se = ex + 120;
+ ux.f *= 0x1p-120f;
+ } else
+ ux.i.se = ex;
+ x = ux.f;
+ if (sy)
+ y = -y;
+ if (ex == ey || (ex + 1 == ey && (2 * x > y || (2 * x == y && q % 2)))) {
+ x -= y;
+ q++;
+ }
+ q &= 0x7fffffff;
+ *quo = sx ^ sy ? -(int)q : (int)q;
+ return sx ? -x : x;
}
#endif
diff --git a/fusl/src/math/rint.c b/fusl/src/math/rint.c
index fbba390..8d2447e 100644
--- a/fusl/src/math/rint.c
+++ b/fusl/src/math/rint.c
@@ -2,27 +2,29 @@
#include <math.h>
#include <stdint.h>
-#if FLT_EVAL_METHOD==0 || FLT_EVAL_METHOD==1
+#if FLT_EVAL_METHOD == 0 || FLT_EVAL_METHOD == 1
#define EPS DBL_EPSILON
-#elif FLT_EVAL_METHOD==2
+#elif FLT_EVAL_METHOD == 2
#define EPS LDBL_EPSILON
#endif
-static const double_t toint = 1/EPS;
+static const double_t toint = 1 / EPS;
-double rint(double x)
-{
- union {double f; uint64_t i;} u = {x};
- int e = u.i>>52 & 0x7ff;
- int s = u.i>>63;
- double_t y;
+double rint(double x) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {x};
+ int e = u.i >> 52 & 0x7ff;
+ int s = u.i >> 63;
+ double_t y;
- if (e >= 0x3ff+52)
- return x;
- if (s)
- y = x - toint + toint;
- else
- y = x + toint - toint;
- if (y == 0)
- return s ? -0.0 : 0;
- return y;
+ if (e >= 0x3ff + 52)
+ return x;
+ if (s)
+ y = x - toint + toint;
+ else
+ y = x + toint - toint;
+ if (y == 0)
+ return s ? -0.0 : 0;
+ return y;
}
diff --git a/fusl/src/math/rintf.c b/fusl/src/math/rintf.c
index 9047688..0ed0ecc 100644
--- a/fusl/src/math/rintf.c
+++ b/fusl/src/math/rintf.c
@@ -2,29 +2,31 @@
#include <math.h>
#include <stdint.h>
-#if FLT_EVAL_METHOD==0
+#if FLT_EVAL_METHOD == 0
#define EPS FLT_EPSILON
-#elif FLT_EVAL_METHOD==1
+#elif FLT_EVAL_METHOD == 1
#define EPS DBL_EPSILON
-#elif FLT_EVAL_METHOD==2
+#elif FLT_EVAL_METHOD == 2
#define EPS LDBL_EPSILON
#endif
-static const float_t toint = 1/EPS;
+static const float_t toint = 1 / EPS;
-float rintf(float x)
-{
- union {float f; uint32_t i;} u = {x};
- int e = u.i>>23 & 0xff;
- int s = u.i>>31;
- float_t y;
+float rintf(float x) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {x};
+ int e = u.i >> 23 & 0xff;
+ int s = u.i >> 31;
+ float_t y;
- if (e >= 0x7f+23)
- return x;
- if (s)
- y = x - toint + toint;
- else
- y = x + toint - toint;
- if (y == 0)
- return s ? -0.0f : 0.0f;
- return y;
+ if (e >= 0x7f + 23)
+ return x;
+ if (s)
+ y = x - toint + toint;
+ else
+ y = x + toint - toint;
+ if (y == 0)
+ return s ? -0.0f : 0.0f;
+ return y;
}
diff --git a/fusl/src/math/rintl.c b/fusl/src/math/rintl.c
index 374327d..e5b5267 100644
--- a/fusl/src/math/rintl.c
+++ b/fusl/src/math/rintl.c
@@ -1,29 +1,27 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double rintl(long double x)
-{
- return rint(x);
+long double rintl(long double x) {
+ return rint(x);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-static const long double toint = 1/LDBL_EPSILON;
+static const long double toint = 1 / LDBL_EPSILON;
-long double rintl(long double x)
-{
- union ldshape u = {x};
- int e = u.i.se & 0x7fff;
- int s = u.i.se >> 15;
- long double y;
+long double rintl(long double x) {
+ union ldshape u = {x};
+ int e = u.i.se & 0x7fff;
+ int s = u.i.se >> 15;
+ long double y;
- if (e >= 0x3fff+LDBL_MANT_DIG-1)
- return x;
- if (s)
- y = x - toint + toint;
- else
- y = x + toint - toint;
- if (y == 0)
- return 0*x;
- return y;
+ if (e >= 0x3fff + LDBL_MANT_DIG - 1)
+ return x;
+ if (s)
+ y = x - toint + toint;
+ else
+ y = x + toint - toint;
+ if (y == 0)
+ return 0 * x;
+ return y;
}
#endif
diff --git a/fusl/src/math/round.c b/fusl/src/math/round.c
index 130d58d..ad1baa8 100644
--- a/fusl/src/math/round.c
+++ b/fusl/src/math/round.c
@@ -1,35 +1,37 @@
#include "libm.h"
-#if FLT_EVAL_METHOD==0 || FLT_EVAL_METHOD==1
+#if FLT_EVAL_METHOD == 0 || FLT_EVAL_METHOD == 1
#define EPS DBL_EPSILON
-#elif FLT_EVAL_METHOD==2
+#elif FLT_EVAL_METHOD == 2
#define EPS LDBL_EPSILON
#endif
-static const double_t toint = 1/EPS;
+static const double_t toint = 1 / EPS;
-double round(double x)
-{
- union {double f; uint64_t i;} u = {x};
- int e = u.i >> 52 & 0x7ff;
- double_t y;
+double round(double x) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {x};
+ int e = u.i >> 52 & 0x7ff;
+ double_t y;
- if (e >= 0x3ff+52)
- return x;
- if (u.i >> 63)
- x = -x;
- if (e < 0x3ff-1) {
- /* raise inexact if x!=0 */
- FORCE_EVAL(x + toint);
- return 0*u.f;
- }
- y = x + toint - toint - x;
- if (y > 0.5)
- y = y + x - 1;
- else if (y <= -0.5)
- y = y + x + 1;
- else
- y = y + x;
- if (u.i >> 63)
- y = -y;
- return y;
+ if (e >= 0x3ff + 52)
+ return x;
+ if (u.i >> 63)
+ x = -x;
+ if (e < 0x3ff - 1) {
+ /* raise inexact if x!=0 */
+ FORCE_EVAL(x + toint);
+ return 0 * u.f;
+ }
+ y = x + toint - toint - x;
+ if (y > 0.5)
+ y = y + x - 1;
+ else if (y <= -0.5)
+ y = y + x + 1;
+ else
+ y = y + x;
+ if (u.i >> 63)
+ y = -y;
+ return y;
}
diff --git a/fusl/src/math/roundf.c b/fusl/src/math/roundf.c
index e8210af..55a38dd 100644
--- a/fusl/src/math/roundf.c
+++ b/fusl/src/math/roundf.c
@@ -1,36 +1,38 @@
#include "libm.h"
-#if FLT_EVAL_METHOD==0
+#if FLT_EVAL_METHOD == 0
#define EPS FLT_EPSILON
-#elif FLT_EVAL_METHOD==1
+#elif FLT_EVAL_METHOD == 1
#define EPS DBL_EPSILON
-#elif FLT_EVAL_METHOD==2
+#elif FLT_EVAL_METHOD == 2
#define EPS LDBL_EPSILON
#endif
-static const float_t toint = 1/EPS;
+static const float_t toint = 1 / EPS;
-float roundf(float x)
-{
- union {float f; uint32_t i;} u = {x};
- int e = u.i >> 23 & 0xff;
- float_t y;
+float roundf(float x) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {x};
+ int e = u.i >> 23 & 0xff;
+ float_t y;
- if (e >= 0x7f+23)
- return x;
- if (u.i >> 31)
- x = -x;
- if (e < 0x7f-1) {
- FORCE_EVAL(x + toint);
- return 0*u.f;
- }
- y = x + toint - toint - x;
- if (y > 0.5f)
- y = y + x - 1;
- else if (y <= -0.5f)
- y = y + x + 1;
- else
- y = y + x;
- if (u.i >> 31)
- y = -y;
- return y;
+ if (e >= 0x7f + 23)
+ return x;
+ if (u.i >> 31)
+ x = -x;
+ if (e < 0x7f - 1) {
+ FORCE_EVAL(x + toint);
+ return 0 * u.f;
+ }
+ y = x + toint - toint - x;
+ if (y > 0.5f)
+ y = y + x - 1;
+ else if (y <= -0.5f)
+ y = y + x + 1;
+ else
+ y = y + x;
+ if (u.i >> 31)
+ y = -y;
+ return y;
}
diff --git a/fusl/src/math/roundl.c b/fusl/src/math/roundl.c
index f4ff682..adb580a 100644
--- a/fusl/src/math/roundl.c
+++ b/fusl/src/math/roundl.c
@@ -1,37 +1,35 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double roundl(long double x)
-{
- return round(x);
+long double roundl(long double x) {
+ return round(x);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-static const long double toint = 1/LDBL_EPSILON;
+static const long double toint = 1 / LDBL_EPSILON;
-long double roundl(long double x)
-{
- union ldshape u = {x};
- int e = u.i.se & 0x7fff;
- long double y;
+long double roundl(long double x) {
+ union ldshape u = {x};
+ int e = u.i.se & 0x7fff;
+ long double y;
- if (e >= 0x3fff+LDBL_MANT_DIG-1)
- return x;
- if (u.i.se >> 15)
- x = -x;
- if (e < 0x3fff-1) {
- FORCE_EVAL(x + toint);
- return 0*u.f;
- }
- y = x + toint - toint - x;
- if (y > 0.5)
- y = y + x - 1;
- else if (y <= -0.5)
- y = y + x + 1;
- else
- y = y + x;
- if (u.i.se >> 15)
- y = -y;
- return y;
+ if (e >= 0x3fff + LDBL_MANT_DIG - 1)
+ return x;
+ if (u.i.se >> 15)
+ x = -x;
+ if (e < 0x3fff - 1) {
+ FORCE_EVAL(x + toint);
+ return 0 * u.f;
+ }
+ y = x + toint - toint - x;
+ if (y > 0.5)
+ y = y + x - 1;
+ else if (y <= -0.5)
+ y = y + x + 1;
+ else
+ y = y + x;
+ if (u.i.se >> 15)
+ y = -y;
+ return y;
}
#endif
diff --git a/fusl/src/math/scalb.c b/fusl/src/math/scalb.c
index efe69e6..49cdb5a 100644
--- a/fusl/src/math/scalb.c
+++ b/fusl/src/math/scalb.c
@@ -18,18 +18,20 @@
#define _GNU_SOURCE
#include <math.h>
-double scalb(double x, double fn)
-{
- if (isnan(x) || isnan(fn))
- return x*fn;
- if (!isfinite(fn)) {
- if (fn > 0.0)
- return x*fn;
- else
- return x/(-fn);
- }
- if (rint(fn) != fn) return (fn-fn)/(fn-fn);
- if ( fn > 65000.0) return scalbn(x, 65000);
- if (-fn > 65000.0) return scalbn(x,-65000);
- return scalbn(x,(int)fn);
+double scalb(double x, double fn) {
+ if (isnan(x) || isnan(fn))
+ return x * fn;
+ if (!isfinite(fn)) {
+ if (fn > 0.0)
+ return x * fn;
+ else
+ return x / (-fn);
+ }
+ if (rint(fn) != fn)
+ return (fn - fn) / (fn - fn);
+ if (fn > 65000.0)
+ return scalbn(x, 65000);
+ if (-fn > 65000.0)
+ return scalbn(x, -65000);
+ return scalbn(x, (int)fn);
}
diff --git a/fusl/src/math/scalbf.c b/fusl/src/math/scalbf.c
index f44ed5b..d0f2831 100644
--- a/fusl/src/math/scalbf.c
+++ b/fusl/src/math/scalbf.c
@@ -16,17 +16,20 @@
#define _GNU_SOURCE
#include <math.h>
-float scalbf(float x, float fn)
-{
- if (isnan(x) || isnan(fn)) return x*fn;
- if (!isfinite(fn)) {
- if (fn > 0.0f)
- return x*fn;
- else
- return x/(-fn);
- }
- if (rintf(fn) != fn) return (fn-fn)/(fn-fn);
- if ( fn > 65000.0f) return scalbnf(x, 65000);
- if (-fn > 65000.0f) return scalbnf(x,-65000);
- return scalbnf(x,(int)fn);
+float scalbf(float x, float fn) {
+ if (isnan(x) || isnan(fn))
+ return x * fn;
+ if (!isfinite(fn)) {
+ if (fn > 0.0f)
+ return x * fn;
+ else
+ return x / (-fn);
+ }
+ if (rintf(fn) != fn)
+ return (fn - fn) / (fn - fn);
+ if (fn > 65000.0f)
+ return scalbnf(x, 65000);
+ if (-fn > 65000.0f)
+ return scalbnf(x, -65000);
+ return scalbnf(x, (int)fn);
}
diff --git a/fusl/src/math/scalbln.c b/fusl/src/math/scalbln.c
index e6f3f19..fc59ea9 100644
--- a/fusl/src/math/scalbln.c
+++ b/fusl/src/math/scalbln.c
@@ -1,11 +1,10 @@
#include <limits.h>
#include <math.h>
-double scalbln(double x, long n)
-{
- if (n > INT_MAX)
- n = INT_MAX;
- else if (n < INT_MIN)
- n = INT_MIN;
- return scalbn(x, n);
+double scalbln(double x, long n) {
+ if (n > INT_MAX)
+ n = INT_MAX;
+ else if (n < INT_MIN)
+ n = INT_MIN;
+ return scalbn(x, n);
}
diff --git a/fusl/src/math/scalblnf.c b/fusl/src/math/scalblnf.c
index d8e8166..8eb6fc4 100644
--- a/fusl/src/math/scalblnf.c
+++ b/fusl/src/math/scalblnf.c
@@ -1,11 +1,10 @@
#include <limits.h>
#include <math.h>
-float scalblnf(float x, long n)
-{
- if (n > INT_MAX)
- n = INT_MAX;
- else if (n < INT_MIN)
- n = INT_MIN;
- return scalbnf(x, n);
+float scalblnf(float x, long n) {
+ if (n > INT_MAX)
+ n = INT_MAX;
+ else if (n < INT_MIN)
+ n = INT_MIN;
+ return scalbnf(x, n);
}
diff --git a/fusl/src/math/scalblnl.c b/fusl/src/math/scalblnl.c
index 854c51c..7a0084f 100644
--- a/fusl/src/math/scalblnl.c
+++ b/fusl/src/math/scalblnl.c
@@ -3,17 +3,15 @@
#include <float.h>
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double scalblnl(long double x, long n)
-{
- return scalbln(x, n);
+long double scalblnl(long double x, long n) {
+ return scalbln(x, n);
}
#else
-long double scalblnl(long double x, long n)
-{
- if (n > INT_MAX)
- n = INT_MAX;
- else if (n < INT_MIN)
- n = INT_MIN;
- return scalbnl(x, n);
+long double scalblnl(long double x, long n) {
+ if (n > INT_MAX)
+ n = INT_MAX;
+ else if (n < INT_MIN)
+ n = INT_MIN;
+ return scalbnl(x, n);
}
#endif
diff --git a/fusl/src/math/scalbn.c b/fusl/src/math/scalbn.c
index 530e07c..acfc13d 100644
--- a/fusl/src/math/scalbn.c
+++ b/fusl/src/math/scalbn.c
@@ -1,31 +1,33 @@
#include <math.h>
#include <stdint.h>
-double scalbn(double x, int n)
-{
- union {double f; uint64_t i;} u;
- double_t y = x;
+double scalbn(double x, int n) {
+ union {
+ double f;
+ uint64_t i;
+ } u;
+ double_t y = x;
- if (n > 1023) {
- y *= 0x1p1023;
- n -= 1023;
- if (n > 1023) {
- y *= 0x1p1023;
- n -= 1023;
- if (n > 1023)
- n = 1023;
- }
- } else if (n < -1022) {
- y *= 0x1p-1022;
- n += 1022;
- if (n < -1022) {
- y *= 0x1p-1022;
- n += 1022;
- if (n < -1022)
- n = -1022;
- }
- }
- u.i = (uint64_t)(0x3ff+n)<<52;
- x = y * u.f;
- return x;
+ if (n > 1023) {
+ y *= 0x1p1023;
+ n -= 1023;
+ if (n > 1023) {
+ y *= 0x1p1023;
+ n -= 1023;
+ if (n > 1023)
+ n = 1023;
+ }
+ } else if (n < -1022) {
+ y *= 0x1p-1022;
+ n += 1022;
+ if (n < -1022) {
+ y *= 0x1p-1022;
+ n += 1022;
+ if (n < -1022)
+ n = -1022;
+ }
+ }
+ u.i = (uint64_t)(0x3ff + n) << 52;
+ x = y * u.f;
+ return x;
}
diff --git a/fusl/src/math/scalbnf.c b/fusl/src/math/scalbnf.c
index 0b62c3c..473792d 100644
--- a/fusl/src/math/scalbnf.c
+++ b/fusl/src/math/scalbnf.c
@@ -1,31 +1,33 @@
#include <math.h>
#include <stdint.h>
-float scalbnf(float x, int n)
-{
- union {float f; uint32_t i;} u;
- float_t y = x;
+float scalbnf(float x, int n) {
+ union {
+ float f;
+ uint32_t i;
+ } u;
+ float_t y = x;
- if (n > 127) {
- y *= 0x1p127f;
- n -= 127;
- if (n > 127) {
- y *= 0x1p127f;
- n -= 127;
- if (n > 127)
- n = 127;
- }
- } else if (n < -126) {
- y *= 0x1p-126f;
- n += 126;
- if (n < -126) {
- y *= 0x1p-126f;
- n += 126;
- if (n < -126)
- n = -126;
- }
- }
- u.i = (uint32_t)(0x7f+n)<<23;
- x = y * u.f;
- return x;
+ if (n > 127) {
+ y *= 0x1p127f;
+ n -= 127;
+ if (n > 127) {
+ y *= 0x1p127f;
+ n -= 127;
+ if (n > 127)
+ n = 127;
+ }
+ } else if (n < -126) {
+ y *= 0x1p-126f;
+ n += 126;
+ if (n < -126) {
+ y *= 0x1p-126f;
+ n += 126;
+ if (n < -126)
+ n = -126;
+ }
+ }
+ u.i = (uint32_t)(0x7f + n) << 23;
+ x = y * u.f;
+ return x;
}
diff --git a/fusl/src/math/scalbnl.c b/fusl/src/math/scalbnl.c
index 08a4c58..9a03ef7 100644
--- a/fusl/src/math/scalbnl.c
+++ b/fusl/src/math/scalbnl.c
@@ -1,36 +1,34 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double scalbnl(long double x, int n)
-{
- return scalbn(x, n);
+long double scalbnl(long double x, int n) {
+ return scalbn(x, n);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-long double scalbnl(long double x, int n)
-{
- union ldshape u;
+long double scalbnl(long double x, int n) {
+ union ldshape u;
- if (n > 16383) {
- x *= 0x1p16383L;
- n -= 16383;
- if (n > 16383) {
- x *= 0x1p16383L;
- n -= 16383;
- if (n > 16383)
- n = 16383;
- }
- } else if (n < -16382) {
- x *= 0x1p-16382L;
- n += 16382;
- if (n < -16382) {
- x *= 0x1p-16382L;
- n += 16382;
- if (n < -16382)
- n = -16382;
- }
- }
- u.f = 1.0;
- u.i.se = 0x3fff + n;
- return x * u.f;
+ if (n > 16383) {
+ x *= 0x1p16383L;
+ n -= 16383;
+ if (n > 16383) {
+ x *= 0x1p16383L;
+ n -= 16383;
+ if (n > 16383)
+ n = 16383;
+ }
+ } else if (n < -16382) {
+ x *= 0x1p-16382L;
+ n += 16382;
+ if (n < -16382) {
+ x *= 0x1p-16382L;
+ n += 16382;
+ if (n < -16382)
+ n = -16382;
+ }
+ }
+ u.f = 1.0;
+ u.i.se = 0x3fff + n;
+ return x * u.f;
}
#endif
diff --git a/fusl/src/math/significand.c b/fusl/src/math/significand.c
index 40d9aa9..e5d5bbe 100644
--- a/fusl/src/math/significand.c
+++ b/fusl/src/math/significand.c
@@ -1,7 +1,6 @@
#define _GNU_SOURCE
#include <math.h>
-double significand(double x)
-{
- return scalbn(x, -ilogb(x));
+double significand(double x) {
+ return scalbn(x, -ilogb(x));
}
diff --git a/fusl/src/math/significandf.c b/fusl/src/math/significandf.c
index 8a697e1..119aa3a 100644
--- a/fusl/src/math/significandf.c
+++ b/fusl/src/math/significandf.c
@@ -1,7 +1,6 @@
#define _GNU_SOURCE
#include <math.h>
-float significandf(float x)
-{
- return scalbnf(x, -ilogbf(x));
+float significandf(float x) {
+ return scalbnf(x, -ilogbf(x));
}
diff --git a/fusl/src/math/sin.c b/fusl/src/math/sin.c
index 055e215..e44c00c 100644
--- a/fusl/src/math/sin.c
+++ b/fusl/src/math/sin.c
@@ -42,37 +42,39 @@
#include "libm.h"
-double sin(double x)
-{
- double y[2];
- uint32_t ix;
- unsigned n;
+double sin(double x) {
+ double y[2];
+ uint32_t ix;
+ unsigned n;
- /* High word of x. */
- GET_HIGH_WORD(ix, x);
- ix &= 0x7fffffff;
+ /* High word of x. */
+ GET_HIGH_WORD(ix, x);
+ ix &= 0x7fffffff;
- /* |x| ~< pi/4 */
- if (ix <= 0x3fe921fb) {
- if (ix < 0x3e500000) { /* |x| < 2**-26 */
- /* raise inexact if x != 0 and underflow if subnormal*/
- FORCE_EVAL(ix < 0x00100000 ? x/0x1p120f : x+0x1p120f);
- return x;
- }
- return __sin(x, 0.0, 0);
- }
+ /* |x| ~< pi/4 */
+ if (ix <= 0x3fe921fb) {
+ if (ix < 0x3e500000) { /* |x| < 2**-26 */
+ /* raise inexact if x != 0 and underflow if subnormal*/
+ FORCE_EVAL(ix < 0x00100000 ? x / 0x1p120f : x + 0x1p120f);
+ return x;
+ }
+ return __sin(x, 0.0, 0);
+ }
- /* sin(Inf or NaN) is NaN */
- if (ix >= 0x7ff00000)
- return x - x;
+ /* sin(Inf or NaN) is NaN */
+ if (ix >= 0x7ff00000)
+ return x - x;
- /* argument reduction needed */
- n = __rem_pio2(x, y);
- switch (n&3) {
- case 0: return __sin(y[0], y[1], 1);
- case 1: return __cos(y[0], y[1]);
- case 2: return -__sin(y[0], y[1], 1);
- default:
- return -__cos(y[0], y[1]);
- }
+ /* argument reduction needed */
+ n = __rem_pio2(x, y);
+ switch (n & 3) {
+ case 0:
+ return __sin(y[0], y[1], 1);
+ case 1:
+ return __cos(y[0], y[1]);
+ case 2:
+ return -__sin(y[0], y[1], 1);
+ default:
+ return -__cos(y[0], y[1]);
+ }
}
diff --git a/fusl/src/math/sincos.c b/fusl/src/math/sincos.c
index 35b2d92..33d74fc 100644
--- a/fusl/src/math/sincos.c
+++ b/fusl/src/math/sincos.c
@@ -13,57 +13,56 @@
#define _GNU_SOURCE
#include "libm.h"
-void sincos(double x, double *sin, double *cos)
-{
- double y[2], s, c;
- uint32_t ix;
- unsigned n;
+void sincos(double x, double* sin, double* cos) {
+ double y[2], s, c;
+ uint32_t ix;
+ unsigned n;
- GET_HIGH_WORD(ix, x);
- ix &= 0x7fffffff;
+ GET_HIGH_WORD(ix, x);
+ ix &= 0x7fffffff;
- /* |x| ~< pi/4 */
- if (ix <= 0x3fe921fb) {
- /* if |x| < 2**-27 * sqrt(2) */
- if (ix < 0x3e46a09e) {
- /* raise inexact if x!=0 and underflow if subnormal */
- FORCE_EVAL(ix < 0x00100000 ? x/0x1p120f : x+0x1p120f);
- *sin = x;
- *cos = 1.0;
- return;
- }
- *sin = __sin(x, 0.0, 0);
- *cos = __cos(x, 0.0);
- return;
- }
+ /* |x| ~< pi/4 */
+ if (ix <= 0x3fe921fb) {
+ /* if |x| < 2**-27 * sqrt(2) */
+ if (ix < 0x3e46a09e) {
+ /* raise inexact if x!=0 and underflow if subnormal */
+ FORCE_EVAL(ix < 0x00100000 ? x / 0x1p120f : x + 0x1p120f);
+ *sin = x;
+ *cos = 1.0;
+ return;
+ }
+ *sin = __sin(x, 0.0, 0);
+ *cos = __cos(x, 0.0);
+ return;
+ }
- /* sincos(Inf or NaN) is NaN */
- if (ix >= 0x7ff00000) {
- *sin = *cos = x - x;
- return;
- }
+ /* sincos(Inf or NaN) is NaN */
+ if (ix >= 0x7ff00000) {
+ *sin = *cos = x - x;
+ return;
+ }
- /* argument reduction needed */
- n = __rem_pio2(x, y);
- s = __sin(y[0], y[1], 1);
- c = __cos(y[0], y[1]);
- switch (n&3) {
- case 0:
- *sin = s;
- *cos = c;
- break;
- case 1:
- *sin = c;
- *cos = -s;
- break;
- case 2:
- *sin = -s;
- *cos = -c;
- break;
- case 3:
- default:
- *sin = -c;
- *cos = s;
- break;
- }
+ /* argument reduction needed */
+ n = __rem_pio2(x, y);
+ s = __sin(y[0], y[1], 1);
+ c = __cos(y[0], y[1]);
+ switch (n & 3) {
+ case 0:
+ *sin = s;
+ *cos = c;
+ break;
+ case 1:
+ *sin = c;
+ *cos = -s;
+ break;
+ case 2:
+ *sin = -s;
+ *cos = -c;
+ break;
+ case 3:
+ default:
+ *sin = -c;
+ *cos = s;
+ break;
+ }
}
diff --git a/fusl/src/math/sincosf.c b/fusl/src/math/sincosf.c
index f8ca723..11feeab 100644
--- a/fusl/src/math/sincosf.c
+++ b/fusl/src/math/sincosf.c
@@ -18,100 +18,98 @@
#include "libm.h"
/* Small multiples of pi/2 rounded to double precision. */
-static const double
-s1pio2 = 1*M_PI_2, /* 0x3FF921FB, 0x54442D18 */
-s2pio2 = 2*M_PI_2, /* 0x400921FB, 0x54442D18 */
-s3pio2 = 3*M_PI_2, /* 0x4012D97C, 0x7F3321D2 */
-s4pio2 = 4*M_PI_2; /* 0x401921FB, 0x54442D18 */
+static const double s1pio2 = 1 * M_PI_2, /* 0x3FF921FB, 0x54442D18 */
+ s2pio2 = 2 * M_PI_2, /* 0x400921FB, 0x54442D18 */
+ s3pio2 = 3 * M_PI_2, /* 0x4012D97C, 0x7F3321D2 */
+ s4pio2 = 4 * M_PI_2; /* 0x401921FB, 0x54442D18 */
-void sincosf(float x, float *sin, float *cos)
-{
- double y;
- float_t s, c;
- uint32_t ix;
- unsigned n, sign;
+void sincosf(float x, float* sin, float* cos) {
+ double y;
+ float_t s, c;
+ uint32_t ix;
+ unsigned n, sign;
- GET_FLOAT_WORD(ix, x);
- sign = ix >> 31;
- ix &= 0x7fffffff;
+ GET_FLOAT_WORD(ix, x);
+ sign = ix >> 31;
+ ix &= 0x7fffffff;
- /* |x| ~<= pi/4 */
- if (ix <= 0x3f490fda) {
- /* |x| < 2**-12 */
- if (ix < 0x39800000) {
- /* raise inexact if x!=0 and underflow if subnormal */
- FORCE_EVAL(ix < 0x00100000 ? x/0x1p120f : x+0x1p120f);
- *sin = x;
- *cos = 1.0f;
- return;
- }
- *sin = __sindf(x);
- *cos = __cosdf(x);
- return;
- }
+ /* |x| ~<= pi/4 */
+ if (ix <= 0x3f490fda) {
+ /* |x| < 2**-12 */
+ if (ix < 0x39800000) {
+ /* raise inexact if x!=0 and underflow if subnormal */
+ FORCE_EVAL(ix < 0x00100000 ? x / 0x1p120f : x + 0x1p120f);
+ *sin = x;
+ *cos = 1.0f;
+ return;
+ }
+ *sin = __sindf(x);
+ *cos = __cosdf(x);
+ return;
+ }
- /* |x| ~<= 5*pi/4 */
- if (ix <= 0x407b53d1) {
- if (ix <= 0x4016cbe3) { /* |x| ~<= 3pi/4 */
- if (sign) {
- *sin = -__cosdf(x + s1pio2);
- *cos = __sindf(x + s1pio2);
- } else {
- *sin = __cosdf(s1pio2 - x);
- *cos = __sindf(s1pio2 - x);
- }
- return;
- }
- /* -sin(x+c) is not correct if x+c could be 0: -0 vs +0 */
- *sin = -__sindf(sign ? x + s2pio2 : x - s2pio2);
- *cos = -__cosdf(sign ? x + s2pio2 : x - s2pio2);
- return;
- }
+ /* |x| ~<= 5*pi/4 */
+ if (ix <= 0x407b53d1) {
+ if (ix <= 0x4016cbe3) { /* |x| ~<= 3pi/4 */
+ if (sign) {
+ *sin = -__cosdf(x + s1pio2);
+ *cos = __sindf(x + s1pio2);
+ } else {
+ *sin = __cosdf(s1pio2 - x);
+ *cos = __sindf(s1pio2 - x);
+ }
+ return;
+ }
+ /* -sin(x+c) is not correct if x+c could be 0: -0 vs +0 */
+ *sin = -__sindf(sign ? x + s2pio2 : x - s2pio2);
+ *cos = -__cosdf(sign ? x + s2pio2 : x - s2pio2);
+ return;
+ }
- /* |x| ~<= 9*pi/4 */
- if (ix <= 0x40e231d5) {
- if (ix <= 0x40afeddf) { /* |x| ~<= 7*pi/4 */
- if (sign) {
- *sin = __cosdf(x + s3pio2);
- *cos = -__sindf(x + s3pio2);
- } else {
- *sin = -__cosdf(x - s3pio2);
- *cos = __sindf(x - s3pio2);
- }
- return;
- }
- *sin = __sindf(sign ? x + s4pio2 : x - s4pio2);
- *cos = __cosdf(sign ? x + s4pio2 : x - s4pio2);
- return;
- }
+ /* |x| ~<= 9*pi/4 */
+ if (ix <= 0x40e231d5) {
+ if (ix <= 0x40afeddf) { /* |x| ~<= 7*pi/4 */
+ if (sign) {
+ *sin = __cosdf(x + s3pio2);
+ *cos = -__sindf(x + s3pio2);
+ } else {
+ *sin = -__cosdf(x - s3pio2);
+ *cos = __sindf(x - s3pio2);
+ }
+ return;
+ }
+ *sin = __sindf(sign ? x + s4pio2 : x - s4pio2);
+ *cos = __cosdf(sign ? x + s4pio2 : x - s4pio2);
+ return;
+ }
- /* sin(Inf or NaN) is NaN */
- if (ix >= 0x7f800000) {
- *sin = *cos = x - x;
- return;
- }
+ /* sin(Inf or NaN) is NaN */
+ if (ix >= 0x7f800000) {
+ *sin = *cos = x - x;
+ return;
+ }
- /* general argument reduction needed */
- n = __rem_pio2f(x, &y);
- s = __sindf(y);
- c = __cosdf(y);
- switch (n&3) {
- case 0:
- *sin = s;
- *cos = c;
- break;
- case 1:
- *sin = c;
- *cos = -s;
- break;
- case 2:
- *sin = -s;
- *cos = -c;
- break;
- case 3:
- default:
- *sin = -c;
- *cos = s;
- break;
- }
+ /* general argument reduction needed */
+ n = __rem_pio2f(x, &y);
+ s = __sindf(y);
+ c = __cosdf(y);
+ switch (n & 3) {
+ case 0:
+ *sin = s;
+ *cos = c;
+ break;
+ case 1:
+ *sin = c;
+ *cos = -s;
+ break;
+ case 2:
+ *sin = -s;
+ *cos = -c;
+ break;
+ case 3:
+ default:
+ *sin = -c;
+ *cos = s;
+ break;
+ }
}
diff --git a/fusl/src/math/sincosl.c b/fusl/src/math/sincosl.c
index d3ac1c4..a4f6c28 100644
--- a/fusl/src/math/sincosl.c
+++ b/fusl/src/math/sincosl.c
@@ -2,59 +2,58 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-void sincosl(long double x, long double *sin, long double *cos)
-{
- double sind, cosd;
- sincos(x, &sind, &cosd);
- *sin = sind;
- *cos = cosd;
+void sincosl(long double x, long double* sin, long double* cos) {
+ double sind, cosd;
+ sincos(x, &sind, &cosd);
+ *sin = sind;
+ *cos = cosd;
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-void sincosl(long double x, long double *sin, long double *cos)
-{
- union ldshape u = {x};
- unsigned n;
- long double y[2], s, c;
+void sincosl(long double x, long double* sin, long double* cos) {
+ union ldshape u = {x};
+ unsigned n;
+ long double y[2], s, c;
- u.i.se &= 0x7fff;
- if (u.i.se == 0x7fff) {
- *sin = *cos = x - x;
- return;
- }
- if (u.f < M_PI_4) {
- if (u.i.se < 0x3fff - LDBL_MANT_DIG) {
- /* raise underflow if subnormal */
- if (u.i.se == 0) FORCE_EVAL(x*0x1p-120f);
- *sin = x;
- /* raise inexact if x!=0 */
- *cos = 1.0 + x;
- return;
- }
- *sin = __sinl(x, 0, 0);
- *cos = __cosl(x, 0);
- return;
- }
- n = __rem_pio2l(x, y);
- s = __sinl(y[0], y[1], 1);
- c = __cosl(y[0], y[1]);
- switch (n & 3) {
- case 0:
- *sin = s;
- *cos = c;
- break;
- case 1:
- *sin = c;
- *cos = -s;
- break;
- case 2:
- *sin = -s;
- *cos = -c;
- break;
- case 3:
- default:
- *sin = -c;
- *cos = s;
- break;
- }
+ u.i.se &= 0x7fff;
+ if (u.i.se == 0x7fff) {
+ *sin = *cos = x - x;
+ return;
+ }
+ if (u.f < M_PI_4) {
+ if (u.i.se < 0x3fff - LDBL_MANT_DIG) {
+ /* raise underflow if subnormal */
+ if (u.i.se == 0)
+ FORCE_EVAL(x * 0x1p-120f);
+ *sin = x;
+ /* raise inexact if x!=0 */
+ *cos = 1.0 + x;
+ return;
+ }
+ *sin = __sinl(x, 0, 0);
+ *cos = __cosl(x, 0);
+ return;
+ }
+ n = __rem_pio2l(x, y);
+ s = __sinl(y[0], y[1], 1);
+ c = __cosl(y[0], y[1]);
+ switch (n & 3) {
+ case 0:
+ *sin = s;
+ *cos = c;
+ break;
+ case 1:
+ *sin = c;
+ *cos = -s;
+ break;
+ case 2:
+ *sin = -s;
+ *cos = -c;
+ break;
+ case 3:
+ default:
+ *sin = -c;
+ *cos = s;
+ break;
+ }
}
#endif
diff --git a/fusl/src/math/sinf.c b/fusl/src/math/sinf.c
index 64e39f5..7893625 100644
--- a/fusl/src/math/sinf.c
+++ b/fusl/src/math/sinf.c
@@ -17,60 +17,61 @@
#include "libm.h"
/* Small multiples of pi/2 rounded to double precision. */
-static const double
-s1pio2 = 1*M_PI_2, /* 0x3FF921FB, 0x54442D18 */
-s2pio2 = 2*M_PI_2, /* 0x400921FB, 0x54442D18 */
-s3pio2 = 3*M_PI_2, /* 0x4012D97C, 0x7F3321D2 */
-s4pio2 = 4*M_PI_2; /* 0x401921FB, 0x54442D18 */
+static const double s1pio2 = 1 * M_PI_2, /* 0x3FF921FB, 0x54442D18 */
+ s2pio2 = 2 * M_PI_2, /* 0x400921FB, 0x54442D18 */
+ s3pio2 = 3 * M_PI_2, /* 0x4012D97C, 0x7F3321D2 */
+ s4pio2 = 4 * M_PI_2; /* 0x401921FB, 0x54442D18 */
-float sinf(float x)
-{
- double y;
- uint32_t ix;
- int n, sign;
+float sinf(float x) {
+ double y;
+ uint32_t ix;
+ int n, sign;
- GET_FLOAT_WORD(ix, x);
- sign = ix >> 31;
- ix &= 0x7fffffff;
+ GET_FLOAT_WORD(ix, x);
+ sign = ix >> 31;
+ ix &= 0x7fffffff;
- if (ix <= 0x3f490fda) { /* |x| ~<= pi/4 */
- if (ix < 0x39800000) { /* |x| < 2**-12 */
- /* raise inexact if x!=0 and underflow if subnormal */
- FORCE_EVAL(ix < 0x00800000 ? x/0x1p120f : x+0x1p120f);
- return x;
- }
- return __sindf(x);
- }
- if (ix <= 0x407b53d1) { /* |x| ~<= 5*pi/4 */
- if (ix <= 0x4016cbe3) { /* |x| ~<= 3pi/4 */
- if (sign)
- return -__cosdf(x + s1pio2);
- else
- return __cosdf(x - s1pio2);
- }
- return __sindf(sign ? -(x + s2pio2) : -(x - s2pio2));
- }
- if (ix <= 0x40e231d5) { /* |x| ~<= 9*pi/4 */
- if (ix <= 0x40afeddf) { /* |x| ~<= 7*pi/4 */
- if (sign)
- return __cosdf(x + s3pio2);
- else
- return -__cosdf(x - s3pio2);
- }
- return __sindf(sign ? x + s4pio2 : x - s4pio2);
- }
+ if (ix <= 0x3f490fda) { /* |x| ~<= pi/4 */
+ if (ix < 0x39800000) { /* |x| < 2**-12 */
+ /* raise inexact if x!=0 and underflow if subnormal */
+ FORCE_EVAL(ix < 0x00800000 ? x / 0x1p120f : x + 0x1p120f);
+ return x;
+ }
+ return __sindf(x);
+ }
+ if (ix <= 0x407b53d1) { /* |x| ~<= 5*pi/4 */
+ if (ix <= 0x4016cbe3) { /* |x| ~<= 3pi/4 */
+ if (sign)
+ return -__cosdf(x + s1pio2);
+ else
+ return __cosdf(x - s1pio2);
+ }
+ return __sindf(sign ? -(x + s2pio2) : -(x - s2pio2));
+ }
+ if (ix <= 0x40e231d5) { /* |x| ~<= 9*pi/4 */
+ if (ix <= 0x40afeddf) { /* |x| ~<= 7*pi/4 */
+ if (sign)
+ return __cosdf(x + s3pio2);
+ else
+ return -__cosdf(x - s3pio2);
+ }
+ return __sindf(sign ? x + s4pio2 : x - s4pio2);
+ }
- /* sin(Inf or NaN) is NaN */
- if (ix >= 0x7f800000)
- return x - x;
+ /* sin(Inf or NaN) is NaN */
+ if (ix >= 0x7f800000)
+ return x - x;
- /* general argument reduction needed */
- n = __rem_pio2f(x, &y);
- switch (n&3) {
- case 0: return __sindf(y);
- case 1: return __cosdf(y);
- case 2: return __sindf(-y);
- default:
- return -__cosdf(y);
- }
+ /* general argument reduction needed */
+ n = __rem_pio2f(x, &y);
+ switch (n & 3) {
+ case 0:
+ return __sindf(y);
+ case 1:
+ return __cosdf(y);
+ case 2:
+ return __sindf(-y);
+ default:
+ return -__cosdf(y);
+ }
}
diff --git a/fusl/src/math/sinh.c b/fusl/src/math/sinh.c
index 00022c4..c94e59c 100644
--- a/fusl/src/math/sinh.c
+++ b/fusl/src/math/sinh.c
@@ -4,36 +4,38 @@
* = (exp(x)-1 + (exp(x)-1)/exp(x))/2
* = x + x^3/6 + o(x^5)
*/
-double sinh(double x)
-{
- union {double f; uint64_t i;} u = {.f = x};
- uint32_t w;
- double t, h, absx;
+double sinh(double x) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {.f = x};
+ uint32_t w;
+ double t, h, absx;
- h = 0.5;
- if (u.i >> 63)
- h = -h;
- /* |x| */
- u.i &= (uint64_t)-1/2;
- absx = u.f;
- w = u.i >> 32;
+ h = 0.5;
+ if (u.i >> 63)
+ h = -h;
+ /* |x| */
+ u.i &= (uint64_t)-1 / 2;
+ absx = u.f;
+ w = u.i >> 32;
- /* |x| < log(DBL_MAX) */
- if (w < 0x40862e42) {
- t = expm1(absx);
- if (w < 0x3ff00000) {
- if (w < 0x3ff00000 - (26<<20))
- /* note: inexact and underflow are raised by expm1 */
- /* note: this branch avoids spurious underflow */
- return x;
- return h*(2*t - t*t/(t+1));
- }
- /* note: |x|>log(0x1p26)+eps could be just h*exp(x) */
- return h*(t + t/(t+1));
- }
+ /* |x| < log(DBL_MAX) */
+ if (w < 0x40862e42) {
+ t = expm1(absx);
+ if (w < 0x3ff00000) {
+ if (w < 0x3ff00000 - (26 << 20))
+ /* note: inexact and underflow are raised by expm1 */
+ /* note: this branch avoids spurious underflow */
+ return x;
+ return h * (2 * t - t * t / (t + 1));
+ }
+ /* note: |x|>log(0x1p26)+eps could be just h*exp(x) */
+ return h * (t + t / (t + 1));
+ }
- /* |x| > log(DBL_MAX) or nan */
- /* note: the result is stored to handle overflow */
- t = 2*h*__expo2(absx);
- return t;
+ /* |x| > log(DBL_MAX) or nan */
+ /* note: the result is stored to handle overflow */
+ t = 2 * h * __expo2(absx);
+ return t;
}
diff --git a/fusl/src/math/sinhf.c b/fusl/src/math/sinhf.c
index 6ad19ea..705ba77 100644
--- a/fusl/src/math/sinhf.c
+++ b/fusl/src/math/sinhf.c
@@ -1,31 +1,33 @@
#include "libm.h"
-float sinhf(float x)
-{
- union {float f; uint32_t i;} u = {.f = x};
- uint32_t w;
- float t, h, absx;
+float sinhf(float x) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {.f = x};
+ uint32_t w;
+ float t, h, absx;
- h = 0.5;
- if (u.i >> 31)
- h = -h;
- /* |x| */
- u.i &= 0x7fffffff;
- absx = u.f;
- w = u.i;
+ h = 0.5;
+ if (u.i >> 31)
+ h = -h;
+ /* |x| */
+ u.i &= 0x7fffffff;
+ absx = u.f;
+ w = u.i;
- /* |x| < log(FLT_MAX) */
- if (w < 0x42b17217) {
- t = expm1f(absx);
- if (w < 0x3f800000) {
- if (w < 0x3f800000 - (12<<23))
- return x;
- return h*(2*t - t*t/(t+1));
- }
- return h*(t + t/(t+1));
- }
+ /* |x| < log(FLT_MAX) */
+ if (w < 0x42b17217) {
+ t = expm1f(absx);
+ if (w < 0x3f800000) {
+ if (w < 0x3f800000 - (12 << 23))
+ return x;
+ return h * (2 * t - t * t / (t + 1));
+ }
+ return h * (t + t / (t + 1));
+ }
- /* |x| > logf(FLT_MAX) or nan */
- t = 2*h*__expo2f(absx);
- return t;
+ /* |x| > logf(FLT_MAX) or nan */
+ t = 2 * h * __expo2f(absx);
+ return t;
}
diff --git a/fusl/src/math/sinhl.c b/fusl/src/math/sinhl.c
index b305d4d..4ef2c17 100644
--- a/fusl/src/math/sinhl.c
+++ b/fusl/src/math/sinhl.c
@@ -1,43 +1,40 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double sinhl(long double x)
-{
- return sinh(x);
+long double sinhl(long double x) {
+ return sinh(x);
}
#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
-long double sinhl(long double x)
-{
- union ldshape u = {x};
- unsigned ex = u.i.se & 0x7fff;
- long double h, t, absx;
+long double sinhl(long double x) {
+ union ldshape u = {x};
+ unsigned ex = u.i.se & 0x7fff;
+ long double h, t, absx;
- h = 0.5;
- if (u.i.se & 0x8000)
- h = -h;
- /* |x| */
- u.i.se = ex;
- absx = u.f;
+ h = 0.5;
+ if (u.i.se & 0x8000)
+ h = -h;
+ /* |x| */
+ u.i.se = ex;
+ absx = u.f;
- /* |x| < log(LDBL_MAX) */
- if (ex < 0x3fff+13 || (ex == 0x3fff+13 && u.i.m>>32 < 0xb17217f7)) {
- t = expm1l(absx);
- if (ex < 0x3fff) {
- if (ex < 0x3fff-32)
- return x;
- return h*(2*t - t*t/(1+t));
- }
- return h*(t + t/(t+1));
- }
+ /* |x| < log(LDBL_MAX) */
+ if (ex < 0x3fff + 13 || (ex == 0x3fff + 13 && u.i.m >> 32 < 0xb17217f7)) {
+ t = expm1l(absx);
+ if (ex < 0x3fff) {
+ if (ex < 0x3fff - 32)
+ return x;
+ return h * (2 * t - t * t / (1 + t));
+ }
+ return h * (t + t / (t + 1));
+ }
- /* |x| > log(LDBL_MAX) or nan */
- t = expl(0.5*absx);
- return h*t*t;
+ /* |x| > log(LDBL_MAX) or nan */
+ t = expl(0.5 * absx);
+ return h * t * t;
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
// TODO: broken implementation to make things compile
-long double sinhl(long double x)
-{
- return sinh(x);
+long double sinhl(long double x) {
+ return sinh(x);
}
#endif
diff --git a/fusl/src/math/sinl.c b/fusl/src/math/sinl.c
index 9c0b16e..e755374 100644
--- a/fusl/src/math/sinl.c
+++ b/fusl/src/math/sinl.c
@@ -1,41 +1,39 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double sinl(long double x)
-{
- return sin(x);
+long double sinl(long double x) {
+ return sin(x);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-long double sinl(long double x)
-{
- union ldshape u = {x};
- unsigned n;
- long double y[2], hi, lo;
+long double sinl(long double x) {
+ union ldshape u = {x};
+ unsigned n;
+ long double y[2], hi, lo;
- u.i.se &= 0x7fff;
- if (u.i.se == 0x7fff)
- return x - x;
- if (u.f < M_PI_4) {
- if (u.i.se < 0x3fff - LDBL_MANT_DIG/2) {
- /* raise inexact if x!=0 and underflow if subnormal */
- FORCE_EVAL(u.i.se == 0 ? x*0x1p-120f : x+0x1p120f);
- return x;
- }
- return __sinl(x, 0.0, 0);
- }
- n = __rem_pio2l(x, y);
- hi = y[0];
- lo = y[1];
- switch (n & 3) {
- case 0:
- return __sinl(hi, lo, 1);
- case 1:
- return __cosl(hi, lo);
- case 2:
- return -__sinl(hi, lo, 1);
- case 3:
- default:
- return -__cosl(hi, lo);
- }
+ u.i.se &= 0x7fff;
+ if (u.i.se == 0x7fff)
+ return x - x;
+ if (u.f < M_PI_4) {
+ if (u.i.se < 0x3fff - LDBL_MANT_DIG / 2) {
+ /* raise inexact if x!=0 and underflow if subnormal */
+ FORCE_EVAL(u.i.se == 0 ? x * 0x1p-120f : x + 0x1p120f);
+ return x;
+ }
+ return __sinl(x, 0.0, 0);
+ }
+ n = __rem_pio2l(x, y);
+ hi = y[0];
+ lo = y[1];
+ switch (n & 3) {
+ case 0:
+ return __sinl(hi, lo, 1);
+ case 1:
+ return __cosl(hi, lo);
+ case 2:
+ return -__sinl(hi, lo, 1);
+ case 3:
+ default:
+ return -__cosl(hi, lo);
+ }
}
#endif
diff --git a/fusl/src/math/sqrt.c b/fusl/src/math/sqrt.c
index b277567..ff184fa 100644
--- a/fusl/src/math/sqrt.c
+++ b/fusl/src/math/sqrt.c
@@ -80,106 +80,105 @@
static const double tiny = 1.0e-300;
-double sqrt(double x)
-{
- double z;
- int32_t sign = (int)0x80000000;
- int32_t ix0,s0,q,m,t,i;
- uint32_t r,t1,s1,ix1,q1;
+double sqrt(double x) {
+ double z;
+ int32_t sign = (int)0x80000000;
+ int32_t ix0, s0, q, m, t, i;
+ uint32_t r, t1, s1, ix1, q1;
- EXTRACT_WORDS(ix0, ix1, x);
+ EXTRACT_WORDS(ix0, ix1, x);
- /* take care of Inf and NaN */
- if ((ix0&0x7ff00000) == 0x7ff00000) {
- return x*x + x; /* sqrt(NaN)=NaN, sqrt(+inf)=+inf, sqrt(-inf)=sNaN */
- }
- /* take care of zero */
- if (ix0 <= 0) {
- if (((ix0&~sign)|ix1) == 0)
- return x; /* sqrt(+-0) = +-0 */
- if (ix0 < 0)
- return (x-x)/(x-x); /* sqrt(-ve) = sNaN */
- }
- /* normalize x */
- m = ix0>>20;
- if (m == 0) { /* subnormal x */
- while (ix0 == 0) {
- m -= 21;
- ix0 |= (ix1>>11);
- ix1 <<= 21;
- }
- for (i=0; (ix0&0x00100000) == 0; i++)
- ix0<<=1;
- m -= i - 1;
- ix0 |= ix1>>(32-i);
- ix1 <<= i;
- }
- m -= 1023; /* unbias exponent */
- ix0 = (ix0&0x000fffff)|0x00100000;
- if (m & 1) { /* odd m, double x to make it even */
- ix0 += ix0 + ((ix1&sign)>>31);
- ix1 += ix1;
- }
- m >>= 1; /* m = [m/2] */
+ /* take care of Inf and NaN */
+ if ((ix0 & 0x7ff00000) == 0x7ff00000) {
+ return x * x + x; /* sqrt(NaN)=NaN, sqrt(+inf)=+inf, sqrt(-inf)=sNaN */
+ }
+ /* take care of zero */
+ if (ix0 <= 0) {
+ if (((ix0 & ~sign) | ix1) == 0)
+ return x; /* sqrt(+-0) = +-0 */
+ if (ix0 < 0)
+ return (x - x) / (x - x); /* sqrt(-ve) = sNaN */
+ }
+ /* normalize x */
+ m = ix0 >> 20;
+ if (m == 0) { /* subnormal x */
+ while (ix0 == 0) {
+ m -= 21;
+ ix0 |= (ix1 >> 11);
+ ix1 <<= 21;
+ }
+ for (i = 0; (ix0 & 0x00100000) == 0; i++)
+ ix0 <<= 1;
+ m -= i - 1;
+ ix0 |= ix1 >> (32 - i);
+ ix1 <<= i;
+ }
+ m -= 1023; /* unbias exponent */
+ ix0 = (ix0 & 0x000fffff) | 0x00100000;
+ if (m & 1) { /* odd m, double x to make it even */
+ ix0 += ix0 + ((ix1 & sign) >> 31);
+ ix1 += ix1;
+ }
+ m >>= 1; /* m = [m/2] */
- /* generate sqrt(x) bit by bit */
- ix0 += ix0 + ((ix1&sign)>>31);
- ix1 += ix1;
- q = q1 = s0 = s1 = 0; /* [q,q1] = sqrt(x) */
- r = 0x00200000; /* r = moving bit from right to left */
+ /* generate sqrt(x) bit by bit */
+ ix0 += ix0 + ((ix1 & sign) >> 31);
+ ix1 += ix1;
+ q = q1 = s0 = s1 = 0; /* [q,q1] = sqrt(x) */
+ r = 0x00200000; /* r = moving bit from right to left */
- while (r != 0) {
- t = s0 + r;
- if (t <= ix0) {
- s0 = t + r;
- ix0 -= t;
- q += r;
- }
- ix0 += ix0 + ((ix1&sign)>>31);
- ix1 += ix1;
- r >>= 1;
- }
+ while (r != 0) {
+ t = s0 + r;
+ if (t <= ix0) {
+ s0 = t + r;
+ ix0 -= t;
+ q += r;
+ }
+ ix0 += ix0 + ((ix1 & sign) >> 31);
+ ix1 += ix1;
+ r >>= 1;
+ }
- r = sign;
- while (r != 0) {
- t1 = s1 + r;
- t = s0;
- if (t < ix0 || (t == ix0 && t1 <= ix1)) {
- s1 = t1 + r;
- if ((t1&sign) == sign && (s1&sign) == 0)
- s0++;
- ix0 -= t;
- if (ix1 < t1)
- ix0--;
- ix1 -= t1;
- q1 += r;
- }
- ix0 += ix0 + ((ix1&sign)>>31);
- ix1 += ix1;
- r >>= 1;
- }
+ r = sign;
+ while (r != 0) {
+ t1 = s1 + r;
+ t = s0;
+ if (t < ix0 || (t == ix0 && t1 <= ix1)) {
+ s1 = t1 + r;
+ if ((t1 & sign) == sign && (s1 & sign) == 0)
+ s0++;
+ ix0 -= t;
+ if (ix1 < t1)
+ ix0--;
+ ix1 -= t1;
+ q1 += r;
+ }
+ ix0 += ix0 + ((ix1 & sign) >> 31);
+ ix1 += ix1;
+ r >>= 1;
+ }
- /* use floating add to find out rounding direction */
- if ((ix0|ix1) != 0) {
- z = 1.0 - tiny; /* raise inexact flag */
- if (z >= 1.0) {
- z = 1.0 + tiny;
- if (q1 == (uint32_t)0xffffffff) {
- q1 = 0;
- q++;
- } else if (z > 1.0) {
- if (q1 == (uint32_t)0xfffffffe)
- q++;
- q1 += 2;
- } else
- q1 += q1 & 1;
- }
- }
- ix0 = (q>>1) + 0x3fe00000;
- ix1 = q1>>1;
- if (q&1)
- ix1 |= sign;
- ix0 += m << 20;
- INSERT_WORDS(z, ix0, ix1);
- return z;
+ /* use floating add to find out rounding direction */
+ if ((ix0 | ix1) != 0) {
+ z = 1.0 - tiny; /* raise inexact flag */
+ if (z >= 1.0) {
+ z = 1.0 + tiny;
+ if (q1 == (uint32_t)0xffffffff) {
+ q1 = 0;
+ q++;
+ } else if (z > 1.0) {
+ if (q1 == (uint32_t)0xfffffffe)
+ q++;
+ q1 += 2;
+ } else
+ q1 += q1 & 1;
+ }
+ }
+ ix0 = (q >> 1) + 0x3fe00000;
+ ix1 = q1 >> 1;
+ if (q & 1)
+ ix1 |= sign;
+ ix0 += m << 20;
+ INSERT_WORDS(z, ix0, ix1);
+ return z;
}
diff --git a/fusl/src/math/sqrtf.c b/fusl/src/math/sqrtf.c
index 28cb4ad..329a00a 100644
--- a/fusl/src/math/sqrtf.c
+++ b/fusl/src/math/sqrtf.c
@@ -17,68 +17,67 @@
static const float tiny = 1.0e-30;
-float sqrtf(float x)
-{
- float z;
- int32_t sign = (int)0x80000000;
- int32_t ix,s,q,m,t,i;
- uint32_t r;
+float sqrtf(float x) {
+ float z;
+ int32_t sign = (int)0x80000000;
+ int32_t ix, s, q, m, t, i;
+ uint32_t r;
- GET_FLOAT_WORD(ix, x);
+ GET_FLOAT_WORD(ix, x);
- /* take care of Inf and NaN */
- if ((ix&0x7f800000) == 0x7f800000)
- return x*x + x; /* sqrt(NaN)=NaN, sqrt(+inf)=+inf, sqrt(-inf)=sNaN */
+ /* take care of Inf and NaN */
+ if ((ix & 0x7f800000) == 0x7f800000)
+ return x * x + x; /* sqrt(NaN)=NaN, sqrt(+inf)=+inf, sqrt(-inf)=sNaN */
- /* take care of zero */
- if (ix <= 0) {
- if ((ix&~sign) == 0)
- return x; /* sqrt(+-0) = +-0 */
- if (ix < 0)
- return (x-x)/(x-x); /* sqrt(-ve) = sNaN */
- }
- /* normalize x */
- m = ix>>23;
- if (m == 0) { /* subnormal x */
- for (i = 0; (ix&0x00800000) == 0; i++)
- ix<<=1;
- m -= i - 1;
- }
- m -= 127; /* unbias exponent */
- ix = (ix&0x007fffff)|0x00800000;
- if (m&1) /* odd m, double x to make it even */
- ix += ix;
- m >>= 1; /* m = [m/2] */
+ /* take care of zero */
+ if (ix <= 0) {
+ if ((ix & ~sign) == 0)
+ return x; /* sqrt(+-0) = +-0 */
+ if (ix < 0)
+ return (x - x) / (x - x); /* sqrt(-ve) = sNaN */
+ }
+ /* normalize x */
+ m = ix >> 23;
+ if (m == 0) { /* subnormal x */
+ for (i = 0; (ix & 0x00800000) == 0; i++)
+ ix <<= 1;
+ m -= i - 1;
+ }
+ m -= 127; /* unbias exponent */
+ ix = (ix & 0x007fffff) | 0x00800000;
+ if (m & 1) /* odd m, double x to make it even */
+ ix += ix;
+ m >>= 1; /* m = [m/2] */
- /* generate sqrt(x) bit by bit */
- ix += ix;
- q = s = 0; /* q = sqrt(x) */
- r = 0x01000000; /* r = moving bit from right to left */
+ /* generate sqrt(x) bit by bit */
+ ix += ix;
+ q = s = 0; /* q = sqrt(x) */
+ r = 0x01000000; /* r = moving bit from right to left */
- while (r != 0) {
- t = s + r;
- if (t <= ix) {
- s = t+r;
- ix -= t;
- q += r;
- }
- ix += ix;
- r >>= 1;
- }
+ while (r != 0) {
+ t = s + r;
+ if (t <= ix) {
+ s = t + r;
+ ix -= t;
+ q += r;
+ }
+ ix += ix;
+ r >>= 1;
+ }
- /* use floating add to find out rounding direction */
- if (ix != 0) {
- z = 1.0f - tiny; /* raise inexact flag */
- if (z >= 1.0f) {
- z = 1.0f + tiny;
- if (z > 1.0f)
- q += 2;
- else
- q += q & 1;
- }
- }
- ix = (q>>1) + 0x3f000000;
- ix += m << 23;
- SET_FLOAT_WORD(z, ix);
- return z;
+ /* use floating add to find out rounding direction */
+ if (ix != 0) {
+ z = 1.0f - tiny; /* raise inexact flag */
+ if (z >= 1.0f) {
+ z = 1.0f + tiny;
+ if (z > 1.0f)
+ q += 2;
+ else
+ q += q & 1;
+ }
+ }
+ ix = (q >> 1) + 0x3f000000;
+ ix += m << 23;
+ SET_FLOAT_WORD(z, ix);
+ return z;
}
diff --git a/fusl/src/math/sqrtl.c b/fusl/src/math/sqrtl.c
index 83a8f80..f21f907 100644
--- a/fusl/src/math/sqrtl.c
+++ b/fusl/src/math/sqrtl.c
@@ -1,7 +1,6 @@
#include <math.h>
-long double sqrtl(long double x)
-{
- /* FIXME: implement in C, this is for LDBL_MANT_DIG == 64 only */
- return sqrt(x);
+long double sqrtl(long double x) {
+ /* FIXME: implement in C, this is for LDBL_MANT_DIG == 64 only */
+ return sqrt(x);
}
diff --git a/fusl/src/math/tan.c b/fusl/src/math/tan.c
index 9c724a4..b1da8a4 100644
--- a/fusl/src/math/tan.c
+++ b/fusl/src/math/tan.c
@@ -41,30 +41,29 @@
#include "libm.h"
-double tan(double x)
-{
- double y[2];
- uint32_t ix;
- unsigned n;
+double tan(double x) {
+ double y[2];
+ uint32_t ix;
+ unsigned n;
- GET_HIGH_WORD(ix, x);
- ix &= 0x7fffffff;
+ GET_HIGH_WORD(ix, x);
+ ix &= 0x7fffffff;
- /* |x| ~< pi/4 */
- if (ix <= 0x3fe921fb) {
- if (ix < 0x3e400000) { /* |x| < 2**-27 */
- /* raise inexact if x!=0 and underflow if subnormal */
- FORCE_EVAL(ix < 0x00100000 ? x/0x1p120f : x+0x1p120f);
- return x;
- }
- return __tan(x, 0.0, 0);
- }
+ /* |x| ~< pi/4 */
+ if (ix <= 0x3fe921fb) {
+ if (ix < 0x3e400000) { /* |x| < 2**-27 */
+ /* raise inexact if x!=0 and underflow if subnormal */
+ FORCE_EVAL(ix < 0x00100000 ? x / 0x1p120f : x + 0x1p120f);
+ return x;
+ }
+ return __tan(x, 0.0, 0);
+ }
- /* tan(Inf or NaN) is NaN */
- if (ix >= 0x7ff00000)
- return x - x;
+ /* tan(Inf or NaN) is NaN */
+ if (ix >= 0x7ff00000)
+ return x - x;
- /* argument reduction */
- n = __rem_pio2(x, y);
- return __tan(y[0], y[1], n&1);
+ /* argument reduction */
+ n = __rem_pio2(x, y);
+ return __tan(y[0], y[1], n & 1);
}
diff --git a/fusl/src/math/tanf.c b/fusl/src/math/tanf.c
index aba1977..04d86c3 100644
--- a/fusl/src/math/tanf.c
+++ b/fusl/src/math/tanf.c
@@ -17,48 +17,46 @@
#include "libm.h"
/* Small multiples of pi/2 rounded to double precision. */
-static const double
-t1pio2 = 1*M_PI_2, /* 0x3FF921FB, 0x54442D18 */
-t2pio2 = 2*M_PI_2, /* 0x400921FB, 0x54442D18 */
-t3pio2 = 3*M_PI_2, /* 0x4012D97C, 0x7F3321D2 */
-t4pio2 = 4*M_PI_2; /* 0x401921FB, 0x54442D18 */
+static const double t1pio2 = 1 * M_PI_2, /* 0x3FF921FB, 0x54442D18 */
+ t2pio2 = 2 * M_PI_2, /* 0x400921FB, 0x54442D18 */
+ t3pio2 = 3 * M_PI_2, /* 0x4012D97C, 0x7F3321D2 */
+ t4pio2 = 4 * M_PI_2; /* 0x401921FB, 0x54442D18 */
-float tanf(float x)
-{
- double y;
- uint32_t ix;
- unsigned n, sign;
+float tanf(float x) {
+ double y;
+ uint32_t ix;
+ unsigned n, sign;
- GET_FLOAT_WORD(ix, x);
- sign = ix >> 31;
- ix &= 0x7fffffff;
+ GET_FLOAT_WORD(ix, x);
+ sign = ix >> 31;
+ ix &= 0x7fffffff;
- if (ix <= 0x3f490fda) { /* |x| ~<= pi/4 */
- if (ix < 0x39800000) { /* |x| < 2**-12 */
- /* raise inexact if x!=0 and underflow if subnormal */
- FORCE_EVAL(ix < 0x00800000 ? x/0x1p120f : x+0x1p120f);
- return x;
- }
- return __tandf(x, 0);
- }
- if (ix <= 0x407b53d1) { /* |x| ~<= 5*pi/4 */
- if (ix <= 0x4016cbe3) /* |x| ~<= 3pi/4 */
- return __tandf((sign ? x+t1pio2 : x-t1pio2), 1);
- else
- return __tandf((sign ? x+t2pio2 : x-t2pio2), 0);
- }
- if (ix <= 0x40e231d5) { /* |x| ~<= 9*pi/4 */
- if (ix <= 0x40afeddf) /* |x| ~<= 7*pi/4 */
- return __tandf((sign ? x+t3pio2 : x-t3pio2), 1);
- else
- return __tandf((sign ? x+t4pio2 : x-t4pio2), 0);
- }
+ if (ix <= 0x3f490fda) { /* |x| ~<= pi/4 */
+ if (ix < 0x39800000) { /* |x| < 2**-12 */
+ /* raise inexact if x!=0 and underflow if subnormal */
+ FORCE_EVAL(ix < 0x00800000 ? x / 0x1p120f : x + 0x1p120f);
+ return x;
+ }
+ return __tandf(x, 0);
+ }
+ if (ix <= 0x407b53d1) { /* |x| ~<= 5*pi/4 */
+ if (ix <= 0x4016cbe3) /* |x| ~<= 3pi/4 */
+ return __tandf((sign ? x + t1pio2 : x - t1pio2), 1);
+ else
+ return __tandf((sign ? x + t2pio2 : x - t2pio2), 0);
+ }
+ if (ix <= 0x40e231d5) { /* |x| ~<= 9*pi/4 */
+ if (ix <= 0x40afeddf) /* |x| ~<= 7*pi/4 */
+ return __tandf((sign ? x + t3pio2 : x - t3pio2), 1);
+ else
+ return __tandf((sign ? x + t4pio2 : x - t4pio2), 0);
+ }
- /* tan(Inf or NaN) is NaN */
- if (ix >= 0x7f800000)
- return x - x;
+ /* tan(Inf or NaN) is NaN */
+ if (ix >= 0x7f800000)
+ return x - x;
- /* argument reduction */
- n = __rem_pio2f(x, &y);
- return __tandf(y, n&1);
+ /* argument reduction */
+ n = __rem_pio2f(x, &y);
+ return __tandf(y, n & 1);
}
diff --git a/fusl/src/math/tanh.c b/fusl/src/math/tanh.c
index 20d6dbc..13fe2f6 100644
--- a/fusl/src/math/tanh.c
+++ b/fusl/src/math/tanh.c
@@ -4,42 +4,45 @@
* = (exp(2*x) - 1)/(exp(2*x) - 1 + 2)
* = (1 - exp(-2*x))/(exp(-2*x) - 1 + 2)
*/
-double tanh(double x)
-{
- union {double f; uint64_t i;} u = {.f = x};
- uint32_t w;
- int sign;
- double_t t;
+double tanh(double x) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {.f = x};
+ uint32_t w;
+ int sign;
+ double_t t;
- /* x = |x| */
- sign = u.i >> 63;
- u.i &= (uint64_t)-1/2;
- x = u.f;
- w = u.i >> 32;
+ /* x = |x| */
+ sign = u.i >> 63;
+ u.i &= (uint64_t)-1 / 2;
+ x = u.f;
+ w = u.i >> 32;
- if (w > 0x3fe193ea) {
- /* |x| > log(3)/2 ~= 0.5493 or nan */
- if (w > 0x40340000) {
- /* |x| > 20 or nan */
- /* note: this branch avoids raising overflow */
- t = 1 - 0/x;
- } else {
- t = expm1(2*x);
- t = 1 - 2/(t+2);
- }
- } else if (w > 0x3fd058ae) {
- /* |x| > log(5/3)/2 ~= 0.2554 */
- t = expm1(2*x);
- t = t/(t+2);
- } else if (w >= 0x00100000) {
- /* |x| >= 0x1p-1022, up to 2ulp error in [0.1,0.2554] */
- t = expm1(-2*x);
- t = -t/(t+2);
- } else {
- /* |x| is subnormal */
- /* note: the branch above would not raise underflow in [0x1p-1023,0x1p-1022) */
- FORCE_EVAL((float)x);
- t = x;
- }
- return sign ? -t : t;
+ if (w > 0x3fe193ea) {
+ /* |x| > log(3)/2 ~= 0.5493 or nan */
+ if (w > 0x40340000) {
+ /* |x| > 20 or nan */
+ /* note: this branch avoids raising overflow */
+ t = 1 - 0 / x;
+ } else {
+ t = expm1(2 * x);
+ t = 1 - 2 / (t + 2);
+ }
+ } else if (w > 0x3fd058ae) {
+ /* |x| > log(5/3)/2 ~= 0.2554 */
+ t = expm1(2 * x);
+ t = t / (t + 2);
+ } else if (w >= 0x00100000) {
+ /* |x| >= 0x1p-1022, up to 2ulp error in [0.1,0.2554] */
+ t = expm1(-2 * x);
+ t = -t / (t + 2);
+ } else {
+ /* |x| is subnormal */
+ /* note: the branch above would not raise underflow in [0x1p-1023,0x1p-1022)
+ */
+ FORCE_EVAL((float)x);
+ t = x;
+ }
+ return sign ? -t : t;
}
diff --git a/fusl/src/math/tanhf.c b/fusl/src/math/tanhf.c
index 10636fb..7c57ccf 100644
--- a/fusl/src/math/tanhf.c
+++ b/fusl/src/math/tanhf.c
@@ -1,39 +1,41 @@
#include "libm.h"
-float tanhf(float x)
-{
- union {float f; uint32_t i;} u = {.f = x};
- uint32_t w;
- int sign;
- float t;
+float tanhf(float x) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {.f = x};
+ uint32_t w;
+ int sign;
+ float t;
- /* x = |x| */
- sign = u.i >> 31;
- u.i &= 0x7fffffff;
- x = u.f;
- w = u.i;
+ /* x = |x| */
+ sign = u.i >> 31;
+ u.i &= 0x7fffffff;
+ x = u.f;
+ w = u.i;
- if (w > 0x3f0c9f54) {
- /* |x| > log(3)/2 ~= 0.5493 or nan */
- if (w > 0x41200000) {
- /* |x| > 10 */
- t = 1 + 0/x;
- } else {
- t = expm1f(2*x);
- t = 1 - 2/(t+2);
- }
- } else if (w > 0x3e82c578) {
- /* |x| > log(5/3)/2 ~= 0.2554 */
- t = expm1f(2*x);
- t = t/(t+2);
- } else if (w >= 0x00800000) {
- /* |x| >= 0x1p-126 */
- t = expm1f(-2*x);
- t = -t/(t+2);
- } else {
- /* |x| is subnormal */
- FORCE_EVAL(x*x);
- t = x;
- }
- return sign ? -t : t;
+ if (w > 0x3f0c9f54) {
+ /* |x| > log(3)/2 ~= 0.5493 or nan */
+ if (w > 0x41200000) {
+ /* |x| > 10 */
+ t = 1 + 0 / x;
+ } else {
+ t = expm1f(2 * x);
+ t = 1 - 2 / (t + 2);
+ }
+ } else if (w > 0x3e82c578) {
+ /* |x| > log(5/3)/2 ~= 0.2554 */
+ t = expm1f(2 * x);
+ t = t / (t + 2);
+ } else if (w >= 0x00800000) {
+ /* |x| >= 0x1p-126 */
+ t = expm1f(-2 * x);
+ t = -t / (t + 2);
+ } else {
+ /* |x| is subnormal */
+ FORCE_EVAL(x * x);
+ t = x;
+ }
+ return sign ? -t : t;
}
diff --git a/fusl/src/math/tanhl.c b/fusl/src/math/tanhl.c
index 4e1aa9f..64389b1 100644
--- a/fusl/src/math/tanhl.c
+++ b/fusl/src/math/tanhl.c
@@ -1,48 +1,45 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double tanhl(long double x)
-{
- return tanh(x);
+long double tanhl(long double x) {
+ return tanh(x);
}
#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
-long double tanhl(long double x)
-{
- union ldshape u = {x};
- unsigned ex = u.i.se & 0x7fff;
- unsigned sign = u.i.se & 0x8000;
- uint32_t w;
- long double t;
+long double tanhl(long double x) {
+ union ldshape u = {x};
+ unsigned ex = u.i.se & 0x7fff;
+ unsigned sign = u.i.se & 0x8000;
+ uint32_t w;
+ long double t;
- /* x = |x| */
- u.i.se = ex;
- x = u.f;
- w = u.i.m >> 32;
+ /* x = |x| */
+ u.i.se = ex;
+ x = u.f;
+ w = u.i.m >> 32;
- if (ex > 0x3ffe || (ex == 0x3ffe && w > 0x8c9f53d5)) {
- /* |x| > log(3)/2 ~= 0.5493 or nan */
- if (ex >= 0x3fff+5) {
- /* |x| >= 32 */
- t = 1 + 0/(x + 0x1p-120f);
- } else {
- t = expm1l(2*x);
- t = 1 - 2/(t+2);
- }
- } else if (ex > 0x3ffd || (ex == 0x3ffd && w > 0x82c577d4)) {
- /* |x| > log(5/3)/2 ~= 0.2554 */
- t = expm1l(2*x);
- t = t/(t+2);
- } else {
- /* |x| is small */
- t = expm1l(-2*x);
- t = -t/(t+2);
- }
- return sign ? -t : t;
+ if (ex > 0x3ffe || (ex == 0x3ffe && w > 0x8c9f53d5)) {
+ /* |x| > log(3)/2 ~= 0.5493 or nan */
+ if (ex >= 0x3fff + 5) {
+ /* |x| >= 32 */
+ t = 1 + 0 / (x + 0x1p-120f);
+ } else {
+ t = expm1l(2 * x);
+ t = 1 - 2 / (t + 2);
+ }
+ } else if (ex > 0x3ffd || (ex == 0x3ffd && w > 0x82c577d4)) {
+ /* |x| > log(5/3)/2 ~= 0.2554 */
+ t = expm1l(2 * x);
+ t = t / (t + 2);
+ } else {
+ /* |x| is small */
+ t = expm1l(-2 * x);
+ t = -t / (t + 2);
+ }
+ return sign ? -t : t;
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
// TODO: broken implementation to make things compile
-long double tanhl(long double x)
-{
- return tanh(x);
+long double tanhl(long double x) {
+ return tanh(x);
}
#endif
diff --git a/fusl/src/math/tanl.c b/fusl/src/math/tanl.c
index 6af0671..7888309 100644
--- a/fusl/src/math/tanl.c
+++ b/fusl/src/math/tanl.c
@@ -1,29 +1,27 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double tanl(long double x)
-{
- return tan(x);
+long double tanl(long double x) {
+ return tan(x);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-long double tanl(long double x)
-{
- union ldshape u = {x};
- long double y[2];
- unsigned n;
+long double tanl(long double x) {
+ union ldshape u = {x};
+ long double y[2];
+ unsigned n;
- u.i.se &= 0x7fff;
- if (u.i.se == 0x7fff)
- return x - x;
- if (u.f < M_PI_4) {
- if (u.i.se < 0x3fff - LDBL_MANT_DIG/2) {
- /* raise inexact if x!=0 and underflow if subnormal */
- FORCE_EVAL(u.i.se == 0 ? x*0x1p-120f : x+0x1p120f);
- return x;
- }
- return __tanl(x, 0, 0);
- }
- n = __rem_pio2l(x, y);
- return __tanl(y[0], y[1], n&1);
+ u.i.se &= 0x7fff;
+ if (u.i.se == 0x7fff)
+ return x - x;
+ if (u.f < M_PI_4) {
+ if (u.i.se < 0x3fff - LDBL_MANT_DIG / 2) {
+ /* raise inexact if x!=0 and underflow if subnormal */
+ FORCE_EVAL(u.i.se == 0 ? x * 0x1p-120f : x + 0x1p120f);
+ return x;
+ }
+ return __tanl(x, 0, 0);
+ }
+ n = __rem_pio2l(x, y);
+ return __tanl(y[0], y[1], n & 1);
}
#endif
diff --git a/fusl/src/math/tgamma.c b/fusl/src/math/tgamma.c
index 28f6e0f..feb0616 100644
--- a/fusl/src/math/tgamma.c
+++ b/fusl/src/math/tgamma.c
@@ -27,147 +27,166 @@
static const double pi = 3.141592653589793238462643383279502884;
/* sin(pi x) with x > 0x1p-100, if sin(pi*x)==0 the sign is arbitrary */
-static double sinpi(double x)
-{
- int n;
+static double sinpi(double x) {
+ int n;
- /* argument reduction: x = |x| mod 2 */
- /* spurious inexact when x is odd int */
- x = x * 0.5;
- x = 2 * (x - floor(x));
+ /* argument reduction: x = |x| mod 2 */
+ /* spurious inexact when x is odd int */
+ x = x * 0.5;
+ x = 2 * (x - floor(x));
- /* reduce x into [-.25,.25] */
- n = 4 * x;
- n = (n+1)/2;
- x -= n * 0.5;
+ /* reduce x into [-.25,.25] */
+ n = 4 * x;
+ n = (n + 1) / 2;
+ x -= n * 0.5;
- x *= pi;
- switch (n) {
- default: /* case 4 */
- case 0:
- return __sin(x, 0, 0);
- case 1:
- return __cos(x, 0);
- case 2:
- return __sin(-x, 0, 0);
- case 3:
- return -__cos(x, 0);
- }
+ x *= pi;
+ switch (n) {
+ default: /* case 4 */
+ case 0:
+ return __sin(x, 0, 0);
+ case 1:
+ return __cos(x, 0);
+ case 2:
+ return __sin(-x, 0, 0);
+ case 3:
+ return -__cos(x, 0);
+ }
}
#define N 12
-//static const double g = 6.024680040776729583740234375;
+// static const double g = 6.024680040776729583740234375;
static const double gmhalf = 5.524680040776729583740234375;
-static const double Snum[N+1] = {
- 23531376880.410759688572007674451636754734846804940,
- 42919803642.649098768957899047001988850926355848959,
- 35711959237.355668049440185451547166705960488635843,
- 17921034426.037209699919755754458931112671403265390,
- 6039542586.3520280050642916443072979210699388420708,
- 1439720407.3117216736632230727949123939715485786772,
- 248874557.86205415651146038641322942321632125127801,
- 31426415.585400194380614231628318205362874684987640,
- 2876370.6289353724412254090516208496135991145378768,
- 186056.26539522349504029498971604569928220784236328,
- 8071.6720023658162106380029022722506138218516325024,
- 210.82427775157934587250973392071336271166969580291,
- 2.5066282746310002701649081771338373386264310793408,
+static const double Snum[N + 1] = {
+ 23531376880.410759688572007674451636754734846804940,
+ 42919803642.649098768957899047001988850926355848959,
+ 35711959237.355668049440185451547166705960488635843,
+ 17921034426.037209699919755754458931112671403265390,
+ 6039542586.3520280050642916443072979210699388420708,
+ 1439720407.3117216736632230727949123939715485786772,
+ 248874557.86205415651146038641322942321632125127801,
+ 31426415.585400194380614231628318205362874684987640,
+ 2876370.6289353724412254090516208496135991145378768,
+ 186056.26539522349504029498971604569928220784236328,
+ 8071.6720023658162106380029022722506138218516325024,
+ 210.82427775157934587250973392071336271166969580291,
+ 2.5066282746310002701649081771338373386264310793408,
};
-static const double Sden[N+1] = {
- 0, 39916800, 120543840, 150917976, 105258076, 45995730, 13339535,
- 2637558, 357423, 32670, 1925, 66, 1,
+static const double Sden[N + 1] = {
+ 0, 39916800, 120543840, 150917976, 105258076, 45995730, 13339535,
+ 2637558, 357423, 32670, 1925, 66, 1,
};
/* n! for small integer n */
static const double fact[] = {
- 1, 1, 2, 6, 24, 120, 720, 5040.0, 40320.0, 362880.0, 3628800.0, 39916800.0,
- 479001600.0, 6227020800.0, 87178291200.0, 1307674368000.0, 20922789888000.0,
- 355687428096000.0, 6402373705728000.0, 121645100408832000.0,
- 2432902008176640000.0, 51090942171709440000.0, 1124000727777607680000.0,
+ 1,
+ 1,
+ 2,
+ 6,
+ 24,
+ 120,
+ 720,
+ 5040.0,
+ 40320.0,
+ 362880.0,
+ 3628800.0,
+ 39916800.0,
+ 479001600.0,
+ 6227020800.0,
+ 87178291200.0,
+ 1307674368000.0,
+ 20922789888000.0,
+ 355687428096000.0,
+ 6402373705728000.0,
+ 121645100408832000.0,
+ 2432902008176640000.0,
+ 51090942171709440000.0,
+ 1124000727777607680000.0,
};
/* S(x) rational function for positive x */
-static double S(double x)
-{
- double_t num = 0, den = 0;
- int i;
+static double S(double x) {
+ double_t num = 0, den = 0;
+ int i;
- /* to avoid overflow handle large x differently */
- if (x < 8)
- for (i = N; i >= 0; i--) {
- num = num * x + Snum[i];
- den = den * x + Sden[i];
- }
- else
- for (i = 0; i <= N; i++) {
- num = num / x + Snum[i];
- den = den / x + Sden[i];
- }
- return num/den;
+ /* to avoid overflow handle large x differently */
+ if (x < 8)
+ for (i = N; i >= 0; i--) {
+ num = num * x + Snum[i];
+ den = den * x + Sden[i];
+ }
+ else
+ for (i = 0; i <= N; i++) {
+ num = num / x + Snum[i];
+ den = den / x + Sden[i];
+ }
+ return num / den;
}
-double tgamma(double x)
-{
- union {double f; uint64_t i;} u = {x};
- double absx, y;
- double_t dy, z, r;
- uint32_t ix = u.i>>32 & 0x7fffffff;
- int sign = u.i>>63;
+double tgamma(double x) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {x};
+ double absx, y;
+ double_t dy, z, r;
+ uint32_t ix = u.i >> 32 & 0x7fffffff;
+ int sign = u.i >> 63;
- /* special cases */
- if (ix >= 0x7ff00000)
- /* tgamma(nan)=nan, tgamma(inf)=inf, tgamma(-inf)=nan with invalid */
- return x + INFINITY;
- if (ix < (0x3ff-54)<<20)
- /* |x| < 2^-54: tgamma(x) ~ 1/x, +-0 raises div-by-zero */
- return 1/x;
+ /* special cases */
+ if (ix >= 0x7ff00000)
+ /* tgamma(nan)=nan, tgamma(inf)=inf, tgamma(-inf)=nan with invalid */
+ return x + INFINITY;
+ if (ix < (0x3ff - 54) << 20)
+ /* |x| < 2^-54: tgamma(x) ~ 1/x, +-0 raises div-by-zero */
+ return 1 / x;
- /* integer arguments */
- /* raise inexact when non-integer */
- if (x == floor(x)) {
- if (sign)
- return 0/0.0;
- if (x <= sizeof fact/sizeof *fact)
- return fact[(int)x - 1];
- }
+ /* integer arguments */
+ /* raise inexact when non-integer */
+ if (x == floor(x)) {
+ if (sign)
+ return 0 / 0.0;
+ if (x <= sizeof fact / sizeof *fact)
+ return fact[(int)x - 1];
+ }
- /* x >= 172: tgamma(x)=inf with overflow */
- /* x =< -184: tgamma(x)=+-0 with underflow */
- if (ix >= 0x40670000) { /* |x| >= 184 */
- if (sign) {
- FORCE_EVAL((float)(0x1p-126/x));
- if (floor(x) * 0.5 == floor(x * 0.5))
- return 0;
- return -0.0;
- }
- x *= 0x1p1023;
- return x;
- }
+ /* x >= 172: tgamma(x)=inf with overflow */
+ /* x =< -184: tgamma(x)=+-0 with underflow */
+ if (ix >= 0x40670000) { /* |x| >= 184 */
+ if (sign) {
+ FORCE_EVAL((float)(0x1p-126 / x));
+ if (floor(x) * 0.5 == floor(x * 0.5))
+ return 0;
+ return -0.0;
+ }
+ x *= 0x1p1023;
+ return x;
+ }
- absx = sign ? -x : x;
+ absx = sign ? -x : x;
- /* handle the error of x + g - 0.5 */
- y = absx + gmhalf;
- if (absx > gmhalf) {
- dy = y - absx;
- dy -= gmhalf;
- } else {
- dy = y - gmhalf;
- dy -= absx;
- }
+ /* handle the error of x + g - 0.5 */
+ y = absx + gmhalf;
+ if (absx > gmhalf) {
+ dy = y - absx;
+ dy -= gmhalf;
+ } else {
+ dy = y - gmhalf;
+ dy -= absx;
+ }
- z = absx - 0.5;
- r = S(absx) * exp(-y);
- if (x < 0) {
- /* reflection formula for negative x */
- /* sinpi(absx) is not 0, integers are already handled */
- r = -pi / (sinpi(absx) * absx * r);
- dy = -dy;
- z = -z;
- }
- r += dy * (gmhalf+0.5) * r / y;
- z = pow(y, 0.5*z);
- y = r * z * z;
- return y;
+ z = absx - 0.5;
+ r = S(absx) * exp(-y);
+ if (x < 0) {
+ /* reflection formula for negative x */
+ /* sinpi(absx) is not 0, integers are already handled */
+ r = -pi / (sinpi(absx) * absx * r);
+ dy = -dy;
+ z = -z;
+ }
+ r += dy * (gmhalf + 0.5) * r / y;
+ z = pow(y, 0.5 * z);
+ y = r * z * z;
+ return y;
}
#if 0
diff --git a/fusl/src/math/tgammaf.c b/fusl/src/math/tgammaf.c
index b4ca51c..6d8d33f 100644
--- a/fusl/src/math/tgammaf.c
+++ b/fusl/src/math/tgammaf.c
@@ -1,6 +1,5 @@
#include <math.h>
-float tgammaf(float x)
-{
- return tgamma(x);
+float tgammaf(float x) {
+ return tgamma(x);
}
diff --git a/fusl/src/math/tgammal.c b/fusl/src/math/tgammal.c
index 5336c5b..9708929 100644
--- a/fusl/src/math/tgammal.c
+++ b/fusl/src/math/tgammal.c
@@ -51,9 +51,8 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double tgammal(long double x)
-{
- return tgamma(x);
+long double tgammal(long double x) {
+ return tgamma(x);
}
#elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
/*
@@ -65,25 +64,17 @@
Relative error spread = 8.4e-23
*/
static const long double P[8] = {
- 4.212760487471622013093E-5L,
- 4.542931960608009155600E-4L,
- 4.092666828394035500949E-3L,
- 2.385363243461108252554E-2L,
- 1.113062816019361559013E-1L,
- 3.629515436640239168939E-1L,
- 8.378004301573126728826E-1L,
- 1.000000000000000000009E0L,
+ 4.212760487471622013093E-5L, 4.542931960608009155600E-4L,
+ 4.092666828394035500949E-3L, 2.385363243461108252554E-2L,
+ 1.113062816019361559013E-1L, 3.629515436640239168939E-1L,
+ 8.378004301573126728826E-1L, 1.000000000000000000009E0L,
};
static const long double Q[9] = {
--1.397148517476170440917E-5L,
- 2.346584059160635244282E-4L,
--1.237799246653152231188E-3L,
--7.955933682494738320586E-4L,
- 2.773706565840072979165E-2L,
--4.633887671244534213831E-2L,
--2.243510905670329164562E-1L,
- 4.150160950588455434583E-1L,
- 9.999999999999999999908E-1L,
+ -1.397148517476170440917E-5L, 2.346584059160635244282E-4L,
+ -1.237799246653152231188E-3L, -7.955933682494738320586E-4L,
+ 2.773706565840072979165E-2L, -4.633887671244534213831E-2L,
+ -2.243510905670329164562E-1L, 4.150160950588455434583E-1L,
+ 9.999999999999999999908E-1L,
};
/*
@@ -122,15 +113,11 @@
Relative error spread = 8.8e-4
*/
static const long double STIR[9] = {
- 7.147391378143610789273E-4L,
--2.363848809501759061727E-5L,
--5.950237554056330156018E-4L,
- 6.989332260623193171870E-5L,
- 7.840334842744753003862E-4L,
--2.294719747873185405699E-4L,
--2.681327161876304418288E-3L,
- 3.472222222230075327854E-3L,
- 8.333333333333331800504E-2L,
+ 7.147391378143610789273E-4L, -2.363848809501759061727E-5L,
+ -5.950237554056330156018E-4L, 6.989332260623193171870E-5L,
+ 7.840334842744753003862E-4L, -2.294719747873185405699E-4L,
+ -2.681327161876304418288E-3L, 3.472222222230075327854E-3L,
+ 8.333333333333331800504E-2L,
};
#define MAXSTIR 1024.0L
@@ -142,15 +129,11 @@
* Peak relative error 4.2e-23
*/
static const long double S[9] = {
--1.193945051381510095614E-3L,
- 7.220599478036909672331E-3L,
--9.622023360406271645744E-3L,
--4.219773360705915470089E-2L,
- 1.665386113720805206758E-1L,
--4.200263503403344054473E-2L,
--6.558780715202540684668E-1L,
- 5.772156649015328608253E-1L,
- 1.000000000000000000000E0L,
+ -1.193945051381510095614E-3L, 7.220599478036909672331E-3L,
+ -9.622023360406271645744E-3L, -4.219773360705915470089E-2L,
+ 1.665386113720805206758E-1L, -4.200263503403344054473E-2L,
+ -6.558780715202540684668E-1L, 5.772156649015328608253E-1L,
+ 1.000000000000000000000E0L,
};
/* 1/tgamma(-x) = z P(z)
@@ -160,122 +143,118 @@
* Relative error spread = 2.5e-24
*/
static const long double SN[9] = {
- 1.133374167243894382010E-3L,
- 7.220837261893170325704E-3L,
- 9.621911155035976733706E-3L,
--4.219773343731191721664E-2L,
--1.665386113944413519335E-1L,
--4.200263503402112910504E-2L,
- 6.558780715202536547116E-1L,
- 5.772156649015328608727E-1L,
--1.000000000000000000000E0L,
+ 1.133374167243894382010E-3L, 7.220837261893170325704E-3L,
+ 9.621911155035976733706E-3L, -4.219773343731191721664E-2L,
+ -1.665386113944413519335E-1L, -4.200263503402112910504E-2L,
+ 6.558780715202536547116E-1L, 5.772156649015328608727E-1L,
+ -1.000000000000000000000E0L,
};
static const long double PIL = 3.1415926535897932384626L;
/* Gamma function computed by Stirling's formula.
*/
-static long double stirf(long double x)
-{
- long double y, w, v;
+static long double stirf(long double x) {
+ long double y, w, v;
- w = 1.0/x;
- /* For large x, use rational coefficients from the analytical expansion. */
- if (x > 1024.0)
- w = (((((6.97281375836585777429E-5L * w
- + 7.84039221720066627474E-4L) * w
- - 2.29472093621399176955E-4L) * w
- - 2.68132716049382716049E-3L) * w
- + 3.47222222222222222222E-3L) * w
- + 8.33333333333333333333E-2L) * w
- + 1.0;
- else
- w = 1.0 + w * __polevll(w, STIR, 8);
- y = expl(x);
- if (x > MAXSTIR) { /* Avoid overflow in pow() */
- v = powl(x, 0.5L * x - 0.25L);
- y = v * (v / y);
- } else {
- y = powl(x, x - 0.5L) / y;
- }
- y = SQTPI * y * w;
- return y;
+ w = 1.0 / x;
+ /* For large x, use rational coefficients from the analytical expansion. */
+ if (x > 1024.0)
+ w = (((((6.97281375836585777429E-5L * w + 7.84039221720066627474E-4L) * w -
+ 2.29472093621399176955E-4L) *
+ w -
+ 2.68132716049382716049E-3L) *
+ w +
+ 3.47222222222222222222E-3L) *
+ w +
+ 8.33333333333333333333E-2L) *
+ w +
+ 1.0;
+ else
+ w = 1.0 + w * __polevll(w, STIR, 8);
+ y = expl(x);
+ if (x > MAXSTIR) { /* Avoid overflow in pow() */
+ v = powl(x, 0.5L * x - 0.25L);
+ y = v * (v / y);
+ } else {
+ y = powl(x, x - 0.5L) / y;
+ }
+ y = SQTPI * y * w;
+ return y;
}
-long double tgammal(long double x)
-{
- long double p, q, z;
+long double tgammal(long double x) {
+ long double p, q, z;
- if (!isfinite(x))
- return x + INFINITY;
+ if (!isfinite(x))
+ return x + INFINITY;
- q = fabsl(x);
- if (q > 13.0) {
- if (x < 0.0) {
- p = floorl(q);
- z = q - p;
- if (z == 0)
- return 0 / z;
- if (q > MAXGAML) {
- z = 0;
- } else {
- if (z > 0.5) {
- p += 1.0;
- z = q - p;
- }
- z = q * sinl(PIL * z);
- z = fabsl(z) * stirf(q);
- z = PIL/z;
- }
- if (0.5 * p == floorl(q * 0.5))
- z = -z;
- } else if (x > MAXGAML) {
- z = x * 0x1p16383L;
- } else {
- z = stirf(x);
- }
- return z;
- }
+ q = fabsl(x);
+ if (q > 13.0) {
+ if (x < 0.0) {
+ p = floorl(q);
+ z = q - p;
+ if (z == 0)
+ return 0 / z;
+ if (q > MAXGAML) {
+ z = 0;
+ } else {
+ if (z > 0.5) {
+ p += 1.0;
+ z = q - p;
+ }
+ z = q * sinl(PIL * z);
+ z = fabsl(z) * stirf(q);
+ z = PIL / z;
+ }
+ if (0.5 * p == floorl(q * 0.5))
+ z = -z;
+ } else if (x > MAXGAML) {
+ z = x * 0x1p16383L;
+ } else {
+ z = stirf(x);
+ }
+ return z;
+ }
- z = 1.0;
- while (x >= 3.0) {
- x -= 1.0;
- z *= x;
- }
- while (x < -0.03125L) {
- z /= x;
- x += 1.0;
- }
- if (x <= 0.03125L)
- goto small;
- while (x < 2.0) {
- z /= x;
- x += 1.0;
- }
- if (x == 2.0)
- return z;
+ z = 1.0;
+ while (x >= 3.0) {
+ x -= 1.0;
+ z *= x;
+ }
+ while (x < -0.03125L) {
+ z /= x;
+ x += 1.0;
+ }
+ if (x <= 0.03125L)
+ goto small;
+ while (x < 2.0) {
+ z /= x;
+ x += 1.0;
+ }
+ if (x == 2.0)
+ return z;
- x -= 2.0;
- p = __polevll(x, P, 7);
- q = __polevll(x, Q, 8);
- z = z * p / q;
- return z;
+ x -= 2.0;
+ p = __polevll(x, P, 7);
+ q = __polevll(x, Q, 8);
+ z = z * p / q;
+ return z;
small:
- /* z==1 if x was originally +-0 */
- if (x == 0 && z != 1)
- return x / x;
- if (x < 0.0) {
- x = -x;
- q = z / (x * __polevll(x, SN, 8));
- } else
- q = z / (x * __polevll(x, S, 8));
- return q;
+ /* z==1 if x was originally +-0 */
+ if (x == 0 && z != 1)
+ return x / x;
+ if (x < 0.0) {
+ x = -x;
+ q = z / (x * __polevll(x, SN, 8));
+ } else
+ q = z / (x * __polevll(x, S, 8));
+ return q;
}
#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
// TODO: broken implementation to make things compile
-long double tgammal(long double x)
-{
- return tgamma(x);
+long double tgammal(long double x) {
+ return tgamma(x);
}
#endif
diff --git a/fusl/src/math/trunc.c b/fusl/src/math/trunc.c
index d13711b..48c3589 100644
--- a/fusl/src/math/trunc.c
+++ b/fusl/src/math/trunc.c
@@ -1,19 +1,21 @@
#include "libm.h"
-double trunc(double x)
-{
- union {double f; uint64_t i;} u = {x};
- int e = (int)(u.i >> 52 & 0x7ff) - 0x3ff + 12;
- uint64_t m;
+double trunc(double x) {
+ union {
+ double f;
+ uint64_t i;
+ } u = {x};
+ int e = (int)(u.i >> 52 & 0x7ff) - 0x3ff + 12;
+ uint64_t m;
- if (e >= 52 + 12)
- return x;
- if (e < 12)
- e = 1;
- m = -1ULL >> e;
- if ((u.i & m) == 0)
- return x;
- FORCE_EVAL(x + 0x1p120f);
- u.i &= ~m;
- return u.f;
+ if (e >= 52 + 12)
+ return x;
+ if (e < 12)
+ e = 1;
+ m = -1ULL >> e;
+ if ((u.i & m) == 0)
+ return x;
+ FORCE_EVAL(x + 0x1p120f);
+ u.i &= ~m;
+ return u.f;
}
diff --git a/fusl/src/math/truncf.c b/fusl/src/math/truncf.c
index 1a7d03c..a703662 100644
--- a/fusl/src/math/truncf.c
+++ b/fusl/src/math/truncf.c
@@ -1,19 +1,21 @@
#include "libm.h"
-float truncf(float x)
-{
- union {float f; uint32_t i;} u = {x};
- int e = (int)(u.i >> 23 & 0xff) - 0x7f + 9;
- uint32_t m;
+float truncf(float x) {
+ union {
+ float f;
+ uint32_t i;
+ } u = {x};
+ int e = (int)(u.i >> 23 & 0xff) - 0x7f + 9;
+ uint32_t m;
- if (e >= 23 + 9)
- return x;
- if (e < 9)
- e = 1;
- m = -1U >> e;
- if ((u.i & m) == 0)
- return x;
- FORCE_EVAL(x + 0x1p120f);
- u.i &= ~m;
- return u.f;
+ if (e >= 23 + 9)
+ return x;
+ if (e < 9)
+ e = 1;
+ m = -1U >> e;
+ if ((u.i & m) == 0)
+ return x;
+ FORCE_EVAL(x + 0x1p120f);
+ u.i &= ~m;
+ return u.f;
}
diff --git a/fusl/src/math/truncl.c b/fusl/src/math/truncl.c
index f07b193..ba2b8f4 100644
--- a/fusl/src/math/truncl.c
+++ b/fusl/src/math/truncl.c
@@ -1,34 +1,32 @@
#include "libm.h"
#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double truncl(long double x)
-{
- return trunc(x);
+long double truncl(long double x) {
+ return trunc(x);
}
#elif (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384
-static const long double toint = 1/LDBL_EPSILON;
+static const long double toint = 1 / LDBL_EPSILON;
-long double truncl(long double x)
-{
- union ldshape u = {x};
- int e = u.i.se & 0x7fff;
- int s = u.i.se >> 15;
- long double y;
+long double truncl(long double x) {
+ union ldshape u = {x};
+ int e = u.i.se & 0x7fff;
+ int s = u.i.se >> 15;
+ long double y;
- if (e >= 0x3fff+LDBL_MANT_DIG-1)
- return x;
- if (e <= 0x3fff-1) {
- FORCE_EVAL(x + 0x1p120f);
- return x*0;
- }
- /* y = int(|x|) - |x|, where int(|x|) is an integer neighbor of |x| */
- if (s)
- x = -x;
- y = x + toint - toint - x;
- if (y > 0)
- y -= 1;
- x += y;
- return s ? -x : x;
+ if (e >= 0x3fff + LDBL_MANT_DIG - 1)
+ return x;
+ if (e <= 0x3fff - 1) {
+ FORCE_EVAL(x + 0x1p120f);
+ return x * 0;
+ }
+ /* y = int(|x|) - |x|, where int(|x|) is an integer neighbor of |x| */
+ if (s)
+ x = -x;
+ y = x + toint - toint - x;
+ if (y > 0)
+ y -= 1;
+ x += y;
+ return s ? -x : x;
}
#endif
