diff options
Diffstat (limited to 'math')
| -rw-r--r-- | math/Makefile | 10 | ||||
| -rw-r--r-- | math/bits/cmathcalls.h | 5 | ||||
| -rw-r--r-- | math/bits/mathcalls.h | 25 | ||||
| -rw-r--r-- | math/libm-test.c | 216 | ||||
| -rw-r--r-- | math/libm.map | 11 | ||||
| -rw-r--r-- | math/math.h | 25 | ||||
| -rw-r--r-- | math/test-double.c | 1 | ||||
| -rw-r--r-- | math/test-float.c | 1 | ||||
| -rw-r--r-- | math/test-idouble.c | 1 | ||||
| -rw-r--r-- | math/test-ifloat.c | 3 | ||||
| -rw-r--r-- | math/tgmath.h | 312 |
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 */ |