aboutsummaryrefslogtreecommitdiff
path: root/math
diff options
context:
space:
mode:
Diffstat (limited to 'math')
-rw-r--r--math/Makefile10
-rw-r--r--math/bits/cmathcalls.h5
-rw-r--r--math/bits/mathcalls.h25
-rw-r--r--math/libm-test.c216
-rw-r--r--math/libm.map11
-rw-r--r--math/math.h25
-rw-r--r--math/test-double.c1
-rw-r--r--math/test-float.c1
-rw-r--r--math/test-idouble.c1
-rw-r--r--math/test-ifloat.c3
-rw-r--r--math/tgmath.h312
11 files changed, 562 insertions, 48 deletions
diff --git a/math/Makefile b/math/Makefile
index bc54d57c43..d7525d084d 100644
--- a/math/Makefile
+++ b/math/Makefile
@@ -23,7 +23,7 @@ subdir := math
# Installed header files.
headers := math.h bits/mathcalls.h bits/mathinline.h bits/huge_val.h \
bits/nan.h fpu_control.h complex.h bits/cmathcalls.h \
- fenv.h bits/fenv.h bits/mathdef.h
+ fenv.h bits/fenv.h bits/mathdef.h tgmath.h
# Internal header files.
distribute := math_private.h machine/asm.h machine/endian.h
@@ -39,7 +39,6 @@ extra-libs-others = $(extra-libs)
libm-map := libm.map
libm-support = k_standard s_lib_version s_matherr s_signgam \
- s_lrint s_llrint s_lround s_llround \
fclrexcpt fgetexcptflg fraiseexcpt fsetexcptflg \
ftestexcept fegetround fesetround fegetenv feholdexcpt \
fesetenv feupdateenv
@@ -49,8 +48,8 @@ libm-calls = e_acos e_acosh e_asin e_atan2 e_atanh e_cosh e_exp e_fmod \
k_cos k_rem_pio2 k_sin k_tan s_asinh s_atan s_cbrt \
s_ceil s_copysign s_cos s_erf s_expm1 s_fabs s_finite \
s_floor s_frexp s_ilogb s_ldexp s_log1p s_logb \
- s_modf s_nextafter s_rint s_scalbn s_significand \
- s_sin s_tan s_tanh w_acos w_acosh w_asin \
+ s_modf s_nextafter s_nextafterx s_rint s_scalbn s_scalbln \
+ s_significand s_sin s_tan s_tanh w_acos w_acosh w_asin \
w_atan2 w_atanh w_cosh w_drem w_exp w_exp2 w_fmod w_gamma \
w_hypot w_j0 w_j1 w_jn w_lgamma w_lgamma_r \
w_log w_log10 w_pow w_remainder w_scalb w_sinh w_sqrt \
@@ -58,7 +57,8 @@ libm-calls = e_acos e_acosh e_asin e_atan2 e_atanh e_cosh e_exp e_fmod \
s_remquo s_log2 s_exp2 s_round s_nearbyint s_sincos \
conj cimag creal cabs carg s_cexp s_csinh s_ccosh s_clog \
s_catan s_casin s_ccos s_csin s_ctan s_ctanh s_cacos \
- s_casinh s_cacosh s_catanh s_csqrt s_cpow s_cproj
+ s_casinh s_cacosh s_catanh s_csqrt s_cpow s_cproj s_clog10 \
+ s_fma s_lrint s_llrint s_lround s_llround
libm-routines = $(libm-support) $(libm-calls) \
$(patsubst %_rf,%f_r,$(libm-calls:=f)) \
$(long-m-$(long-double-fcts))
diff --git a/math/bits/cmathcalls.h b/math/bits/cmathcalls.h
index d94e764930..ca0dfe1b9c 100644
--- a/math/bits/cmathcalls.h
+++ b/math/bits/cmathcalls.h
@@ -90,6 +90,11 @@ __MATHCALL (cexp, (_Mdouble_complex_ __z));
/* Natural logarithm of Z. */
__MATHCALL (clog, (_Mdouble_complex_ __z));
+#ifdef __USE_GNU
+/* The base 10 logarithm is not defined by the standard but to implement
+ the standard C++ library it is handy. */
+__MATHCALL (clog10, (_Mdouble_complex_ __z));
+#endif
/* Power functions. */
diff --git a/math/bits/mathcalls.h b/math/bits/mathcalls.h
index e0bf1008d3..dacc264136 100644
--- a/math/bits/mathcalls.h
+++ b/math/bits/mathcalls.h
@@ -232,6 +232,9 @@ __MATHCALL (rint,, (_Mdouble_ __x));
/* Return X + epsilon if X < Y, X - epsilon if X > Y. */
__MATHCALLX (nextafter,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
+#ifdef __USE_ISOC9X
+__MATHCALLX (nextafterx,, (_Mdouble_ __x, long double __y), (__const__));
+#endif
/* Return the remainder of integer divison X / Y with infinite precision. */
__MATHCALL (remainder,, (_Mdouble_ __x, _Mdouble_ __y));
@@ -240,13 +243,16 @@ __MATHCALL (remainder,, (_Mdouble_ __x, _Mdouble_ __y));
__MATHCALL (scalb,, (_Mdouble_ __x, _Mdouble_ __n));
/* Return X times (2 to the Nth power). */
-__MATHCALL (scalbn,, (_Mdouble_ __x, long int __n));
+__MATHCALL (scalbn,, (_Mdouble_ __x, int __n));
/* Return the binary exponent of X, which must be nonzero. */
__MATHDECL (int,ilogb,, (_Mdouble_ __x));
#endif
#ifdef __USE_ISOC9X
+/* Return X times (2 to the Nth power). */
+__MATHCALL (scalbln,, (_Mdouble_ __x, long int __n));
+
/* Round X to integral valuein floating-point format using current
rounding direction, but do not raise inexact exception. */
__MATHCALL (nearbyint,, (_Mdouble_ __x));
@@ -265,6 +271,19 @@ __MATHCALLX (trunc,, (_Mdouble_ __x), (__const__));
__MATHCALL (remquo,, (_Mdouble_ __x, _Mdouble_ __y, int *__quo));
+/* Conversion functions. */
+
+/* Round X to nearest integral value according to current rounding
+ direction. */
+__MATHDECL (long int, lrint,, (_Mdouble_ __x));
+__MATHDECL (long long int, llrint,, (_Mdouble_ __x));
+
+/* Round X to nearest integral value, rounding halfway cases away from
+ zero. */
+__MATHDECL (long int, lround,, (_Mdouble_ __x));
+__MATHDECL (long long int, llround,, (_Mdouble_ __x));
+
+
/* Return positive difference between X and Y. */
__MATHCALL (fdim,, (_Mdouble_ __x, _Mdouble_ __y));
@@ -282,4 +301,8 @@ __MATHDECL_1 (int, __fpclassify,, (_Mdouble_ __value))
/* Test for negative number. */
__MATHDECL_1 (int, __signbit,, (_Mdouble_ __value))
__attribute__ ((__const__));
+
+
+/* Multiply-add function computed as a ternary operation. */
+__MATHCALL (fma,, (_Mdouble_ __x, _Mdouble_ __y, _Mdouble_ __z));
#endif /* Use ISO C 9X. */
diff --git a/math/libm-test.c b/math/libm-test.c
index 2075adcb59..c24b5f0f83 100644
--- a/math/libm-test.c
+++ b/math/libm-test.c
@@ -4301,6 +4301,160 @@ clog_test (void)
static void
+clog10_test (void)
+{
+ __complex__ MATHTYPE result;
+
+ result = FUNC(clog10) (BUILD_COMPLEX (minus_zero, 0));
+ check_isinfn_exc ("real(clog10(-0 + i0)) = -Inf plus divide-by-zero exception",
+ __real__ result, DIVIDE_BY_ZERO_EXCEPTION);
+ check ("imag(clog10(-0 + i0)) = pi plus divide-by-zero exception",
+ __imag__ result, M_PI);
+ result = FUNC(clog10) (BUILD_COMPLEX (minus_zero, minus_zero));
+ check_isinfn_exc ("real(clog10(-0 - i0)) = -Inf plus divide-by-zero exception",
+ __real__ result, DIVIDE_BY_ZERO_EXCEPTION);
+ check ("imag(clog10(-0 - i0)) = -pi plus divide-by-zero exception",
+ __imag__ result, -M_PI);
+
+ result = FUNC(clog10) (BUILD_COMPLEX (0, 0));
+ check_isinfn_exc ("real(clog10(0 + i0)) = -Inf plus divide-by-zero exception",
+ __real__ result, DIVIDE_BY_ZERO_EXCEPTION);
+ check ("imag(clog10(0 + i0)) = 0 plus divide-by-zero exception",
+ __imag__ result, 0);
+ result = FUNC(clog10) (BUILD_COMPLEX (0, minus_zero));
+ check_isinfn_exc ("real(clog10(0 - i0)) = -Inf plus divide-by-zero exception",
+ __real__ result, DIVIDE_BY_ZERO_EXCEPTION);
+ check ("imag(clog10(0 - i0)) = -0 plus divide-by-zero exception",
+ __imag__ result, minus_zero);
+
+ result = FUNC(clog10) (BUILD_COMPLEX (minus_infty, plus_infty));
+ check_isinfp ("real(clog10(-Inf + i Inf)) = +Inf", __real__ result);
+ check ("imag(clog10(-Inf + i Inf)) = 3*pi/4", __imag__ result, M_PI - M_PI_4);
+ result = FUNC(clog10) (BUILD_COMPLEX (minus_infty, minus_infty));
+ check_isinfp ("real(clog10(-Inf - i Inf)) = +Inf", __real__ result);
+ check ("imag(clog10(-Inf - i Inf)) = -3*pi/4", __imag__ result, M_PI_4 - M_PI);
+
+ result = FUNC(clog10) (BUILD_COMPLEX (plus_infty, plus_infty));
+ check_isinfp ("real(clog10(+Inf + i Inf)) = +Inf", __real__ result);
+ check ("imag(clog10(+Inf + i Inf)) = pi/4", __imag__ result, M_PI_4);
+ result = FUNC(clog10) (BUILD_COMPLEX (plus_infty, minus_infty));
+ check_isinfp ("real(clog10(+Inf - i Inf)) = +Inf", __real__ result);
+ check ("imag(clog10(+Inf - i Inf)) = -pi/4", __imag__ result, -M_PI_4);
+
+ result = FUNC(clog10) (BUILD_COMPLEX (0, plus_infty));
+ check_isinfp ("real(clog10(0 + i Inf)) = +Inf", __real__ result);
+ check ("imag(clog10(0 + i Inf)) = pi/2", __imag__ result, M_PI_2);
+ result = FUNC(clog10) (BUILD_COMPLEX (3, plus_infty));
+ check_isinfp ("real(clog10(3 + i Inf)) = +Inf", __real__ result);
+ check ("imag(clog10(3 + i Inf)) = pi/2", __imag__ result, M_PI_2);
+ result = FUNC(clog10) (BUILD_COMPLEX (minus_zero, plus_infty));
+ check_isinfp ("real(clog10(-0 + i Inf)) = +Inf", __real__ result);
+ check ("imag(clog10(-0 + i Inf)) = pi/2", __imag__ result, M_PI_2);
+ result = FUNC(clog10) (BUILD_COMPLEX (-3, plus_infty));
+ check_isinfp ("real(clog10(-3 + i Inf)) = +Inf", __real__ result);
+ check ("imag(clog10(-3 + i Inf)) = pi/2", __imag__ result, M_PI_2);
+ result = FUNC(clog10) (BUILD_COMPLEX (0, minus_infty));
+ check_isinfp ("real(clog10(0 - i Inf)) = +Inf", __real__ result);
+ check ("imag(clog10(0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
+ result = FUNC(clog10) (BUILD_COMPLEX (3, minus_infty));
+ check_isinfp ("real(clog10(3 - i Inf)) = +Inf", __real__ result);
+ check ("imag(clog10(3 - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
+ result = FUNC(clog10) (BUILD_COMPLEX (minus_zero, minus_infty));
+ check_isinfp ("real(clog10(-0 - i Inf)) = +Inf", __real__ result);
+ check ("imag(clog10(-0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
+ result = FUNC(clog10) (BUILD_COMPLEX (-3, minus_infty));
+ check_isinfp ("real(clog10(-3 - i Inf)) = +Inf", __real__ result);
+ check ("imag(clog10(-3 - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
+
+ result = FUNC(clog10) (BUILD_COMPLEX (minus_infty, 0));
+ check_isinfp ("real(clog10(-Inf + i0)) = +Inf", __real__ result);
+ check ("imag(clog10(-Inf + i0)) = pi", __imag__ result, M_PI);
+ result = FUNC(clog10) (BUILD_COMPLEX (minus_infty, 1));
+ check_isinfp ("real(clog10(-Inf + i1)) = +Inf", __real__ result);
+ check ("imag(clog10(-Inf + i1)) = pi", __imag__ result, M_PI);
+ result = FUNC(clog10) (BUILD_COMPLEX (minus_infty, minus_zero));
+ check_isinfp ("real(clog10(-Inf - i0)) = +Inf", __real__ result);
+ check ("imag(clog10(-Inf - i0)) = -pi", __imag__ result, -M_PI);
+ result = FUNC(clog10) (BUILD_COMPLEX (minus_infty, -1));
+ check_isinfp ("real(clog10(-Inf - i1)) = +Inf", __real__ result);
+ check ("imag(clog10(-Inf - i1)) = -pi", __imag__ result, -M_PI);
+
+ result = FUNC(clog10) (BUILD_COMPLEX (plus_infty, 0));
+ check_isinfp ("real(clog10(+Inf + i0)) = +Inf", __real__ result);
+ check ("imag(clog10(+Inf + i0)) = 0", __imag__ result, 0);
+ result = FUNC(clog10) (BUILD_COMPLEX (plus_infty, 1));
+ check_isinfp ("real(clog10(+Inf + i1)) = +Inf", __real__ result);
+ check ("imag(clog10(+Inf + i1)) = 0", __imag__ result, 0);
+ result = FUNC(clog10) (BUILD_COMPLEX (plus_infty, minus_zero));
+ check_isinfp ("real(clog10(+Inf - i0)) = +Inf", __real__ result);
+ check ("imag(clog10(+Inf - i0)) = -0", __imag__ result, minus_zero);
+ result = FUNC(clog10) (BUILD_COMPLEX (plus_infty, -1));
+ check_isinfp ("real(clog10(+Inf - i1)) = +Inf", __real__ result);
+ check ("imag(clog10(+Inf - i1)) = -0", __imag__ result, minus_zero);
+
+ result = FUNC(clog10) (BUILD_COMPLEX (plus_infty, nan_value));
+ check_isinfp ("real(clog10(+Inf + i NaN)) = +Inf", __real__ result);
+ check_isnan ("imag(clog10(+Inf + i NaN)) = NaN", __imag__ result);
+ result = FUNC(clog10) (BUILD_COMPLEX (minus_infty, nan_value));
+ check_isinfp ("real(clog10(-Inf + i NaN)) = +Inf", __real__ result);
+ check_isnan ("imag(clog10(-Inf + i NaN)) = NaN", __imag__ result);
+
+ result = FUNC(clog10) (BUILD_COMPLEX (nan_value, plus_infty));
+ check_isinfp ("real(clog10(NaN + i Inf)) = +Inf", __real__ result);
+ check_isnan ("imag(clog10(NaN + i Inf)) = NaN", __imag__ result);
+ result = FUNC(clog10) (BUILD_COMPLEX (nan_value, minus_infty));
+ check_isinfp ("real(clog10(NaN - i Inf)) = +Inf", __real__ result);
+ check_isnan ("imag(clog10(NaN - i Inf)) = NaN", __imag__ result);
+
+ result = FUNC(clog10) (BUILD_COMPLEX (0, nan_value));
+ check_isnan_maybe_exc ("real(clog10(0 + i NaN)) = NaN plus maybe invalid exception",
+ __real__ result, INVALID_EXCEPTION);
+ check_isnan ("imag(clog10(0 + i NaN)) = NaN plus maybe invalid exception",
+ __imag__ result);
+ result = FUNC(clog10) (BUILD_COMPLEX (3, nan_value));
+ check_isnan_maybe_exc ("real(clog10(3 + i NaN)) = NaN plus maybe invalid exception",
+ __real__ result, INVALID_EXCEPTION);
+ check_isnan ("imag(clog10(3 + i NaN)) = NaN plus maybe invalid exception",
+ __imag__ result);
+ result = FUNC(clog10) (BUILD_COMPLEX (minus_zero, nan_value));
+ check_isnan_maybe_exc ("real(clog10(-0 + i NaN)) = NaN plus maybe invalid exception",
+ __real__ result, INVALID_EXCEPTION);
+ check_isnan ("imag(clog10(-0 + i NaN)) = NaN plus maybe invalid exception",
+ __imag__ result);
+ result = FUNC(clog10) (BUILD_COMPLEX (-3, nan_value));
+ check_isnan_maybe_exc ("real(clog10(-3 + i NaN)) = NaN plus maybe invalid exception",
+ __real__ result, INVALID_EXCEPTION);
+ check_isnan ("imag(clog10(-3 + i NaN)) = NaN plus maybe invalid exception",
+ __imag__ result);
+
+ result = FUNC(clog10) (BUILD_COMPLEX (nan_value, 0));
+ check_isnan_maybe_exc ("real(clog10(NaN + i0)) = NaN plus maybe invalid exception",
+ __real__ result, INVALID_EXCEPTION);
+ check_isnan ("imag(clog10(NaN + i0)) = NaN plus maybe invalid exception",
+ __imag__ result);
+ result = FUNC(clog10) (BUILD_COMPLEX (nan_value, 5));
+ check_isnan_maybe_exc ("real(clog10(NaN + i5)) = NaN plus maybe invalid exception",
+ __real__ result, INVALID_EXCEPTION);
+ check_isnan ("imag(clog10(NaN + i5)) = NaN plus maybe invalid exception",
+ __imag__ result);
+ result = FUNC(clog10) (BUILD_COMPLEX (nan_value, minus_zero));
+ check_isnan_maybe_exc ("real(clog10(NaN - i0)) = NaN plus maybe invalid exception",
+ __real__ result, INVALID_EXCEPTION);
+ check_isnan ("imag(clog10(NaN - i0)) = NaN plus maybe invalid exception",
+ __imag__ result);
+ result = FUNC(clog10) (BUILD_COMPLEX (nan_value, -5));
+ check_isnan_maybe_exc ("real(clog10(NaN - i5)) = NaN plus maybe invalid exception",
+ __real__ result, INVALID_EXCEPTION);
+ check_isnan ("imag(clog10(NaN - i5)) = NaN plus maybe invalid exception",
+ __imag__ result);
+
+ result = FUNC(clog10) (BUILD_COMPLEX (nan_value, nan_value));
+ check_isnan ("real(clog10(NaN + i NaN)) = NaN", __real__ result);
+ check_isnan ("imag(clog10(NaN + i NaN)) = NaN", __imag__ result);
+}
+
+
+static void
csqrt_test (void)
{
__complex__ MATHTYPE result;
@@ -4539,43 +4693,52 @@ round_test (void)
static void
lround_test (void)
{
- check_long ("lround(0) = 0", lround (0), 0);
- check_long ("lround(-0) = 0", lround (minus_zero), 0);
- check_long ("lround(0.2) = 0", lround (0.2), 0.0);
- check_long ("lround(-0.2) = 0", lround (-0.2), 0);
- check_long ("lround(0.5) = 1", lround (0.5), 1);
- check_long ("lround(-0.5) = -1", lround (-0.5), -1);
- check_long ("lround(0.8) = 1", lround (0.8), 1);
- check_long ("lround(-0.8) = -1", lround (-0.8), -1);
- check_long ("lround(1.5) = 2", lround (1.5), 2);
- check_long ("lround(-1.5) = -2", lround (-1.5), -2);
- check_long ("lround(2097152.5) = 2097153", lround (2097152.5), 2097153);
- check_long ("lround(-2097152.5) = -2097153", lround (-2097152.5),
+ check_long ("lround(0) = 0", FUNC(lround) (0), 0);
+ check_long ("lround(-0) = 0", FUNC(lround) (minus_zero), 0);
+ check_long ("lround(0.2) = 0", FUNC(lround) (0.2), 0.0);
+ check_long ("lround(-0.2) = 0", FUNC(lround) (-0.2), 0);
+ check_long ("lround(0.5) = 1", FUNC(lround) (0.5), 1);
+ check_long ("lround(-0.5) = -1", FUNC(lround) (-0.5), -1);
+ check_long ("lround(0.8) = 1", FUNC(lround) (0.8), 1);
+ check_long ("lround(-0.8) = -1", FUNC(lround) (-0.8), -1);
+ check_long ("lround(1.5) = 2", FUNC(lround) (1.5), 2);
+ check_long ("lround(-1.5) = -2", FUNC(lround) (-1.5), -2);
+ check_long ("lround(22514.5) = 22514", FUNC(lround) (1.5), 2);
+ check_long ("lround(-22514.5) = -22514", FUNC(lround) (-1.5), -2);
+#ifndef TEST_FLOAT
+ check_long ("lround(2097152.5) = 2097153", FUNC(lround) (2097152.5),
+ 2097153);
+ check_long ("lround(-2097152.5) = -2097153", FUNC(lround) (-2097152.5),
-2097153);
+#endif
}
static void
llround_test (void)
{
- check_longlong ("llround(0) = 0", llround (0), 0);
- check_longlong ("llround(-0) = 0", llround (minus_zero), 0);
- check_longlong ("llround(0.2) = 0", llround (0.2), 0.0);
- check_longlong ("llround(-0.2) = 0", llround (-0.2), 0);
- check_longlong ("llround(0.5) = 1", llround (0.5), 1);
- check_longlong ("llround(-0.5) = -1", llround (-0.5), -1);
- check_longlong ("llround(0.8) = 1", llround (0.8), 1);
- check_longlong ("llround(-0.8) = -1", llround (-0.8), -1);
- check_longlong ("llround(1.5) = 2", llround (1.5), 2);
- check_longlong ("llround(-1.5) = -2", llround (-1.5), -2);
+ check_longlong ("llround(0) = 0", FUNC(llround) (0), 0);
+ check_longlong ("llround(-0) = 0", FUNC(llround) (minus_zero), 0);
+ check_longlong ("llround(0.2) = 0", FUNC(llround) (0.2), 0.0);
+ check_longlong ("llround(-0.2) = 0", FUNC(llround) (-0.2), 0);
+ check_longlong ("llround(0.5) = 1", FUNC(llround) (0.5), 1);
+ check_longlong ("llround(-0.5) = -1", FUNC(llround) (-0.5), -1);
+ check_longlong ("llround(0.8) = 1", FUNC(llround) (0.8), 1);
+ check_longlong ("llround(-0.8) = -1", FUNC(llround) (-0.8), -1);
+ check_longlong ("llround(1.5) = 2", FUNC(llround) (1.5), 2);
+ check_longlong ("llround(-1.5) = -2", FUNC(llround) (-1.5), -2);
+ check_longlong ("llround(22514.5) = 22514", FUNC(llround) (1.5), 2);
+ check_longlong ("llround(-22514.5) = -22514", FUNC(llround) (-1.5), -2);
+#ifndef TEST_FLOAT
check_longlong ("llround(2097152.5) = 2097153",
- llround (2097152.5), 2097153);
+ FUNC(llround) (2097152.5), 2097153);
check_longlong ("llround(-2097152.5) = -2097153",
- llround (-2097152.5), -2097153);
+ FUNC(llround) (-2097152.5), -2097153);
check_longlong ("llround(34359738368.5) = 34359738369",
- llround (34359738368.5), 34359738369ll);
+ FUNC(llround) (34359738368.5), 34359738369ll);
check_longlong ("llround(-34359738368.5) = -34359738369",
- llround (-34359738368.5), -34359738369ll);
+ FUNC(llround) (-34359738368.5), -34359738369ll);
+#endif
}
@@ -4962,6 +5125,7 @@ main (int argc, char *argv[])
ccos_test ();
ccosh_test ();
clog_test ();
+ clog10_test ();
cacos_test ();
cacosh_test ();
casin_test ();
diff --git a/math/libm.map b/math/libm.map
index 2a1aa6cfbe..296d55d675 100644
--- a/math/libm.map
+++ b/math/libm.map
@@ -23,6 +23,7 @@ GLIBC_2.0 {
fdim; fdimf; fdiml;
finite; finitef; finitel;
floor; floorf; floorl;
+ fma; fmaf; fmal;
fmax; fmaxf; fmaxl;
fmin; fminf; fminl;
fmod; fmodf; fmodl;
@@ -47,15 +48,19 @@ GLIBC_2.0 {
nan; nanf; nanl;
nearbyint; nearbyintf; nearbyintl;
nextafter; nextafterf; nextafterl;
+ nextafterx; nextafterxf; nextafterxl;
pow; powf; powl;
remainder; remainderf; remainderl;
remquo; remquof; remquol;
rint; rintf; rintl;
- lrint; llrint;
+ lrint; lrintf; lrintl;
+ llrint; llrintf; llrintl;
round; roundf; roundl;
- lround; llround;
+ lround; lroundf; lroundl;
+ llround; llroundf; llroundl;
scalb; scalbf; scalbl;
scalbn; scalbnf; scalbnl;
+ scalbln; scalblnf; scalblnl;
significand; significandf; significandl;
sin; sinf; sinl;
sincos; sincosf; sincosl;
@@ -82,6 +87,8 @@ GLIBC_2.0 {
cexp; cexpf; cexpl;
cimag; cimagf; cimagl;
clog; clogf; clogl;
+ clog10; clog10f; clog10l;
+ __clog10; __clog10f; __clog10l;
conj; conjf; conjl;
cpow; cpowf; cpowl;
cproj; cprojf; cprojl;
diff --git a/math/math.h b/math/math.h
index 762ccbe409..51055849ce 100644
--- a/math/math.h
+++ b/math/math.h
@@ -131,6 +131,18 @@ extern int signgam;
else `float_t' and `double_t' are unspecified
INFINITY representation of the infinity value of type `float_t'
+
+ FP_FAST_FMA
+ FP_FAST_FMAF
+ FP_FAST_FMAL
+ If defined it indicates that the the `fma' function
+ generally executes about as fast as a multiply and an add.
+ This macro is defined only iff the `fma' function is
+ implemented directly with a hardware multiply-add instructions.
+
+ FP_ILOGB0 Expands to a value returned by `ilogb (0.0)'.
+ FP_ILOGBNAN Expands to a value returned by `ilogb (NAN)'.
+
*/
# include <bits/mathdef.h>
@@ -181,19 +193,6 @@ enum
: sizeof (x) == sizeof (double) ? \
__isnan (x) : __isnanl (x))
-
-/* Conversion functions. */
-
-/* Round X to nearest integral value according to current rounding
- direction. */
-extern long int lrint __P ((long double __x));
-extern long long int llrint __P ((long double __x));
-
-/* Round X to nearest integral value, rounding halfway cases away from
- zero. */
-extern long int lround __P ((long double __x));
-extern long long int llround __P ((long double __x));
-
#endif /* Use ISO C 9X. */
#ifdef __USE_MISC
diff --git a/math/test-double.c b/math/test-double.c
index 1f4ff8e0d0..c2e7dc92b3 100644
--- a/math/test-double.c
+++ b/math/test-double.c
@@ -23,6 +23,7 @@
#define MATHCONST(x) x
#define CHOOSE(Clongdouble,Cdouble,Cfloat) Cdouble
#define PRINTF_EXPR "e"
+#define TEST_DOUBLE 1
#ifndef __NO_MATH_INLINES
# define __NO_MATH_INLINES
diff --git a/math/test-float.c b/math/test-float.c
index de918a3886..849067c8da 100644
--- a/math/test-float.c
+++ b/math/test-float.c
@@ -23,6 +23,7 @@
#define MATHCONST(x) x
#define CHOOSE(Clongdouble,Cdouble,Cfloat) Cfloat
#define PRINTF_EXPR "e"
+#define TEST_FLOAT 1
#ifndef __NO_MATH_INLINES
# define __NO_MATH_INLINES
diff --git a/math/test-idouble.c b/math/test-idouble.c
index 614f10feb4..3039ccf5b4 100644
--- a/math/test-idouble.c
+++ b/math/test-idouble.c
@@ -24,6 +24,7 @@
#define MATHCONST(x) x
#define CHOOSE(Clongdouble,Cdouble,Cfloat) Cdouble
#define PRINTF_EXPR "e"
+#define TEST_DOUBLE 1
#define TEST_INLINE
#ifdef __NO_MATH_INLINES
diff --git a/math/test-ifloat.c b/math/test-ifloat.c
index 05e5de62ff..d6f96f8622 100644
--- a/math/test-ifloat.c
+++ b/math/test-ifloat.c
@@ -23,7 +23,8 @@
#define MATHCONST(x) x
#define CHOOSE(Clongdouble,Cdouble,Cfloat) Cfloat
#define PRINTF_EXPR "e"
-#define TEST_INLINE
+#define TEST_FLOAT 1
+#define TEST_INLINE 1
#ifdef __NO_MATH_INLINES
# undef __NO_MATH_INLINES
diff --git a/math/tgmath.h b/math/tgmath.h
new file mode 100644
index 0000000000..4c7d957b37
--- /dev/null
+++ b/math/tgmath.h
@@ -0,0 +1,312 @@
+/* Copyright (C) 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+/*
+ * ISO C 9X Standard: 7.9 Type-generic math <tgmath.h>
+ */
+
+#ifndef _TGMATH_H
+#define _TGMATH_H 1
+
+/* Include the needed headers. */
+#include <math.h>
+#include <complex.h>
+
+
+/* Since `complex' is currently not really implemented in most C compilers
+ and if it is implemented, the implementations differ. This makes it
+ quite difficult to write a generic implementation of this header. We
+ do not try this for now and instead concentrate only on GNU CC. Once
+ we have more information support for other compilers might follow. */
+
+#if defined __GNUC__ && (__GNUC__ > 2 || __GNUC__ == 2 && __GNUC_MINOR__ >= 7)
+
+/* We have two kinds of generic macros: to support functions which are
+ only defined on real valued parameters and those which are defined
+ for complex functions as well. */
+# define __TGMATH_UNARY_REAL_ONLY(Val, Fct) \
+ (__extension__ (sizeof (__real__ (Val)) == sizeof (long double) \
+ ? Fct##l (Val) \
+ : (sizeof (__real__ (Val)) == sizeof (double) \
+ ? Fct (Val) \
+ : Fct##f (Val))))
+
+# define __TGMATH_BINARY_FIRST_REAL_ONLY(Val1, Val2, Fct) \
+ (__extension__ (sizeof (__real__ (Val1)) == sizeof (long double) \
+ ? Fct##l (Val1, Val2) \
+ : (sizeof (__real__ (Val1)) == sizeof (double) \
+ ? Fct (Val1, Val2) \
+ : Fct##f (Val1, Val2))))
+
+# define __TGMATH_BINARY_REAL_ONLY(Val1, Val2, Fct) \
+ (__extension__ (sizeof (Val1) == sizeof (long double) \
+ || sizeof (Val2) == sizeof (long double) \
+ ? Fct##l (Val1, Val2) \
+ : (sizeof (Val1) == sizeof (double) \
+ || sizeof (Val2) == sizeof (double) \
+ ? Fct (Val1, Val2) \
+ : Fct##f (Val1, Val2))))
+
+# define __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY(Val1, Val2, Val3, Fct) \
+ (__extension__ (sizeof (Val1) == sizeof (long double) \
+ || sizeof (Val2) == sizeof (long double) \
+ ? Fct##l (Val1, Val2, Val3) \
+ : (sizeof (Val1) == sizeof (double) \
+ || sizeof (Val2) == sizeof (double) \
+ ? Fct (Val1, Val2, Val3) \
+ : Fct##f (Val1, Val2, Val3))))
+
+# define __TGMATH_UNARY_REAL_IMAG(Val, Fct, Cfct) \
+ (__extension__ (sizeof (__real__ (Val)) == sizeof (long double) \
+ ? (sizeof (__real__ (Val)) == sizeof (Val) \
+ ? Fct##l (Val) \
+ : Cfct##l (Val)) \
+ : (sizeof (__real__ (Val)) == sizeof (double) \
+ ? (sizeof (__real__ (Val)) == sizeof (Val) \
+ ? Fct (Val) \
+ : Cfct (Val)) \
+ : (sizeof (__real__ (Val)) == sizeof (Val) \
+ ? Fct##f (Val) \
+ : Cfct##f (Val)))))
+
+# define __TGMATH_UNARY_IMAG_ONLY(Val, Fct) \
+ (__extension__ (sizeof (Val) == sizeof (__complex__ long double) \
+ ? Fct##l (Val) \
+ : (sizeof (Val) == sizeof (__complex__ double) \
+ ? Fct (Val) \
+ : Fct##f (Val))))
+
+# define __TGMATH_BINARY_REAL_IMAG(Val1, Val2, Fct, Cfct) \
+ (__extension__ (sizeof (__real__ (Val1)) == sizeof (long double) \
+ || sizeof (__real__ (Val2)) == sizeof (long double) \
+ ? (sizeof (__real__ (Val1)) == sizeof (Val1) \
+ && sizeof (__real__ (Val2)) == sizeof (Val2) \
+ ? Fct##l (Val1, Val2) \
+ : Cfct##l (Val1, Val2)) \
+ : (sizeof (__real__ (Val1)) == sizeof (double) \
+ || sizeof (__real__ (Val2)) == sizeof (double) \
+ ? (sizeof (__real__ (Val1)) == sizeof (Val1) \
+ && sizeof (__real__ (Val2)) == sizeof (Val2) \
+ ? Fct (Val1, Val2) \
+ : Cfct (Val1, Val2)) \
+ : (sizeof (__real__ (Val1)) == sizeof (Val1) \
+ && sizeof (__real__ (Val2)) == sizeof (Val2) \
+ ? Fct##f (Val1, Val2) \
+ : Cfct##f (Val1, Val2)))))
+#else
+# error "Unsupported compiler; you cannot use <tgmath.h>"
+#endif
+
+
+/* Unary functions defined for real and complex values. */
+
+
+/* Trigonometric functions. */
+
+/* Arc cosine of X. */
+#define acos(Val) __TGMATH_UNARY_REAL_IMAG (Val, acos, cacos)
+/* Arc sine of X. */
+#define asin(Val) __TGMATH_UNARY_REAL_IMAG (Val, asin, casin)
+/* Arc tangent of X. */
+#define atan(Val) __TGMATH_UNARY_REAL_IMAG (Val, atan, catan)
+/* Arc tangent of Y/X. */
+#define atan2(Val) __TGMATH_UNARY_REAL_ONLY (Val, atan2)
+
+/* Cosine of X. */
+#define cos(Val) __TGMATH_UNARY_REAL_IMAG (Val, cos, ccos)
+/* Sine of X. */
+#define sin(Val) __TGMATH_UNARY_REAL_IMAG (Val, sin, csin)
+/* Tangent of X. */
+#define tan(Val) __TGMATH_UNARY_REAL_IMAG (Val, tan, ctan)
+
+
+/* Hyperbolic functions. */
+
+/* Hyperbolic arc cosine of X. */
+#define acosh(Val) __TGMATH_UNARY_REAL_IMAG (Val, acosh, cacosh)
+/* Hyperbolic arc sine of X. */
+#define asinh(Val) __TGMATH_UNARY_REAL_IMAG (Val, asinh, casinh)
+/* Hyperbolic arc tangent of X. */
+#define atanh(Val) __TGMATH_UNARY_REAL_IMAG (Val, atanh, catanh)
+
+/* Hyperbolic cosine of X. */
+#define cosh(Val) __TGMATH_UNARY_REAL_IMAG (Val, cosh, ccosh)
+/* Hyperbolic sine of X. */
+#define sinh(Val) __TGMATH_UNARY_REAL_IMAG (Val, sinh, csinh)
+/* Hyperbolic tangent of X. */
+#define tanh(Val) __TGMATH_UNARY_REAL_IMAG (Val, tanh, ctanh)
+
+
+/* Exponential and logarithmic functions. */
+
+/* Exponential function of X. */
+#define exp(Val) __TGMATH_UNARY_REAL_IMAG (Val, exp, cexp)
+
+/* Break VALUE into a normalized fraction and an integral power of 2. */
+#define frexp(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, frexp)
+
+/* X times (two to the EXP power). */
+#define ldexp(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, ldexp)
+
+/* Natural logarithm of X. */
+#define log(Val) __TGMATH_UNARY_REAL_IMAG (Val, log, clog)
+
+/* Base-ten logarithm of X. */
+#define log10(Val) __TGMATH_UNARY_REAL_IMAG (Val, log10, __clog10)
+
+/* Return exp(X) - 1. */
+#define expm1(Val) __TGMATH_UNARY_REAL_ONLY (Val, expm1)
+
+/* Return log(1 + X). */
+#define log1p(Val) __TGMATH_UNARY_REAL_ONLY (Val, log1p)
+
+/* Return the base 2 signed integral exponent of X. */
+#define logb(Val) __TGMATH_UNARY_REAL_ONLY (Val, logb)
+
+/* Compute base-2 exponential of X. */
+#define exp2(Val) __TGMATH_UNARY_REAL_ONLY (Val, exp2)
+
+/* Compute base-2 logarithm of X. */
+#define log2(Val) __TGMATH_UNARY_REAL_ONLY (Val, log2)
+
+
+/* Power functions. */
+
+/* Return X to the Y power. */
+#define pow(Val1, Val2) __TGMATH_BINARY_REAL_IMAG (Val1, Val2, pow, cpow)
+
+/* Return the square root of X. */
+#define sqrt(Val) __TGMATH_UNARY_REAL_IMAG (Val, sqrt, csqrt)
+
+/* Return `sqrt(X*X + Y*Y)'. */
+#define hypot(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, hypot)
+
+/* Return the cube root of X. */
+#define cbrt(Val) __TGMATH_UNARY_REAL_ONLY (Val, cbrt)
+
+
+/* Nearest integer, absolute value, and remainder functions. */
+
+/* Smallest integral value not less than X. */
+#define ceil(Val) __TGMATH_UNARY_REAL_ONLY (Val, ceil)
+
+/* Absolute value of X. */
+#define fabs(Val) __TGMATH_UNARY_REAL_IMAG (Val, fabs, cabs)
+
+/* Largest integer not greater than X. */
+#define floor(Val) __TGMATH_UNARY_REAL_ONLY (Val, floor)
+
+/* Floating-point modulo remainder of X/Y. */
+#define fmod(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmod)
+
+/* Round X to integral valuein floating-point format using current
+ rounding direction, but do not raise inexact exception. */
+#define nearbyint(Val) __TGMATH_UNARY_REAL_ONLY (Val, nearbyint)
+
+/* Round X to nearest integral value, rounding halfway cases away from
+ zero. */
+#define round(Val) __TGMATH_UNARY_REAL_ONLY (Val, round)
+
+/* Round X to the integral value in floating-point format nearest but
+ not larger in magnitude. */
+#define trunc(Val) __TGMATH_UNARY_REAL_ONLY (Val, trunc)
+
+/* Compute remainder of X and Y and put in *QUO a value with sign of x/y
+ and magnitude congruent `mod 2^n' to the magnitude of the integral
+ quotient x/y, with n >= 3. */
+#define remquo(Val1, Val2, Val3) \
+ __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY (Val1, Val2, Val3, remquo)
+
+/* Round X to nearest integral value according to current rounding
+ direction. */
+#define lrint(Val) __TGMATH_UNARY_REAL_ONLY (Val, lrint)
+#define llrint(Val) __TGMATH_UNARY_REAL_ONLY (Val, llrint)
+
+/* Round X to nearest integral value, rounding halfway cases away from
+ zero. */
+#define lround(Val) __TGMATH_UNARY_REAL_ONLY (Val, lround)
+#define llround(Val) __TGMATH_UNARY_REAL_ONLY (Val, llround)
+
+
+/* Return X with its signed changed to Y's. */
+#define copysign(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, copysign)
+
+/* Error and gamma functions. */
+#define erf(Val) __TGMATH_UNARY_REAL_ONLY (Val, erf)
+#define erfc(Val) __TGMATH_UNARY_REAL_ONLY (Val, erfc)
+#define gamma(Val) __TGMATH_UNARY_REAL_ONLY (Val, gamma)
+#define lgamma(Val) __TGMATH_UNARY_REAL_ONLY (Val, lgamma)
+
+
+/* Return the integer nearest X in the direction of the
+ prevailing rounding mode. */
+#define rint(Val) __TGMATH_UNARY_REAL_ONLY (Val, rint)
+
+/* Return X + epsilon if X < Y, X - epsilon if X > Y. */
+#define nextafter(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, nextafter)
+#define nextafterx(Val1, Val2) \
+ __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, nextafterx)
+
+/* Return the remainder of integer divison X / Y with infinite precision. */
+#define remainder(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, remainder)
+
+/* Return X times (2 to the Nth power). */
+#define scalb(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, scalb)
+
+/* Return X times (2 to the Nth power). */
+#define scalbn(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, scalbn)
+
+/* Return X times (2 to the Nth power). */
+#define scalbln(Val1, Val2) \
+ __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, scalbln)
+
+/* Return the binary exponent of X, which must be nonzero. */
+#define ilogb(Val) __TGMATH_UNARY_REAL_ONLY (Val, ilogb)
+
+
+/* Return positive difference between X and Y. */
+#define fdim(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fdim)
+
+/* Return maximum numeric value from X and Y. */
+#define fmax(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmax)
+
+/* Return minimum numeric value from X and Y. */
+#define fmin(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmin)
+
+
+/* Absolute value, conjugates, and projection. */
+
+/* Argument value of Z. */
+#define carg(Val) __TGMATH_UNARY_IMAG_ONLY (Val, carg)
+
+/* Complex conjugate of Z. */
+#define conj(Val) __TGMATH_UNARY_IMAG_ONLY (Val, conj)
+
+/* Projection of Z onto the Riemann sphere. */
+#define cproj(Val) __TGMATH_UNARY_IMAG_ONLY (Val, cproj)
+
+
+/* Decomposing complex values. */
+
+/* Imaginary part of Z. */
+#define cimag(Val) __TGMATH_UNARY_IMAG_ONLY (Val, cimag)
+
+/* Real part of Z. */
+#define creal(Val) __TGMATH_UNARY_IMAG_ONLY (Val, creal)
+
+#endif /* tgmath.h */