From 2af193e575ae45f10a13624d1242fc6fd424cdf6 Mon Sep 17 00:00:00 2001 From: ngie Date: Mon, 18 Jan 2016 03:55:40 +0000 Subject: MFC r292497: Integrate the remaining tools/regression/lib/msun testcases into the FreeBSD test suite under lib/msun/tests --- lib/msun/tests/Makefile | 8 +- lib/msun/tests/ctrig_test.c | 482 +++++++++++++++++++++++++++++++++ lib/msun/tests/exponential_test.c | 169 ++++++++++++ lib/msun/tests/fma_test.c | 542 ++++++++++++++++++++++++++++++++++++++ lib/msun/tests/invtrig_test.c | 479 +++++++++++++++++++++++++++++++++ lib/msun/tests/lround_test.c | 115 ++++++++ lib/msun/tests/lround_test.t | 10 + lib/msun/tests/test-utils.h | 174 ++++++++++++ 8 files changed, 1978 insertions(+), 1 deletion(-) create mode 100644 lib/msun/tests/ctrig_test.c create mode 100644 lib/msun/tests/exponential_test.c create mode 100644 lib/msun/tests/fma_test.c create mode 100644 lib/msun/tests/invtrig_test.c create mode 100644 lib/msun/tests/lround_test.c create mode 100644 lib/msun/tests/lround_test.t create mode 100644 lib/msun/tests/test-utils.h (limited to 'lib/msun') diff --git a/lib/msun/tests/Makefile b/lib/msun/tests/Makefile index ffa1765..2561ef7 100644 --- a/lib/msun/tests/Makefile +++ b/lib/msun/tests/Makefile @@ -39,12 +39,19 @@ NETBSD_ATF_TESTS_C+= tanh_test TAP_TESTS_C+= cexp_test TAP_TESTS_C+= conj_test TAP_TESTS_C+= csqrt_test +TAP_TESTS_C+= ctrig_test +TAP_TESTS_C+= exponential_test TAP_TESTS_C+= fenv_test +TAP_TESTS_C+= fma_test TAP_TESTS_C+= fmaxmin_test TAP_TESTS_C+= ilogb_test +TAP_TESTS_C+= invtrig_test TAP_TESTS_C+= invctrig_test TAP_TESTS_C+= logarithm_test TAP_TESTS_C+= lrint_test +# XXX: the testcase crashes on all platforms, but only on head +# (bug 205451) +#TAP_TESTS_C+= lround_test TAP_TESTS_C+= nan_test TAP_TESTS_C+= nearbyint_test TAP_TESTS_C+= next_test @@ -53,7 +60,6 @@ TAP_TESTS_C+= trig_test .for t in ${TAP_TESTS_C} CFLAGS.$t+= -O0 -CFLAGS.$t+= -I${SRCTOP}/tools/regression/lib/msun .endfor CSTD= c99 diff --git a/lib/msun/tests/ctrig_test.c b/lib/msun/tests/ctrig_test.c new file mode 100644 index 0000000..475b6c5 --- /dev/null +++ b/lib/msun/tests/ctrig_test.c @@ -0,0 +1,482 @@ +/*- + * Copyright (c) 2008-2011 David Schultz + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * Tests for csin[h](), ccos[h](), and ctan[h](). + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include +#include +#include +#include + +#include "test-utils.h" + +#pragma STDC FENV_ACCESS ON +#pragma STDC CX_LIMITED_RANGE OFF + +/* + * Test that a function returns the correct value and sets the + * exception flags correctly. The exceptmask specifies which + * exceptions we should check. We need to be lenient for several + * reasons, but mainly because on some architectures it's impossible + * to raise FE_OVERFLOW without raising FE_INEXACT. + * + * These are macros instead of functions so that assert provides more + * meaningful error messages. + * + * XXX The volatile here is to avoid gcc's bogus constant folding and work + * around the lack of support for the FENV_ACCESS pragma. + */ +#define test_p(func, z, result, exceptmask, excepts, checksign) do { \ + volatile long double complex _d = z; \ + debug(" testing %s(%Lg + %Lg I) == %Lg + %Lg I\n", #func, \ + creall(_d), cimagl(_d), creall(result), cimagl(result)); \ + assert(feclearexcept(FE_ALL_EXCEPT) == 0); \ + assert(cfpequal_cs((func)(_d), (result), (checksign))); \ + assert(((void)(func), fetestexcept(exceptmask) == (excepts))); \ +} while (0) + +/* + * Test within a given tolerance. The tolerance indicates relative error + * in ulps. If result is 0, however, it measures absolute error in units + * of _EPSILON. + */ +#define test_p_tol(func, z, result, tol) do { \ + volatile long double complex _d = z; \ + debug(" testing %s(%Lg + %Lg I) ~= %Lg + %Lg I\n", #func, \ + creall(_d), cimagl(_d), creall(result), cimagl(result)); \ + assert(cfpequal_tol((func)(_d), (result), (tol), FPE_ABS_ZERO)); \ +} while (0) + +/* These wrappers apply the identities f(conj(z)) = conj(f(z)). */ +#define test(func, z, result, exceptmask, excepts, checksign) do { \ + test_p(func, z, result, exceptmask, excepts, checksign); \ + test_p(func, conjl(z), conjl(result), exceptmask, excepts, checksign); \ +} while (0) +#define test_tol(func, z, result, tol) do { \ + test_p_tol(func, z, result, tol); \ + test_p_tol(func, conjl(z), conjl(result), tol); \ +} while (0) +#define test_odd_tol(func, z, result, tol) do { \ + test_tol(func, z, result, tol); \ + test_tol(func, -(z), -(result), tol); \ +} while (0) +#define test_even_tol(func, z, result, tol) do { \ + test_tol(func, z, result, tol); \ + test_tol(func, -(z), result, tol); \ +} while (0) + +/* Test the given function in all precisions. */ +#define testall(func, x, result, exceptmask, excepts, checksign) do { \ + test(func, x, result, exceptmask, excepts, checksign); \ + test(func##f, x, result, exceptmask, excepts, checksign); \ +} while (0) +#define testall_odd(func, x, result, exceptmask, excepts, checksign) do { \ + testall(func, x, result, exceptmask, excepts, checksign); \ + testall(func, -x, -result, exceptmask, excepts, checksign); \ +} while (0) +#define testall_even(func, x, result, exceptmask, excepts, checksign) do { \ + testall(func, x, result, exceptmask, excepts, checksign); \ + testall(func, -x, result, exceptmask, excepts, checksign); \ +} while (0) + +/* + * Test the given function in all precisions, within a given tolerance. + * The tolerance is specified in ulps. + */ +#define testall_tol(func, x, result, tol) do { \ + test_tol(func, x, result, tol * DBL_ULP()); \ + test_tol(func##f, x, result, tol * FLT_ULP()); \ +} while (0) +#define testall_odd_tol(func, x, result, tol) do { \ + test_odd_tol(func, x, result, tol * DBL_ULP()); \ + test_odd_tol(func##f, x, result, tol * FLT_ULP()); \ +} while (0) +#define testall_even_tol(func, x, result, tol) do { \ + test_even_tol(func, x, result, tol * DBL_ULP()); \ + test_even_tol(func##f, x, result, tol * FLT_ULP()); \ +} while (0) + + +/* Tests for 0 */ +void +test_zero(void) +{ + long double complex zero = CMPLXL(0.0, 0.0); + + /* csinh(0) = ctanh(0) = 0; ccosh(0) = 1 (no exceptions raised) */ + testall_odd(csinh, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH); + testall_odd(csin, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH); + testall_even(ccosh, zero, 1.0, ALL_STD_EXCEPT, 0, CS_BOTH); + testall_even(ccos, zero, CMPLXL(1.0, -0.0), ALL_STD_EXCEPT, 0, CS_BOTH); + testall_odd(ctanh, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH); + testall_odd(ctan, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH); +} + +/* + * Tests for NaN inputs. + */ +void +test_nan() +{ + long double complex nan_nan = CMPLXL(NAN, NAN); + long double complex z; + + /* + * IN CSINH CCOSH CTANH + * NaN,NaN NaN,NaN NaN,NaN NaN,NaN + * finite,NaN NaN,NaN [inval] NaN,NaN [inval] NaN,NaN [inval] + * NaN,finite NaN,NaN [inval] NaN,NaN [inval] NaN,NaN [inval] + * NaN,Inf NaN,NaN [inval] NaN,NaN [inval] NaN,NaN [inval] + * Inf,NaN +-Inf,NaN Inf,NaN 1,+-0 + * 0,NaN +-0,NaN NaN,+-0 NaN,NaN [inval] + * NaN,0 NaN,0 NaN,+-0 NaN,0 + */ + z = nan_nan; + testall_odd(csinh, z, nan_nan, ALL_STD_EXCEPT, 0, 0); + testall_even(ccosh, z, nan_nan, ALL_STD_EXCEPT, 0, 0); + testall_odd(ctanh, z, nan_nan, ALL_STD_EXCEPT, 0, 0); + testall_odd(csin, z, nan_nan, ALL_STD_EXCEPT, 0, 0); + testall_even(ccos, z, nan_nan, ALL_STD_EXCEPT, 0, 0); + testall_odd(ctan, z, nan_nan, ALL_STD_EXCEPT, 0, 0); + + z = CMPLXL(42, NAN); + testall_odd(csinh, z, nan_nan, OPT_INVALID, 0, 0); + testall_even(ccosh, z, nan_nan, OPT_INVALID, 0, 0); + /* XXX We allow a spurious inexact exception here. */ + testall_odd(ctanh, z, nan_nan, OPT_INVALID & ~FE_INEXACT, 0, 0); + testall_odd(csin, z, nan_nan, OPT_INVALID, 0, 0); + testall_even(ccos, z, nan_nan, OPT_INVALID, 0, 0); + testall_odd(ctan, z, nan_nan, OPT_INVALID, 0, 0); + + z = CMPLXL(NAN, 42); + testall_odd(csinh, z, nan_nan, OPT_INVALID, 0, 0); + testall_even(ccosh, z, nan_nan, OPT_INVALID, 0, 0); + testall_odd(ctanh, z, nan_nan, OPT_INVALID, 0, 0); + testall_odd(csin, z, nan_nan, OPT_INVALID, 0, 0); + testall_even(ccos, z, nan_nan, OPT_INVALID, 0, 0); + /* XXX We allow a spurious inexact exception here. */ + testall_odd(ctan, z, nan_nan, OPT_INVALID & ~FE_INEXACT, 0, 0); + + z = CMPLXL(NAN, INFINITY); + testall_odd(csinh, z, nan_nan, OPT_INVALID, 0, 0); + testall_even(ccosh, z, nan_nan, OPT_INVALID, 0, 0); + testall_odd(ctanh, z, nan_nan, OPT_INVALID, 0, 0); + testall_odd(csin, z, CMPLXL(NAN, INFINITY), ALL_STD_EXCEPT, 0, 0); + testall_even(ccos, z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, 0, + CS_IMAG); + testall_odd(ctan, z, CMPLXL(0, 1), ALL_STD_EXCEPT, 0, CS_IMAG); + + z = CMPLXL(INFINITY, NAN); + testall_odd(csinh, z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, 0, 0); + testall_even(ccosh, z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, 0, + CS_REAL); + testall_odd(ctanh, z, CMPLXL(1, 0), ALL_STD_EXCEPT, 0, CS_REAL); + testall_odd(csin, z, nan_nan, OPT_INVALID, 0, 0); + testall_even(ccos, z, nan_nan, OPT_INVALID, 0, 0); + testall_odd(ctan, z, nan_nan, OPT_INVALID, 0, 0); + + z = CMPLXL(0, NAN); + testall_odd(csinh, z, CMPLXL(0, NAN), ALL_STD_EXCEPT, 0, 0); + testall_even(ccosh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0); + testall_odd(ctanh, z, nan_nan, OPT_INVALID, 0, 0); + testall_odd(csin, z, CMPLXL(0, NAN), ALL_STD_EXCEPT, 0, CS_REAL); + testall_even(ccos, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0); + testall_odd(ctan, z, CMPLXL(0, NAN), ALL_STD_EXCEPT, 0, CS_REAL); + + z = CMPLXL(NAN, 0); + testall_odd(csinh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, CS_IMAG); + testall_even(ccosh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0); + testall_odd(ctanh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, CS_IMAG); + testall_odd(csin, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0); + testall_even(ccos, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0); + testall_odd(ctan, z, nan_nan, OPT_INVALID, 0, 0); +} + +void +test_inf(void) +{ + static const long double finites[] = { + 0, M_PI / 4, 3 * M_PI / 4, 5 * M_PI / 4, + }; + long double complex z, c, s; + int i; + + /* + * IN CSINH CCOSH CTANH + * Inf,Inf +-Inf,NaN inval +-Inf,NaN inval 1,+-0 + * Inf,finite Inf cis(finite) Inf cis(finite) 1,0 sin(2 finite) + * 0,Inf +-0,NaN inval NaN,+-0 inval NaN,NaN inval + * finite,Inf NaN,NaN inval NaN,NaN inval NaN,NaN inval + */ + z = CMPLXL(INFINITY, INFINITY); + testall_odd(csinh, z, CMPLXL(INFINITY, NAN), + ALL_STD_EXCEPT, FE_INVALID, 0); + testall_even(ccosh, z, CMPLXL(INFINITY, NAN), + ALL_STD_EXCEPT, FE_INVALID, 0); + testall_odd(ctanh, z, CMPLXL(1, 0), ALL_STD_EXCEPT, 0, CS_REAL); + testall_odd(csin, z, CMPLXL(NAN, INFINITY), + ALL_STD_EXCEPT, FE_INVALID, 0); + testall_even(ccos, z, CMPLXL(INFINITY, NAN), + ALL_STD_EXCEPT, FE_INVALID, 0); + testall_odd(ctan, z, CMPLXL(0, 1), ALL_STD_EXCEPT, 0, CS_REAL); + + /* XXX We allow spurious inexact exceptions here (hard to avoid). */ + for (i = 0; i < sizeof(finites) / sizeof(finites[0]); i++) { + z = CMPLXL(INFINITY, finites[i]); + c = INFINITY * cosl(finites[i]); + s = finites[i] == 0 ? finites[i] : INFINITY * sinl(finites[i]); + testall_odd(csinh, z, CMPLXL(c, s), OPT_INEXACT, 0, CS_BOTH); + testall_even(ccosh, z, CMPLXL(c, s), OPT_INEXACT, 0, CS_BOTH); + testall_odd(ctanh, z, CMPLXL(1, 0 * sin(finites[i] * 2)), + OPT_INEXACT, 0, CS_BOTH); + z = CMPLXL(finites[i], INFINITY); + testall_odd(csin, z, CMPLXL(s, c), OPT_INEXACT, 0, CS_BOTH); + testall_even(ccos, z, CMPLXL(c, -s), OPT_INEXACT, 0, CS_BOTH); + testall_odd(ctan, z, CMPLXL(0 * sin(finites[i] * 2), 1), + OPT_INEXACT, 0, CS_BOTH); + } + + z = CMPLXL(0, INFINITY); + testall_odd(csinh, z, CMPLXL(0, NAN), ALL_STD_EXCEPT, FE_INVALID, 0); + testall_even(ccosh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, FE_INVALID, 0); + testall_odd(ctanh, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0); + z = CMPLXL(INFINITY, 0); + testall_odd(csin, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, FE_INVALID, 0); + testall_even(ccos, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, FE_INVALID, 0); + testall_odd(ctan, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0); + + z = CMPLXL(42, INFINITY); + testall_odd(csinh, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0); + testall_even(ccosh, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0); + /* XXX We allow a spurious inexact exception here. */ + testall_odd(ctanh, z, CMPLXL(NAN, NAN), OPT_INEXACT, FE_INVALID, 0); + z = CMPLXL(INFINITY, 42); + testall_odd(csin, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0); + testall_even(ccos, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0); + /* XXX We allow a spurious inexact exception here. */ + testall_odd(ctan, z, CMPLXL(NAN, NAN), OPT_INEXACT, FE_INVALID, 0); +} + +/* Tests along the real and imaginary axes. */ +void +test_axes(void) +{ + static const long double nums[] = { + M_PI / 4, M_PI / 2, 3 * M_PI / 4, + 5 * M_PI / 4, 3 * M_PI / 2, 7 * M_PI / 4, + }; + long double complex z; + int i; + + for (i = 0; i < sizeof(nums) / sizeof(nums[0]); i++) { + /* Real axis */ + z = CMPLXL(nums[i], 0.0); + test_odd_tol(csinh, z, CMPLXL(sinh(nums[i]), 0), DBL_ULP()); + test_even_tol(ccosh, z, CMPLXL(cosh(nums[i]), 0), DBL_ULP()); + test_odd_tol(ctanh, z, CMPLXL(tanh(nums[i]), 0), DBL_ULP()); + test_odd_tol(csin, z, CMPLXL(sin(nums[i]), + copysign(0, cos(nums[i]))), DBL_ULP()); + test_even_tol(ccos, z, CMPLXL(cos(nums[i]), + -copysign(0, sin(nums[i]))), DBL_ULP()); + test_odd_tol(ctan, z, CMPLXL(tan(nums[i]), 0), DBL_ULP()); + + test_odd_tol(csinhf, z, CMPLXL(sinhf(nums[i]), 0), FLT_ULP()); + test_even_tol(ccoshf, z, CMPLXL(coshf(nums[i]), 0), FLT_ULP()); + printf("%a %a\n", creal(z), cimag(z)); + printf("%a %a\n", creal(ctanhf(z)), cimag(ctanhf(z))); + printf("%a\n", nextafterf(tanhf(nums[i]), INFINITY)); + test_odd_tol(ctanhf, z, CMPLXL(tanhf(nums[i]), 0), + 1.3 * FLT_ULP()); + test_odd_tol(csinf, z, CMPLXL(sinf(nums[i]), + copysign(0, cosf(nums[i]))), FLT_ULP()); + test_even_tol(ccosf, z, CMPLXL(cosf(nums[i]), + -copysign(0, sinf(nums[i]))), 2 * FLT_ULP()); + test_odd_tol(ctanf, z, CMPLXL(tanf(nums[i]), 0), FLT_ULP()); + + /* Imaginary axis */ + z = CMPLXL(0.0, nums[i]); + test_odd_tol(csinh, z, CMPLXL(copysign(0, cos(nums[i])), + sin(nums[i])), DBL_ULP()); + test_even_tol(ccosh, z, CMPLXL(cos(nums[i]), + copysign(0, sin(nums[i]))), DBL_ULP()); + test_odd_tol(ctanh, z, CMPLXL(0, tan(nums[i])), DBL_ULP()); + test_odd_tol(csin, z, CMPLXL(0, sinh(nums[i])), DBL_ULP()); + test_even_tol(ccos, z, CMPLXL(cosh(nums[i]), -0.0), DBL_ULP()); + test_odd_tol(ctan, z, CMPLXL(0, tanh(nums[i])), DBL_ULP()); + + test_odd_tol(csinhf, z, CMPLXL(copysign(0, cosf(nums[i])), + sinf(nums[i])), FLT_ULP()); + test_even_tol(ccoshf, z, CMPLXL(cosf(nums[i]), + copysign(0, sinf(nums[i]))), FLT_ULP()); + test_odd_tol(ctanhf, z, CMPLXL(0, tanf(nums[i])), FLT_ULP()); + test_odd_tol(csinf, z, CMPLXL(0, sinhf(nums[i])), FLT_ULP()); + test_even_tol(ccosf, z, CMPLXL(coshf(nums[i]), -0.0), + FLT_ULP()); + test_odd_tol(ctanf, z, CMPLXL(0, tanhf(nums[i])), + 1.3 * FLT_ULP()); + } +} + +void +test_small(void) +{ + /* + * z = 0.5 + i Pi/4 + * sinh(z) = (sinh(0.5) + i cosh(0.5)) * sqrt(2)/2 + * cosh(z) = (cosh(0.5) + i sinh(0.5)) * sqrt(2)/2 + * tanh(z) = (2cosh(0.5)sinh(0.5) + i) / (2 cosh(0.5)**2 - 1) + * z = -0.5 + i Pi/2 + * sinh(z) = cosh(0.5) + * cosh(z) = -i sinh(0.5) + * tanh(z) = -coth(0.5) + * z = 1.0 + i 3Pi/4 + * sinh(z) = (-sinh(1) + i cosh(1)) * sqrt(2)/2 + * cosh(z) = (-cosh(1) + i sinh(1)) * sqrt(2)/2 + * tanh(z) = (2cosh(1)sinh(1) - i) / (2cosh(1)**2 - 1) + */ + static const struct { + long double a, b; + long double sinh_a, sinh_b; + long double cosh_a, cosh_b; + long double tanh_a, tanh_b; + } tests[] = { + { 0.5L, + 0.78539816339744830961566084581987572L, + 0.36847002415910435172083660522240710L, + 0.79735196663945774996093142586179334L, + 0.79735196663945774996093142586179334L, + 0.36847002415910435172083660522240710L, + 0.76159415595576488811945828260479359L, + 0.64805427366388539957497735322615032L }, + { -0.5L, + 1.57079632679489661923132169163975144L, + 0.0L, + 1.12762596520638078522622516140267201L, + 0.0L, + -0.52109530549374736162242562641149156L, + -2.16395341373865284877000401021802312L, + 0.0L }, + { 1.0L, + 2.35619449019234492884698253745962716L, + -0.83099273328405698212637979852748608L, + 1.09112278079550143030545602018565236L, + -1.09112278079550143030545602018565236L, + 0.83099273328405698212637979852748609L, + 0.96402758007581688394641372410092315L, + -0.26580222883407969212086273981988897L } + }; + long double complex z; + int i; + + for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) { + z = CMPLXL(tests[i].a, tests[i].b); + testall_odd_tol(csinh, z, + CMPLXL(tests[i].sinh_a, tests[i].sinh_b), 1.1); + testall_even_tol(ccosh, z, + CMPLXL(tests[i].cosh_a, tests[i].cosh_b), 1.1); + testall_odd_tol(ctanh, z, + CMPLXL(tests[i].tanh_a, tests[i].tanh_b), 1.4); + } +} + +/* Test inputs that might cause overflow in a sloppy implementation. */ +void +test_large(void) +{ + long double complex z; + + /* tanh() uses a threshold around x=22, so check both sides. */ + z = CMPLXL(21, 0.78539816339744830961566084581987572L); + testall_odd_tol(ctanh, z, + CMPLXL(1.0, 1.14990445285871196133287617611468468e-18L), 1.2); + z++; + testall_odd_tol(ctanh, z, + CMPLXL(1.0, 1.55622644822675930314266334585597964e-19L), 1); + + z = CMPLXL(355, 0.78539816339744830961566084581987572L); + test_odd_tol(ctanh, z, + CMPLXL(1.0, 8.95257245135025991216632140458264468e-309L), + DBL_ULP()); +#if !defined(__i386__) + z = CMPLXL(30, 0x1p1023L); + test_odd_tol(ctanh, z, + CMPLXL(1.0, -1.62994325413993477997492170229268382e-26L), + DBL_ULP()); + z = CMPLXL(1, 0x1p1023L); + test_odd_tol(ctanh, z, + CMPLXL(0.878606311888306869546254022621986509L, + -0.225462792499754505792678258169527424L), + DBL_ULP()); +#endif + + z = CMPLXL(710.6, 0.78539816339744830961566084581987572L); + test_odd_tol(csinh, z, + CMPLXL(1.43917579766621073533185387499658944e308L, + 1.43917579766621073533185387499658944e308L), DBL_ULP()); + test_even_tol(ccosh, z, + CMPLXL(1.43917579766621073533185387499658944e308L, + 1.43917579766621073533185387499658944e308L), DBL_ULP()); + + z = CMPLXL(1500, 0.78539816339744830961566084581987572L); + testall_odd(csinh, z, CMPLXL(INFINITY, INFINITY), OPT_INEXACT, + FE_OVERFLOW, CS_BOTH); + testall_even(ccosh, z, CMPLXL(INFINITY, INFINITY), OPT_INEXACT, + FE_OVERFLOW, CS_BOTH); +} + +int +main(int argc, char *argv[]) +{ + + printf("1..6\n"); + + test_zero(); + printf("ok 1 - ctrig zero\n"); + + test_nan(); + printf("ok 2 - ctrig nan\n"); + + test_inf(); + printf("ok 3 - ctrig inf\n"); + + test_axes(); + printf("ok 4 - ctrig axes\n"); + + test_small(); + printf("ok 5 - ctrig small\n"); + + test_large(); + printf("ok 6 - ctrig large\n"); + + return (0); +} diff --git a/lib/msun/tests/exponential_test.c b/lib/msun/tests/exponential_test.c new file mode 100644 index 0000000..df552ee --- /dev/null +++ b/lib/msun/tests/exponential_test.c @@ -0,0 +1,169 @@ +/*- + * Copyright (c) 2008 David Schultz + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * Tests for corner cases in exp*(). + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include +#include +#include + +#ifdef __i386__ +#include +#endif + +#include "test-utils.h" + +#pragma STDC FENV_ACCESS ON + +/* + * Test that a function returns the correct value and sets the + * exception flags correctly. The exceptmask specifies which + * exceptions we should check. We need to be lenient for several + * reasoons, but mainly because on some architectures it's impossible + * to raise FE_OVERFLOW without raising FE_INEXACT. + * + * These are macros instead of functions so that assert provides more + * meaningful error messages. + * + * XXX The volatile here is to avoid gcc's bogus constant folding and work + * around the lack of support for the FENV_ACCESS pragma. + */ +#define test(func, x, result, exceptmask, excepts) do { \ + volatile long double _d = x; \ + assert(feclearexcept(FE_ALL_EXCEPT) == 0); \ + assert(fpequal((func)(_d), (result))); \ + assert(((void)(func), fetestexcept(exceptmask) == (excepts))); \ +} while (0) + +/* Test all the functions that compute b^x. */ +#define _testall0(x, result, exceptmask, excepts) do { \ + test(exp, x, result, exceptmask, excepts); \ + test(expf, x, result, exceptmask, excepts); \ + test(exp2, x, result, exceptmask, excepts); \ + test(exp2f, x, result, exceptmask, excepts); \ +} while (0) + +/* Skip over exp2l on platforms that don't support it. */ +#if LDBL_PREC == 53 +#define testall0 _testall0 +#else +#define testall0(x, result, exceptmask, excepts) do { \ + _testall0(x, result, exceptmask, excepts); \ + test(exp2l, x, result, exceptmask, excepts); \ +} while (0) +#endif + +/* Test all the functions that compute b^x - 1. */ +#define testall1(x, result, exceptmask, excepts) do { \ + test(expm1, x, result, exceptmask, excepts); \ + test(expm1f, x, result, exceptmask, excepts); \ +} while (0) + +void +run_generic_tests(void) +{ + + /* exp(0) == 1, no exceptions raised */ + testall0(0.0, 1.0, ALL_STD_EXCEPT, 0); + testall1(0.0, 0.0, ALL_STD_EXCEPT, 0); + testall0(-0.0, 1.0, ALL_STD_EXCEPT, 0); + testall1(-0.0, -0.0, ALL_STD_EXCEPT, 0); + + /* exp(NaN) == NaN, no exceptions raised */ + testall0(NAN, NAN, ALL_STD_EXCEPT, 0); + testall1(NAN, NAN, ALL_STD_EXCEPT, 0); + + /* exp(Inf) == Inf, no exceptions raised */ + testall0(INFINITY, INFINITY, ALL_STD_EXCEPT, 0); + testall1(INFINITY, INFINITY, ALL_STD_EXCEPT, 0); + + /* exp(-Inf) == 0, no exceptions raised */ + testall0(-INFINITY, 0.0, ALL_STD_EXCEPT, 0); + testall1(-INFINITY, -1.0, ALL_STD_EXCEPT, 0); + +#if !defined(__i386__) + /* exp(big) == Inf, overflow exception */ + testall0(50000.0, INFINITY, ALL_STD_EXCEPT & ~FE_INEXACT, FE_OVERFLOW); + testall1(50000.0, INFINITY, ALL_STD_EXCEPT & ~FE_INEXACT, FE_OVERFLOW); + + /* exp(small) == 0, underflow and inexact exceptions */ + testall0(-50000.0, 0.0, ALL_STD_EXCEPT, FE_UNDERFLOW | FE_INEXACT); +#endif + testall1(-50000.0, -1.0, ALL_STD_EXCEPT, FE_INEXACT); +} + +void +run_exp2_tests(void) +{ + int i; + + /* + * We should insist that exp2() return exactly the correct + * result and not raise an inexact exception for integer + * arguments. + */ + feclearexcept(FE_ALL_EXCEPT); + for (i = FLT_MIN_EXP - FLT_MANT_DIG; i < FLT_MAX_EXP; i++) { + assert(exp2f(i) == ldexpf(1.0, i)); + assert(fetestexcept(ALL_STD_EXCEPT) == 0); + } + for (i = DBL_MIN_EXP - DBL_MANT_DIG; i < DBL_MAX_EXP; i++) { + assert(exp2(i) == ldexp(1.0, i)); + assert(fetestexcept(ALL_STD_EXCEPT) == 0); + } + for (i = LDBL_MIN_EXP - LDBL_MANT_DIG; i < LDBL_MAX_EXP; i++) { + assert(exp2l(i) == ldexpl(1.0, i)); + assert(fetestexcept(ALL_STD_EXCEPT) == 0); + } +} + +int +main(int argc, char *argv[]) +{ + + printf("1..3\n"); + + run_generic_tests(); + printf("ok 1 - exponential\n"); + +#ifdef __i386__ + fpsetprec(FP_PE); + run_generic_tests(); +#endif + printf("ok 2 - exponential\n"); + + run_exp2_tests(); + printf("ok 3 - exponential\n"); + + return (0); +} diff --git a/lib/msun/tests/fma_test.c b/lib/msun/tests/fma_test.c new file mode 100644 index 0000000..af7910e --- /dev/null +++ b/lib/msun/tests/fma_test.c @@ -0,0 +1,542 @@ +/*- + * Copyright (c) 2008 David Schultz + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * Tests for fma{,f,l}(). + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include +#include +#include +#include +#include + +#include "test-utils.h" + +#pragma STDC FENV_ACCESS ON + +/* + * Test that a function returns the correct value and sets the + * exception flags correctly. The exceptmask specifies which + * exceptions we should check. We need to be lenient for several + * reasons, but mainly because on some architectures it's impossible + * to raise FE_OVERFLOW without raising FE_INEXACT. + * + * These are macros instead of functions so that assert provides more + * meaningful error messages. + */ +#define test(func, x, y, z, result, exceptmask, excepts) do { \ + volatile long double _vx = (x), _vy = (y), _vz = (z); \ + assert(feclearexcept(FE_ALL_EXCEPT) == 0); \ + assert(fpequal((func)(_vx, _vy, _vz), (result))); \ + assert(((void)(func), fetestexcept(exceptmask) == (excepts))); \ +} while (0) + +#define testall(x, y, z, result, exceptmask, excepts) do { \ + test(fma, (double)(x), (double)(y), (double)(z), \ + (double)(result), (exceptmask), (excepts)); \ + test(fmaf, (float)(x), (float)(y), (float)(z), \ + (float)(result), (exceptmask), (excepts)); \ + test(fmal, (x), (y), (z), (result), (exceptmask), (excepts)); \ +} while (0) + +/* Test in all rounding modes. */ +#define testrnd(func, x, y, z, rn, ru, rd, rz, exceptmask, excepts) do { \ + fesetround(FE_TONEAREST); \ + test((func), (x), (y), (z), (rn), (exceptmask), (excepts)); \ + fesetround(FE_UPWARD); \ + test((func), (x), (y), (z), (ru), (exceptmask), (excepts)); \ + fesetround(FE_DOWNWARD); \ + test((func), (x), (y), (z), (rd), (exceptmask), (excepts)); \ + fesetround(FE_TOWARDZERO); \ + test((func), (x), (y), (z), (rz), (exceptmask), (excepts)); \ +} while (0) + +/* + * This is needed because clang constant-folds fma in ways that are incorrect + * in rounding modes other than FE_TONEAREST. + */ +volatile double one = 1.0; + +static void +test_zeroes(void) +{ + const int rd = (fegetround() == FE_DOWNWARD); + + testall(0.0, 0.0, 0.0, 0.0, ALL_STD_EXCEPT, 0); + testall(1.0, 0.0, 0.0, 0.0, ALL_STD_EXCEPT, 0); + testall(0.0, 1.0, 0.0, 0.0, ALL_STD_EXCEPT, 0); + testall(0.0, 0.0, 1.0, 1.0, ALL_STD_EXCEPT, 0); + + testall(-0.0, 0.0, 0.0, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0); + testall(0.0, -0.0, 0.0, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0); + testall(-0.0, -0.0, 0.0, 0.0, ALL_STD_EXCEPT, 0); + testall(0.0, 0.0, -0.0, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0); + testall(-0.0, -0.0, -0.0, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0); + + testall(-0.0, 0.0, -0.0, -0.0, ALL_STD_EXCEPT, 0); + testall(0.0, -0.0, -0.0, -0.0, ALL_STD_EXCEPT, 0); + + testall(-one, one, one, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0); + testall(one, -one, one, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0); + testall(-one, -one, -one, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0); + + switch (fegetround()) { + case FE_TONEAREST: + case FE_TOWARDZERO: + test(fmaf, -FLT_MIN, FLT_MIN, 0.0, -0.0, + ALL_STD_EXCEPT, FE_INEXACT | FE_UNDERFLOW); + test(fma, -DBL_MIN, DBL_MIN, 0.0, -0.0, + ALL_STD_EXCEPT, FE_INEXACT | FE_UNDERFLOW); + test(fmal, -LDBL_MIN, LDBL_MIN, 0.0, -0.0, + ALL_STD_EXCEPT, FE_INEXACT | FE_UNDERFLOW); + } +} + +static void +test_infinities(void) +{ + + testall(INFINITY, 1.0, -1.0, INFINITY, ALL_STD_EXCEPT, 0); + testall(-1.0, INFINITY, 0.0, -INFINITY, ALL_STD_EXCEPT, 0); + testall(0.0, 0.0, INFINITY, INFINITY, ALL_STD_EXCEPT, 0); + testall(1.0, 1.0, INFINITY, INFINITY, ALL_STD_EXCEPT, 0); + testall(1.0, 1.0, -INFINITY, -INFINITY, ALL_STD_EXCEPT, 0); + + testall(INFINITY, -INFINITY, 1.0, -INFINITY, ALL_STD_EXCEPT, 0); + testall(INFINITY, INFINITY, 1.0, INFINITY, ALL_STD_EXCEPT, 0); + testall(-INFINITY, -INFINITY, INFINITY, INFINITY, ALL_STD_EXCEPT, 0); + + testall(0.0, INFINITY, 1.0, NAN, ALL_STD_EXCEPT, FE_INVALID); + testall(INFINITY, 0.0, -0.0, NAN, ALL_STD_EXCEPT, FE_INVALID); + + /* The invalid exception is optional in this case. */ + testall(INFINITY, 0.0, NAN, NAN, ALL_STD_EXCEPT & ~FE_INVALID, 0); + + testall(INFINITY, INFINITY, -INFINITY, NAN, + ALL_STD_EXCEPT, FE_INVALID); + testall(-INFINITY, INFINITY, INFINITY, NAN, + ALL_STD_EXCEPT, FE_INVALID); + testall(INFINITY, -1.0, INFINITY, NAN, + ALL_STD_EXCEPT, FE_INVALID); + + test(fmaf, FLT_MAX, FLT_MAX, -INFINITY, -INFINITY, ALL_STD_EXCEPT, 0); + test(fma, DBL_MAX, DBL_MAX, -INFINITY, -INFINITY, ALL_STD_EXCEPT, 0); + test(fmal, LDBL_MAX, LDBL_MAX, -INFINITY, -INFINITY, + ALL_STD_EXCEPT, 0); + test(fmaf, FLT_MAX, -FLT_MAX, INFINITY, INFINITY, ALL_STD_EXCEPT, 0); + test(fma, DBL_MAX, -DBL_MAX, INFINITY, INFINITY, ALL_STD_EXCEPT, 0); + test(fmal, LDBL_MAX, -LDBL_MAX, INFINITY, INFINITY, + ALL_STD_EXCEPT, 0); +} + +static void +test_nans(void) +{ + + testall(NAN, 0.0, 0.0, NAN, ALL_STD_EXCEPT, 0); + testall(1.0, NAN, 1.0, NAN, ALL_STD_EXCEPT, 0); + testall(1.0, -1.0, NAN, NAN, ALL_STD_EXCEPT, 0); + testall(0.0, 0.0, NAN, NAN, ALL_STD_EXCEPT, 0); + testall(NAN, NAN, NAN, NAN, ALL_STD_EXCEPT, 0); + + /* x*y should not raise an inexact/overflow/underflow if z is NaN. */ + testall(M_PI, M_PI, NAN, NAN, ALL_STD_EXCEPT, 0); + test(fmaf, FLT_MIN, FLT_MIN, NAN, NAN, ALL_STD_EXCEPT, 0); + test(fma, DBL_MIN, DBL_MIN, NAN, NAN, ALL_STD_EXCEPT, 0); + test(fmal, LDBL_MIN, LDBL_MIN, NAN, NAN, ALL_STD_EXCEPT, 0); + test(fmaf, FLT_MAX, FLT_MAX, NAN, NAN, ALL_STD_EXCEPT, 0); + test(fma, DBL_MAX, DBL_MAX, NAN, NAN, ALL_STD_EXCEPT, 0); + test(fmal, LDBL_MAX, LDBL_MAX, NAN, NAN, ALL_STD_EXCEPT, 0); +} + +/* + * Tests for cases where z is very small compared to x*y. + */ +static void +test_small_z(void) +{ + + /* x*y positive, z positive */ + if (fegetround() == FE_UPWARD) { + test(fmaf, one, one, 0x1.0p-100, 1.0 + FLT_EPSILON, + ALL_STD_EXCEPT, FE_INEXACT); + test(fma, one, one, 0x1.0p-200, 1.0 + DBL_EPSILON, + ALL_STD_EXCEPT, FE_INEXACT); + test(fmal, one, one, 0x1.0p-200, 1.0 + LDBL_EPSILON, + ALL_STD_EXCEPT, FE_INEXACT); + } else { + testall(0x1.0p100, one, 0x1.0p-100, 0x1.0p100, + ALL_STD_EXCEPT, FE_INEXACT); + } + + /* x*y negative, z negative */ + if (fegetround() == FE_DOWNWARD) { + test(fmaf, -one, one, -0x1.0p-100, -(1.0 + FLT_EPSILON), + ALL_STD_EXCEPT, FE_INEXACT); + test(fma, -one, one, -0x1.0p-200, -(1.0 + DBL_EPSILON), + ALL_STD_EXCEPT, FE_INEXACT); + test(fmal, -one, one, -0x1.0p-200, -(1.0 + LDBL_EPSILON), + ALL_STD_EXCEPT, FE_INEXACT); + } else { + testall(0x1.0p100, -one, -0x1.0p-100, -0x1.0p100, + ALL_STD_EXCEPT, FE_INEXACT); + } + + /* x*y positive, z negative */ + if (fegetround() == FE_DOWNWARD || fegetround() == FE_TOWARDZERO) { + test(fmaf, one, one, -0x1.0p-100, 1.0 - FLT_EPSILON / 2, + ALL_STD_EXCEPT, FE_INEXACT); + test(fma, one, one, -0x1.0p-200, 1.0 - DBL_EPSILON / 2, + ALL_STD_EXCEPT, FE_INEXACT); + test(fmal, one, one, -0x1.0p-200, 1.0 - LDBL_EPSILON / 2, + ALL_STD_EXCEPT, FE_INEXACT); + } else { + testall(0x1.0p100, one, -0x1.0p-100, 0x1.0p100, + ALL_STD_EXCEPT, FE_INEXACT); + } + + /* x*y negative, z positive */ + if (fegetround() == FE_UPWARD || fegetround() == FE_TOWARDZERO) { + test(fmaf, -one, one, 0x1.0p-100, -1.0 + FLT_EPSILON / 2, + ALL_STD_EXCEPT, FE_INEXACT); + test(fma, -one, one, 0x1.0p-200, -1.0 + DBL_EPSILON / 2, + ALL_STD_EXCEPT, FE_INEXACT); + test(fmal, -one, one, 0x1.0p-200, -1.0 + LDBL_EPSILON / 2, + ALL_STD_EXCEPT, FE_INEXACT); + } else { + testall(-0x1.0p100, one, 0x1.0p-100, -0x1.0p100, + ALL_STD_EXCEPT, FE_INEXACT); + } +} + +/* + * Tests for cases where z is very large compared to x*y. + */ +static void +test_big_z(void) +{ + + /* z positive, x*y positive */ + if (fegetround() == FE_UPWARD) { + test(fmaf, 0x1.0p-50, 0x1.0p-50, 1.0, 1.0 + FLT_EPSILON, + ALL_STD_EXCEPT, FE_INEXACT); + test(fma, 0x1.0p-100, 0x1.0p-100, 1.0, 1.0 + DBL_EPSILON, + ALL_STD_EXCEPT, FE_INEXACT); + test(fmal, 0x1.0p-100, 0x1.0p-100, 1.0, 1.0 + LDBL_EPSILON, + ALL_STD_EXCEPT, FE_INEXACT); + } else { + testall(-0x1.0p-50, -0x1.0p-50, 0x1.0p100, 0x1.0p100, + ALL_STD_EXCEPT, FE_INEXACT); + } + + /* z negative, x*y negative */ + if (fegetround() == FE_DOWNWARD) { + test(fmaf, -0x1.0p-50, 0x1.0p-50, -1.0, -(1.0 + FLT_EPSILON), + ALL_STD_EXCEPT, FE_INEXACT); + test(fma, -0x1.0p-100, 0x1.0p-100, -1.0, -(1.0 + DBL_EPSILON), + ALL_STD_EXCEPT, FE_INEXACT); + test(fmal, -0x1.0p-100, 0x1.0p-100, -1.0, -(1.0 + LDBL_EPSILON), + ALL_STD_EXCEPT, FE_INEXACT); + } else { + testall(0x1.0p-50, -0x1.0p-50, -0x1.0p100, -0x1.0p100, + ALL_STD_EXCEPT, FE_INEXACT); + } + + /* z negative, x*y positive */ + if (fegetround() == FE_UPWARD || fegetround() == FE_TOWARDZERO) { + test(fmaf, -0x1.0p-50, -0x1.0p-50, -1.0, + -1.0 + FLT_EPSILON / 2, ALL_STD_EXCEPT, FE_INEXACT); + test(fma, -0x1.0p-100, -0x1.0p-100, -1.0, + -1.0 + DBL_EPSILON / 2, ALL_STD_EXCEPT, FE_INEXACT); + test(fmal, -0x1.0p-100, -0x1.0p-100, -1.0, + -1.0 + LDBL_EPSILON / 2, ALL_STD_EXCEPT, FE_INEXACT); + } else { + testall(0x1.0p-50, 0x1.0p-50, -0x1.0p100, -0x1.0p100, + ALL_STD_EXCEPT, FE_INEXACT); + } + + /* z positive, x*y negative */ + if (fegetround() == FE_DOWNWARD || fegetround() == FE_TOWARDZERO) { + test(fmaf, 0x1.0p-50, -0x1.0p-50, 1.0, 1.0 - FLT_EPSILON / 2, + ALL_STD_EXCEPT, FE_INEXACT); + test(fma, 0x1.0p-100, -0x1.0p-100, 1.0, 1.0 - DBL_EPSILON / 2, + ALL_STD_EXCEPT, FE_INEXACT); + test(fmal, 0x1.0p-100, -0x1.0p-100, 1.0, 1.0 - LDBL_EPSILON / 2, + ALL_STD_EXCEPT, FE_INEXACT); + } else { + testall(-0x1.0p-50, 0x1.0p-50, 0x1.0p100, 0x1.0p100, + ALL_STD_EXCEPT, FE_INEXACT); + } +} + +static void +test_accuracy(void) +{ + + /* ilogb(x*y) - ilogb(z) = 20 */ + testrnd(fmaf, -0x1.c139d8p-51, -0x1.600e7ap32, 0x1.26558cp-38, + 0x1.34e48ap-18, 0x1.34e48cp-18, 0x1.34e48ap-18, 0x1.34e48ap-18, + ALL_STD_EXCEPT, FE_INEXACT); + testrnd(fma, -0x1.c139d7b84f1a3p-51, -0x1.600e7a2a16484p32, + 0x1.26558cac31580p-38, 0x1.34e48a78aae97p-18, + 0x1.34e48a78aae97p-18, 0x1.34e48a78aae96p-18, + 0x1.34e48a78aae96p-18, ALL_STD_EXCEPT, FE_INEXACT); +#if LDBL_MANT_DIG == 113 + testrnd(fmal, -0x1.c139d7b84f1a3079263afcc5bae3p-51L, + -0x1.600e7a2a164840edbe2e7d301a72p32L, + 0x1.26558cac315807eb07e448042101p-38L, + 0x1.34e48a78aae96c76ed36077dd387p-18L, + 0x1.34e48a78aae96c76ed36077dd388p-18L, + 0x1.34e48a78aae96c76ed36077dd387p-18L, + 0x1.34e48a78aae96c76ed36077dd387p-18L, + ALL_STD_EXCEPT, FE_INEXACT); +#elif LDBL_MANT_DIG == 64 + testrnd(fmal, -0x1.c139d7b84f1a307ap-51L, -0x1.600e7a2a164840eep32L, + 0x1.26558cac315807ecp-38L, 0x1.34e48a78aae96c78p-18L, + 0x1.34e48a78aae96c78p-18L, 0x1.34e48a78aae96c76p-18L, + 0x1.34e48a78aae96c76p-18L, ALL_STD_EXCEPT, FE_INEXACT); +#elif LDBL_MANT_DIG == 53 + testrnd(fmal, -0x1.c139d7b84f1a3p-51L, -0x1.600e7a2a16484p32L, + 0x1.26558cac31580p-38L, 0x1.34e48a78aae97p-18L, + 0x1.34e48a78aae97p-18L, 0x1.34e48a78aae96p-18L, + 0x1.34e48a78aae96p-18L, ALL_STD_EXCEPT, FE_INEXACT); +#endif + + /* ilogb(x*y) - ilogb(z) = -40 */ + testrnd(fmaf, 0x1.98210ap53, 0x1.9556acp-24, 0x1.d87da4p70, + 0x1.d87da4p70, 0x1.d87da6p70, 0x1.d87da4p70, 0x1.d87da4p70, + ALL_STD_EXCEPT, FE_INEXACT); + testrnd(fma, 0x1.98210ac83fe2bp53, 0x1.9556ac1475f0fp-24, + 0x1.d87da3aafc60ep70, 0x1.d87da3aafda40p70, + 0x1.d87da3aafda40p70, 0x1.d87da3aafda3fp70, + 0x1.d87da3aafda3fp70, ALL_STD_EXCEPT, FE_INEXACT); +#if LDBL_MANT_DIG == 113 + testrnd(fmal, 0x1.98210ac83fe2a8f65b6278b74cebp53L, + 0x1.9556ac1475f0f28968b61d0de65ap-24L, + 0x1.d87da3aafc60d830aa4c6d73b749p70L, + 0x1.d87da3aafda3f36a69eb86488224p70L, + 0x1.d87da3aafda3f36a69eb86488225p70L, + 0x1.d87da3aafda3f36a69eb86488224p70L, + 0x1.d87da3aafda3f36a69eb86488224p70L, + ALL_STD_EXCEPT, FE_INEXACT); +#elif LDBL_MANT_DIG == 64 + testrnd(fmal, 0x1.98210ac83fe2a8f6p53L, 0x1.9556ac1475f0f28ap-24L, + 0x1.d87da3aafc60d83p70L, 0x1.d87da3aafda3f36ap70L, + 0x1.d87da3aafda3f36ap70L, 0x1.d87da3aafda3f368p70L, + 0x1.d87da3aafda3f368p70L, ALL_STD_EXCEPT, FE_INEXACT); +#elif LDBL_MANT_DIG == 53 + testrnd(fmal, 0x1.98210ac83fe2bp53L, 0x1.9556ac1475f0fp-24L, + 0x1.d87da3aafc60ep70L, 0x1.d87da3aafda40p70L, + 0x1.d87da3aafda40p70L, 0x1.d87da3aafda3fp70L, + 0x1.d87da3aafda3fp70L, ALL_STD_EXCEPT, FE_INEXACT); +#endif + + /* ilogb(x*y) - ilogb(z) = 0 */ + testrnd(fmaf, 0x1.31ad02p+100, 0x1.2fbf7ap-42, -0x1.c3e106p+58, + -0x1.64c27cp+56, -0x1.64c27ap+56, -0x1.64c27cp+56, + -0x1.64c27ap+56, ALL_STD_EXCEPT, FE_INEXACT); + testrnd(fma, 0x1.31ad012ede8aap+100, 0x1.2fbf79c839067p-42, + -0x1.c3e106929056ep+58, -0x1.64c282b970a5fp+56, + -0x1.64c282b970a5ep+56, -0x1.64c282b970a5fp+56, + -0x1.64c282b970a5ep+56, ALL_STD_EXCEPT, FE_INEXACT); +#if LDBL_MANT_DIG == 113 + testrnd(fmal, 0x1.31ad012ede8aa282fa1c19376d16p+100L, + 0x1.2fbf79c839066f0f5c68f6d2e814p-42L, + -0x1.c3e106929056ec19de72bfe64215p+58L, + -0x1.64c282b970a612598fc025ca8cddp+56L, + -0x1.64c282b970a612598fc025ca8cddp+56L, + -0x1.64c282b970a612598fc025ca8cdep+56L, + -0x1.64c282b970a612598fc025ca8cddp+56L, + ALL_STD_EXCEPT, FE_INEXACT); +#elif LDBL_MANT_DIG == 64 + testrnd(fmal, 0x1.31ad012ede8aa4eap+100L, 0x1.2fbf79c839066aeap-42L, + -0x1.c3e106929056e61p+58L, -0x1.64c282b970a60298p+56L, + -0x1.64c282b970a60298p+56L, -0x1.64c282b970a6029ap+56L, + -0x1.64c282b970a60298p+56L, ALL_STD_EXCEPT, FE_INEXACT); +#elif LDBL_MANT_DIG == 53 + testrnd(fmal, 0x1.31ad012ede8aap+100L, 0x1.2fbf79c839067p-42L, + -0x1.c3e106929056ep+58L, -0x1.64c282b970a5fp+56L, + -0x1.64c282b970a5ep+56L, -0x1.64c282b970a5fp+56L, + -0x1.64c282b970a5ep+56L, ALL_STD_EXCEPT, FE_INEXACT); +#endif + + /* x*y (rounded) ~= -z */ + /* XXX spurious inexact exceptions */ + testrnd(fmaf, 0x1.bbffeep-30, -0x1.1d164cp-74, 0x1.ee7296p-104, + -0x1.c46ea8p-128, -0x1.c46ea8p-128, -0x1.c46ea8p-128, + -0x1.c46ea8p-128, ALL_STD_EXCEPT & ~FE_INEXACT, 0); + testrnd(fma, 0x1.bbffeea6fc7d6p-30, 0x1.1d164c6cbf078p-74, + -0x1.ee72993aff948p-104, -0x1.71f72ac7d9d8p-159, + -0x1.71f72ac7d9d8p-159, -0x1.71f72ac7d9d8p-159, + -0x1.71f72ac7d9d8p-159, ALL_STD_EXCEPT & ~FE_INEXACT, 0); +#if LDBL_MANT_DIG == 113 + testrnd(fmal, 0x1.bbffeea6fc7d65927d147f437675p-30L, + 0x1.1d164c6cbf078b7a22607d1cd6a2p-74L, + -0x1.ee72993aff94973876031bec0944p-104L, + 0x1.64e086175b3a2adc36e607058814p-217L, + 0x1.64e086175b3a2adc36e607058814p-217L, + 0x1.64e086175b3a2adc36e607058814p-217L, + 0x1.64e086175b3a2adc36e607058814p-217L, + ALL_STD_EXCEPT & ~FE_INEXACT, 0); +#elif LDBL_MANT_DIG == 64 + testrnd(fmal, 0x1.bbffeea6fc7d6592p-30L, 0x1.1d164c6cbf078b7ap-74L, + -0x1.ee72993aff949736p-104L, 0x1.af190e7a1ee6ad94p-168L, + 0x1.af190e7a1ee6ad94p-168L, 0x1.af190e7a1ee6ad94p-168L, + 0x1.af190e7a1ee6ad94p-168L, ALL_STD_EXCEPT & ~FE_INEXACT, 0); +#elif LDBL_MANT_DIG == 53 + testrnd(fmal, 0x1.bbffeea6fc7d6p-30L, 0x1.1d164c6cbf078p-74L, + -0x1.ee72993aff948p-104L, -0x1.71f72ac7d9d8p-159L, + -0x1.71f72ac7d9d8p-159L, -0x1.71f72ac7d9d8p-159L, + -0x1.71f72ac7d9d8p-159L, ALL_STD_EXCEPT & ~FE_INEXACT, 0); +#endif +} + +static void +test_double_rounding(void) +{ + + /* + * a = 0x1.8000000000001p0 + * b = 0x1.8000000000001p0 + * c = -0x0.0000000000000000000000000080...1p+1 + * a * b = 0x1.2000000000001800000000000080p+1 + * + * The correct behavior is to round DOWN to 0x1.2000000000001p+1 in + * round-to-nearest mode. An implementation that computes a*b+c in + * double+double precision, however, will get 0x1.20000000000018p+1, + * and then round UP. + */ + fesetround(FE_TONEAREST); + test(fma, 0x1.8000000000001p0, 0x1.8000000000001p0, + -0x1.0000000000001p-104, 0x1.2000000000001p+1, + ALL_STD_EXCEPT, FE_INEXACT); + fesetround(FE_DOWNWARD); + test(fma, 0x1.8000000000001p0, 0x1.8000000000001p0, + -0x1.0000000000001p-104, 0x1.2000000000001p+1, + ALL_STD_EXCEPT, FE_INEXACT); + fesetround(FE_UPWARD); + test(fma, 0x1.8000000000001p0, 0x1.8000000000001p0, + -0x1.0000000000001p-104, 0x1.2000000000002p+1, + ALL_STD_EXCEPT, FE_INEXACT); + + fesetround(FE_TONEAREST); + test(fmaf, 0x1.800002p+0, 0x1.800002p+0, -0x1.000002p-46, 0x1.200002p+1, + ALL_STD_EXCEPT, FE_INEXACT); + fesetround(FE_DOWNWARD); + test(fmaf, 0x1.800002p+0, 0x1.800002p+0, -0x1.000002p-46, 0x1.200002p+1, + ALL_STD_EXCEPT, FE_INEXACT); + fesetround(FE_UPWARD); + test(fmaf, 0x1.800002p+0, 0x1.800002p+0, -0x1.000002p-46, 0x1.200004p+1, + ALL_STD_EXCEPT, FE_INEXACT); + + fesetround(FE_TONEAREST); +#if LDBL_MANT_DIG == 64 + test(fmal, 0x1.4p+0L, 0x1.0000000000000004p+0L, 0x1p-128L, + 0x1.4000000000000006p+0L, ALL_STD_EXCEPT, FE_INEXACT); +#elif LDBL_MANT_DIG == 113 + test(fmal, 0x1.8000000000000000000000000001p+0L, + 0x1.8000000000000000000000000001p+0L, + -0x1.0000000000000000000000000001p-224L, + 0x1.2000000000000000000000000001p+1L, ALL_STD_EXCEPT, FE_INEXACT); +#endif + +} + +int +main(int argc, char *argv[]) +{ + int rmodes[] = { FE_TONEAREST, FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO }; + int i, j; + +#if defined(__i386__) + printf("1..0 # SKIP all testcases fail on i386\n"); + exit(0); +#endif + + j = 1; + + printf("1..19\n"); + + for (i = 0; i < nitems(rmodes); i++, j++) { + printf("rmode = %d\n", rmodes[i]); + fesetround(rmodes[i]); + test_zeroes(); + printf("ok %d - fma zeroes\n", j); + } + + for (i = 0; i < nitems(rmodes); i++, j++) { +#if defined(__amd64__) + printf("ok %d # SKIP testcase fails assertion on " + "amd64\n", j); + continue; +#endif + printf("rmode = %d\n", rmodes[i]); + fesetround(rmodes[i]); + test_infinities(); + printf("ok %d - fma infinities\n", j); + } + + fesetround(FE_TONEAREST); + test_nans(); + printf("ok 9 - fma NaNs\n"); + + for (i = 0; i < nitems(rmodes); i++, j++) { + printf("rmode = %d\n", rmodes[i]); + fesetround(rmodes[i]); + test_small_z(); + printf("ok %d - fma small z\n", j); + } + + for (i = 0; i < nitems(rmodes); i++, j++) { + printf("rmode = %d\n", rmodes[i]); + fesetround(rmodes[i]); + test_big_z(); + printf("ok %d - fma big z\n", j); + } + + fesetround(FE_TONEAREST); + test_accuracy(); + printf("ok %d - fma accuracy\n", j); + j++; + + test_double_rounding(); + printf("ok %d - fma double rounding\n", j); + j++; + + /* + * TODO: + * - Tests for subnormals + * - Cancellation tests (e.g., z = (double)x*y, but x*y is inexact) + */ + + return (0); +} diff --git a/lib/msun/tests/invtrig_test.c b/lib/msun/tests/invtrig_test.c new file mode 100644 index 0000000..01b0379 --- /dev/null +++ b/lib/msun/tests/invtrig_test.c @@ -0,0 +1,479 @@ +/*- + * Copyright (c) 2008 David Schultz + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * Tests for corner cases in the inverse trigonometric functions. Some + * accuracy tests are included as well, but these are very basic + * sanity checks, not intended to be comprehensive. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include +#include +#include + +#include "test-utils.h" + +#pragma STDC FENV_ACCESS ON + +/* + * Test that a function returns the correct value and sets the + * exception flags correctly. A tolerance specifying the maximum + * relative error allowed may be specified. For the 'testall' + * functions, the tolerance is specified in ulps. + * + * These are macros instead of functions so that assert provides more + * meaningful error messages. + */ +#define test_tol(func, x, result, tol, excepts) do { \ + volatile long double _in = (x), _out = (result); \ + assert(feclearexcept(FE_ALL_EXCEPT) == 0); \ + assert(fpequal_tol(func(_in), _out, (tol), CS_BOTH)); \ + assert(((void)func, fetestexcept(ALL_STD_EXCEPT) == (excepts))); \ +} while (0) +#define test(func, x, result, excepts) \ + test_tol(func, (x), (result), 0, (excepts)) + +#define _testall_tol(prefix, x, result, tol, excepts) do { \ + test_tol(prefix, (double)(x), (double)(result), \ + (tol) * ldexp(1.0, 1 - DBL_MANT_DIG), (excepts)); \ + test_tol(prefix##f, (float)(x), (float)(result), \ + (tol) * ldexpf(1.0, 1 - FLT_MANT_DIG), (excepts)); \ +} while (0) + +#if LDBL_PREC == 53 +#define testall_tol _testall_tol +#else +#define testall_tol(prefix, x, result, tol, excepts) do { \ + _testall_tol(prefix, x, result, tol, excepts); \ + test_tol(prefix##l, (x), (result), \ + (tol) * ldexpl(1.0, 1 - LDBL_MANT_DIG), (excepts)); \ +} while (0) +#endif + +#define testall(prefix, x, result, excepts) \ + testall_tol(prefix, (x), (result), 0, (excepts)) + +#define test2_tol(func, y, x, result, tol, excepts) do { \ + volatile long double _iny = (y), _inx = (x), _out = (result); \ + assert(feclearexcept(FE_ALL_EXCEPT) == 0); \ + assert(fpequal_tol(func(_iny, _inx), _out, (tol), CS_BOTH)); \ + assert(((void)func, fetestexcept(ALL_STD_EXCEPT) == (excepts))); \ +} while (0) +#define test2(func, y, x, result, excepts) \ + test2_tol(func, (y), (x), (result), 0, (excepts)) + +#define _testall2_tol(prefix, y, x, result, tol, excepts) do { \ + test2_tol(prefix, (double)(y), (double)(x), (double)(result), \ + (tol) * ldexp(1.0, 1 - DBL_MANT_DIG), (excepts)); \ + test2_tol(prefix##f, (float)(y), (float)(x), (float)(result), \ + (tol) * ldexpf(1.0, 1 - FLT_MANT_DIG), (excepts)); \ +} while (0) + +#if LDBL_PREC == 53 +#define testall2_tol _testall2_tol +#else +#define testall2_tol(prefix, y, x, result, tol, excepts) do { \ + _testall2_tol(prefix, y, x, result, tol, excepts); \ + test2_tol(prefix##l, (y), (x), (result), \ + (tol) * ldexpl(1.0, 1 - LDBL_MANT_DIG), (excepts)); \ +} while (0) +#endif + +#define testall2(prefix, y, x, result, excepts) \ + testall2_tol(prefix, (y), (x), (result), 0, (excepts)) + +long double +pi = 3.14159265358979323846264338327950280e+00L, +pio3 = 1.04719755119659774615421446109316766e+00L, +c3pi = 9.42477796076937971538793014983850839e+00L, +c5pi = 1.57079632679489661923132169163975140e+01L, +c7pi = 2.19911485751285526692385036829565196e+01L, +c5pio3 = 5.23598775598298873077107230546583851e+00L, +sqrt2m1 = 4.14213562373095048801688724209698081e-01L; + + +/* + * Test special case inputs in asin(), acos() and atan(): signed + * zeroes, infinities, and NaNs. + */ +static void +test_special(void) +{ + + testall(asin, 0.0, 0.0, 0); + testall(acos, 0.0, pi / 2, FE_INEXACT); + testall(atan, 0.0, 0.0, 0); + testall(asin, -0.0, -0.0, 0); + testall(acos, -0.0, pi / 2, FE_INEXACT); + testall(atan, -0.0, -0.0, 0); + + testall(asin, INFINITY, NAN, FE_INVALID); + testall(acos, INFINITY, NAN, FE_INVALID); + testall(atan, INFINITY, pi / 2, FE_INEXACT); + testall(asin, -INFINITY, NAN, FE_INVALID); + testall(acos, -INFINITY, NAN, FE_INVALID); + testall(atan, -INFINITY, -pi / 2, FE_INEXACT); + + testall(asin, NAN, NAN, 0); + testall(acos, NAN, NAN, 0); + testall(atan, NAN, NAN, 0); +} + +/* + * Test special case inputs in atan2(), where the exact value of y/x is + * zero or non-finite. + */ +static void +test_special_atan2(void) +{ + long double z; + int e; + + testall2(atan2, 0.0, -0.0, pi, FE_INEXACT); + testall2(atan2, -0.0, -0.0, -pi, FE_INEXACT); + testall2(atan2, 0.0, 0.0, 0.0, 0); + testall2(atan2, -0.0, 0.0, -0.0, 0); + + testall2(atan2, INFINITY, -INFINITY, c3pi / 4, FE_INEXACT); + testall2(atan2, -INFINITY, -INFINITY, -c3pi / 4, FE_INEXACT); + testall2(atan2, INFINITY, INFINITY, pi / 4, FE_INEXACT); + testall2(atan2, -INFINITY, INFINITY, -pi / 4, FE_INEXACT); + + /* Tests with one input in the range (0, Inf]. */ + z = 1.23456789L; + for (e = FLT_MIN_EXP - FLT_MANT_DIG; e <= FLT_MAX_EXP; e++) { + test2(atan2f, 0.0, ldexpf(z, e), 0.0, 0); + test2(atan2f, -0.0, ldexpf(z, e), -0.0, 0); + test2(atan2f, 0.0, ldexpf(-z, e), (float)pi, FE_INEXACT); + test2(atan2f, -0.0, ldexpf(-z, e), (float)-pi, FE_INEXACT); + test2(atan2f, ldexpf(z, e), 0.0, (float)pi / 2, FE_INEXACT); + test2(atan2f, ldexpf(z, e), -0.0, (float)pi / 2, FE_INEXACT); + test2(atan2f, ldexpf(-z, e), 0.0, (float)-pi / 2, FE_INEXACT); + test2(atan2f, ldexpf(-z, e), -0.0, (float)-pi / 2, FE_INEXACT); + } + for (e = DBL_MIN_EXP - DBL_MANT_DIG; e <= DBL_MAX_EXP; e++) { + test2(atan2, 0.0, ldexp(z, e), 0.0, 0); + test2(atan2, -0.0, ldexp(z, e), -0.0, 0); + test2(atan2, 0.0, ldexp(-z, e), (double)pi, FE_INEXACT); + test2(atan2, -0.0, ldexp(-z, e), (double)-pi, FE_INEXACT); + test2(atan2, ldexp(z, e), 0.0, (double)pi / 2, FE_INEXACT); + test2(atan2, ldexp(z, e), -0.0, (double)pi / 2, FE_INEXACT); + test2(atan2, ldexp(-z, e), 0.0, (double)-pi / 2, FE_INEXACT); + test2(atan2, ldexp(-z, e), -0.0, (double)-pi / 2, FE_INEXACT); + } + for (e = LDBL_MIN_EXP - LDBL_MANT_DIG; e <= LDBL_MAX_EXP; e++) { + test2(atan2l, 0.0, ldexpl(z, e), 0.0, 0); + test2(atan2l, -0.0, ldexpl(z, e), -0.0, 0); + test2(atan2l, 0.0, ldexpl(-z, e), pi, FE_INEXACT); + test2(atan2l, -0.0, ldexpl(-z, e), -pi, FE_INEXACT); + test2(atan2l, ldexpl(z, e), 0.0, pi / 2, FE_INEXACT); + test2(atan2l, ldexpl(z, e), -0.0, pi / 2, FE_INEXACT); + test2(atan2l, ldexpl(-z, e), 0.0, -pi / 2, FE_INEXACT); + test2(atan2l, ldexpl(-z, e), -0.0, -pi / 2, FE_INEXACT); + } + + /* Tests with one input in the range (0, Inf). */ + for (e = FLT_MIN_EXP - FLT_MANT_DIG; e <= FLT_MAX_EXP - 1; e++) { + test2(atan2f, ldexpf(z, e), INFINITY, 0.0, 0); + test2(atan2f, ldexpf(-z,e), INFINITY, -0.0, 0); + test2(atan2f, ldexpf(z, e), -INFINITY, (float)pi, FE_INEXACT); + test2(atan2f, ldexpf(-z,e), -INFINITY, (float)-pi, FE_INEXACT); + test2(atan2f, INFINITY, ldexpf(z,e), (float)pi/2, FE_INEXACT); + test2(atan2f, INFINITY, ldexpf(-z,e), (float)pi/2, FE_INEXACT); + test2(atan2f, -INFINITY, ldexpf(z,e), (float)-pi/2,FE_INEXACT); + test2(atan2f, -INFINITY, ldexpf(-z,e),(float)-pi/2,FE_INEXACT); + } + for (e = DBL_MIN_EXP - DBL_MANT_DIG; e <= DBL_MAX_EXP - 1; e++) { + test2(atan2, ldexp(z, e), INFINITY, 0.0, 0); + test2(atan2, ldexp(-z,e), INFINITY, -0.0, 0); + test2(atan2, ldexp(z, e), -INFINITY, (double)pi, FE_INEXACT); + test2(atan2, ldexp(-z,e), -INFINITY, (double)-pi, FE_INEXACT); + test2(atan2, INFINITY, ldexp(z,e), (double)pi/2, FE_INEXACT); + test2(atan2, INFINITY, ldexp(-z,e), (double)pi/2, FE_INEXACT); + test2(atan2, -INFINITY, ldexp(z,e), (double)-pi/2,FE_INEXACT); + test2(atan2, -INFINITY, ldexp(-z,e),(double)-pi/2,FE_INEXACT); + } + for (e = LDBL_MIN_EXP - LDBL_MANT_DIG; e <= LDBL_MAX_EXP - 1; e++) { + test2(atan2l, ldexpl(z, e), INFINITY, 0.0, 0); + test2(atan2l, ldexpl(-z,e), INFINITY, -0.0, 0); + test2(atan2l, ldexpl(z, e), -INFINITY, pi, FE_INEXACT); + test2(atan2l, ldexpl(-z,e), -INFINITY, -pi, FE_INEXACT); + test2(atan2l, INFINITY, ldexpl(z, e), pi / 2, FE_INEXACT); + test2(atan2l, INFINITY, ldexpl(-z, e), pi / 2, FE_INEXACT); + test2(atan2l, -INFINITY, ldexpl(z, e), -pi / 2, FE_INEXACT); + test2(atan2l, -INFINITY, ldexpl(-z, e), -pi / 2, FE_INEXACT); + } +} + +/* + * Test various inputs to asin(), acos() and atan() and verify that the + * results are accurate to within 1 ulp. + */ +static void +test_accuracy(void) +{ + + /* We expect correctly rounded results for these basic cases. */ + testall(asin, 1.0, pi / 2, FE_INEXACT); + testall(acos, 1.0, 0, 0); + testall(atan, 1.0, pi / 4, FE_INEXACT); + testall(asin, -1.0, -pi / 2, FE_INEXACT); + testall(acos, -1.0, pi, FE_INEXACT); + testall(atan, -1.0, -pi / 4, FE_INEXACT); + + /* + * Here we expect answers to be within 1 ulp, although inexactness + * in the input, combined with double rounding, could cause larger + * errors. + */ + + testall_tol(asin, sqrtl(2) / 2, pi / 4, 1, FE_INEXACT); + testall_tol(acos, sqrtl(2) / 2, pi / 4, 1, FE_INEXACT); + testall_tol(asin, -sqrtl(2) / 2, -pi / 4, 1, FE_INEXACT); + testall_tol(acos, -sqrtl(2) / 2, c3pi / 4, 1, FE_INEXACT); + + testall_tol(asin, sqrtl(3) / 2, pio3, 1, FE_INEXACT); + testall_tol(acos, sqrtl(3) / 2, pio3 / 2, 1, FE_INEXACT); + testall_tol(atan, sqrtl(3), pio3, 1, FE_INEXACT); + testall_tol(asin, -sqrtl(3) / 2, -pio3, 1, FE_INEXACT); + testall_tol(acos, -sqrtl(3) / 2, c5pio3 / 2, 1, FE_INEXACT); + testall_tol(atan, -sqrtl(3), -pio3, 1, FE_INEXACT); + + testall_tol(atan, sqrt2m1, pi / 8, 1, FE_INEXACT); + testall_tol(atan, -sqrt2m1, -pi / 8, 1, FE_INEXACT); +} + +/* + * Test inputs to atan2() where x is a power of 2. These are easy cases + * because y/x is exact. + */ +static void +test_p2x_atan2(void) +{ + + testall2(atan2, 1.0, 1.0, pi / 4, FE_INEXACT); + testall2(atan2, 1.0, -1.0, c3pi / 4, FE_INEXACT); + testall2(atan2, -1.0, 1.0, -pi / 4, FE_INEXACT); + testall2(atan2, -1.0, -1.0, -c3pi / 4, FE_INEXACT); + + testall2_tol(atan2, sqrt2m1 * 2, 2.0, pi / 8, 1, FE_INEXACT); + testall2_tol(atan2, sqrt2m1 * 2, -2.0, c7pi / 8, 1, FE_INEXACT); + testall2_tol(atan2, -sqrt2m1 * 2, 2.0, -pi / 8, 1, FE_INEXACT); + testall2_tol(atan2, -sqrt2m1 * 2, -2.0, -c7pi / 8, 1, FE_INEXACT); + + testall2_tol(atan2, sqrtl(3) * 0.5, 0.5, pio3, 1, FE_INEXACT); + testall2_tol(atan2, sqrtl(3) * 0.5, -0.5, pio3 * 2, 1, FE_INEXACT); + testall2_tol(atan2, -sqrtl(3) * 0.5, 0.5, -pio3, 1, FE_INEXACT); + testall2_tol(atan2, -sqrtl(3) * 0.5, -0.5, -pio3 * 2, 1, FE_INEXACT); +} + +/* + * Test inputs very close to 0. + */ +static void +test_tiny(void) +{ + float tiny = 0x1.23456p-120f; + + testall(asin, tiny, tiny, FE_INEXACT); + testall(acos, tiny, pi / 2, FE_INEXACT); + testall(atan, tiny, tiny, FE_INEXACT); + + testall(asin, -tiny, -tiny, FE_INEXACT); + testall(acos, -tiny, pi / 2, FE_INEXACT); + testall(atan, -tiny, -tiny, FE_INEXACT); + + /* Test inputs to atan2() that would cause y/x to underflow. */ + test2(atan2f, 0x1.0p-100, 0x1.0p100, 0.0, FE_INEXACT | FE_UNDERFLOW); + test2(atan2, 0x1.0p-1000, 0x1.0p1000, 0.0, FE_INEXACT | FE_UNDERFLOW); + test2(atan2l, ldexpl(1.0, 100 - LDBL_MAX_EXP), + ldexpl(1.0, LDBL_MAX_EXP - 100), 0.0, FE_INEXACT | FE_UNDERFLOW); + test2(atan2f, -0x1.0p-100, 0x1.0p100, -0.0, FE_INEXACT | FE_UNDERFLOW); + test2(atan2, -0x1.0p-1000, 0x1.0p1000, -0.0, FE_INEXACT | FE_UNDERFLOW); + test2(atan2l, -ldexpl(1.0, 100 - LDBL_MAX_EXP), + ldexpl(1.0, LDBL_MAX_EXP - 100), -0.0, FE_INEXACT | FE_UNDERFLOW); + test2(atan2f, 0x1.0p-100, -0x1.0p100, (float)pi, FE_INEXACT); + test2(atan2, 0x1.0p-1000, -0x1.0p1000, (double)pi, FE_INEXACT); + test2(atan2l, ldexpl(1.0, 100 - LDBL_MAX_EXP), + -ldexpl(1.0, LDBL_MAX_EXP - 100), pi, FE_INEXACT); + test2(atan2f, -0x1.0p-100, -0x1.0p100, (float)-pi, FE_INEXACT); + test2(atan2, -0x1.0p-1000, -0x1.0p1000, (double)-pi, FE_INEXACT); + test2(atan2l, -ldexpl(1.0, 100 - LDBL_MAX_EXP), + -ldexpl(1.0, LDBL_MAX_EXP - 100), -pi, FE_INEXACT); +} + +/* + * Test very large inputs to atan(). + */ +static void +test_atan_huge(void) +{ + float huge = 0x1.23456p120; + + testall(atan, huge, pi / 2, FE_INEXACT); + testall(atan, -huge, -pi / 2, FE_INEXACT); + + /* Test inputs to atan2() that would cause y/x to overflow. */ + test2(atan2f, 0x1.0p100, 0x1.0p-100, (float)pi / 2, FE_INEXACT); + test2(atan2, 0x1.0p1000, 0x1.0p-1000, (double)pi / 2, FE_INEXACT); + test2(atan2l, ldexpl(1.0, LDBL_MAX_EXP - 100), + ldexpl(1.0, 100 - LDBL_MAX_EXP), pi / 2, FE_INEXACT); + test2(atan2f, -0x1.0p100, 0x1.0p-100, (float)-pi / 2, FE_INEXACT); + test2(atan2, -0x1.0p1000, 0x1.0p-1000, (double)-pi / 2, FE_INEXACT); + test2(atan2l, -ldexpl(1.0, LDBL_MAX_EXP - 100), + ldexpl(1.0, 100 - LDBL_MAX_EXP), -pi / 2, FE_INEXACT); + + test2(atan2f, 0x1.0p100, -0x1.0p-100, (float)pi / 2, FE_INEXACT); + test2(atan2, 0x1.0p1000, -0x1.0p-1000, (double)pi / 2, FE_INEXACT); + test2(atan2l, ldexpl(1.0, LDBL_MAX_EXP - 100), + -ldexpl(1.0, 100 - LDBL_MAX_EXP), pi / 2, FE_INEXACT); + test2(atan2f, -0x1.0p100, -0x1.0p-100, (float)-pi / 2, FE_INEXACT); + test2(atan2, -0x1.0p1000, -0x1.0p-1000, (double)-pi / 2, FE_INEXACT); + test2(atan2l, -ldexpl(1.0, LDBL_MAX_EXP - 100), + -ldexpl(1.0, 100 - LDBL_MAX_EXP), -pi / 2, FE_INEXACT); +} + +/* + * Test that sin(asin(x)) == x, and similarly for acos() and atan(). + * You need to have a working sinl(), cosl(), and tanl() for these + * tests to pass. + */ +static long double +sinasinf(float x) +{ + + return (sinl(asinf(x))); +} + +static long double +sinasin(double x) +{ + + return (sinl(asin(x))); +} + +static long double +sinasinl(long double x) +{ + + return (sinl(asinl(x))); +} + +static long double +cosacosf(float x) +{ + + return (cosl(acosf(x))); +} + +static long double +cosacos(double x) +{ + + return (cosl(acos(x))); +} + +static long double +cosacosl(long double x) +{ + + return (cosl(acosl(x))); +} + +static long double +tanatanf(float x) +{ + + return (tanl(atanf(x))); +} + +static long double +tanatan(double x) +{ + + return (tanl(atan(x))); +} + +static long double +tanatanl(long double x) +{ + + return (tanl(atanl(x))); +} + +static void +test_inverse(void) +{ + float i; + + for (i = -1; i <= 1; i += 0x1.0p-12f) { + testall_tol(sinasin, i, i, 2, i == 0 ? 0 : FE_INEXACT); + /* The relative error for cosacos is very large near x=0. */ + if (fabsf(i) > 0x1.0p-4f) + testall_tol(cosacos, i, i, 16, i == 1 ? 0 : FE_INEXACT); + testall_tol(tanatan, i, i, 2, i == 0 ? 0 : FE_INEXACT); + } +} + +int +main(int argc, char *argv[]) +{ + +#if defined(__i386__) + printf("1..0 # SKIP fails all assertions on i386\n"); + return (0); +#endif + + printf("1..7\n"); + + test_special(); + printf("ok 1 - special\n"); + + test_special_atan2(); + printf("ok 2 - atan2 special\n"); + + test_accuracy(); + printf("ok 3 - accuracy\n"); + + test_p2x_atan2(); + printf("ok 4 - atan2 p2x\n"); + + test_tiny(); + printf("ok 5 - tiny inputs\n"); + + test_atan_huge(); + printf("ok 6 - atan huge inputs\n"); + + test_inverse(); + printf("ok 7 - inverse\n"); + + return (0); +} diff --git a/lib/msun/tests/lround_test.c b/lib/msun/tests/lround_test.c new file mode 100644 index 0000000..2a37367 --- /dev/null +++ b/lib/msun/tests/lround_test.c @@ -0,0 +1,115 @@ +/*- + * Copyright (c) 2005 David Schultz + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * Test for lround(), lroundf(), llround(), and llroundf(). + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include +#include +#include + +/* + * XXX The volatile here is to avoid gcc's bogus constant folding and work + * around the lack of support for the FENV_ACCESS pragma. + */ +#define test(func, x, result, excepts) do { \ + volatile double _d = x; \ + assert(feclearexcept(FE_ALL_EXCEPT) == 0); \ + assert((func)(_d) == (result) || fetestexcept(FE_INVALID)); \ + assert(fetestexcept(FE_ALL_EXCEPT) == (excepts)); \ +} while (0) + +#define testall(x, result, excepts) do { \ + test(lround, x, result, excepts); \ + test(lroundf, x, result, excepts); \ + test(llround, x, result, excepts); \ + test(llroundf, x, result, excepts); \ +} while (0) + +#define IGNORE 0 + +#pragma STDC FENV_ACCESS ON + +int +main(int argc, char *argv[]) +{ + + printf("1..1\n"); + + testall(0.0, 0, 0); + testall(0.25, 0, FE_INEXACT); + testall(0.5, 1, FE_INEXACT); + testall(-0.5, -1, FE_INEXACT); + testall(1.0, 1, 0); + testall(0x12345000p0, 0x12345000, 0); + testall(0x1234.fp0, 0x1235, FE_INEXACT); + testall(INFINITY, IGNORE, FE_INVALID); + testall(NAN, IGNORE, FE_INVALID); + +#if (LONG_MAX == 0x7fffffffl) + test(lround, 0x7fffffff.8p0, IGNORE, FE_INVALID); + test(lround, -0x80000000.8p0, IGNORE, FE_INVALID); + test(lround, 0x80000000.0p0, IGNORE, FE_INVALID); + test(lround, 0x7fffffff.4p0, 0x7fffffffl, FE_INEXACT); + test(lround, -0x80000000.4p0, -0x80000000l, FE_INEXACT); + test(lroundf, 0x80000000.0p0f, IGNORE, FE_INVALID); + test(lroundf, 0x7fffff80.0p0f, 0x7fffff80l, 0); +#elif (LONG_MAX == 0x7fffffffffffffffll) + test(lround, 0x8000000000000000.0p0, IGNORE, FE_INVALID); + test(lroundf, 0x8000000000000000.0p0f, IGNORE, FE_INVALID); + test(lround, 0x7ffffffffffffc00.0p0, 0x7ffffffffffffc00l, 0); + test(lroundf, 0x7fffff8000000000.0p0f, 0x7fffff8000000000l, 0); + test(lround, -0x8000000000000800.0p0, IGNORE, FE_INVALID); + test(lroundf, -0x8000010000000000.0p0f, IGNORE, FE_INVALID); + test(lround, -0x8000000000000000.0p0, -0x8000000000000000l, 0); + test(lroundf, -0x8000000000000000.0p0f, -0x8000000000000000l, 0); +#else +#error "Unsupported long size" +#endif + +#if (LLONG_MAX == 0x7fffffffffffffffLL) + test(llround, 0x8000000000000000.0p0, IGNORE, FE_INVALID); + test(llroundf, 0x8000000000000000.0p0f, IGNORE, FE_INVALID); + test(llround, 0x7ffffffffffffc00.0p0, 0x7ffffffffffffc00ll, 0); + test(llroundf, 0x7fffff8000000000.0p0f, 0x7fffff8000000000ll, 0); + test(llround, -0x8000000000000800.0p0, IGNORE, FE_INVALID); + test(llroundf, -0x8000010000000000.0p0f, IGNORE, FE_INVALID); + test(llround, -0x8000000000000000.0p0, -0x8000000000000000ll, 0); + test(llroundf, -0x8000000000000000.0p0f, -0x8000000000000000ll, 0); +#else +#error "Unsupported long long size" +#endif + + printf("ok 1 - lround\n"); + + return (0); +} diff --git a/lib/msun/tests/lround_test.t b/lib/msun/tests/lround_test.t new file mode 100644 index 0000000..8bdfd03 --- /dev/null +++ b/lib/msun/tests/lround_test.t @@ -0,0 +1,10 @@ +#!/bin/sh +# $FreeBSD$ + +cd `dirname $0` + +executable=`basename $0 .t` + +make $executable 2>&1 > /dev/null + +exec ./$executable diff --git a/lib/msun/tests/test-utils.h b/lib/msun/tests/test-utils.h new file mode 100644 index 0000000..bf0d6de --- /dev/null +++ b/lib/msun/tests/test-utils.h @@ -0,0 +1,174 @@ +/*- + * Copyright (c) 2005-2013 David Schultz + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +#ifndef _TEST_UTILS_H_ +#define _TEST_UTILS_H_ + +#include +#include + +/* + * Implementations are permitted to define additional exception flags + * not specified in the standard, so it is not necessarily true that + * FE_ALL_EXCEPT == ALL_STD_EXCEPT. + */ +#define ALL_STD_EXCEPT (FE_DIVBYZERO | FE_INEXACT | FE_INVALID | \ + FE_OVERFLOW | FE_UNDERFLOW) +#define OPT_INVALID (ALL_STD_EXCEPT & ~FE_INVALID) +#define OPT_INEXACT (ALL_STD_EXCEPT & ~FE_INEXACT) +#define FLT_ULP() ldexpl(1.0, 1 - FLT_MANT_DIG) +#define DBL_ULP() ldexpl(1.0, 1 - DBL_MANT_DIG) +#define LDBL_ULP() ldexpl(1.0, 1 - LDBL_MANT_DIG) + +/* + * Flags that control the behavior of various fpequal* functions. + * XXX This is messy due to merging various notions of "close enough" + * that are best suited for different functions. + * + * CS_REAL + * CS_IMAG + * CS_BOTH + * (cfpequal_cs, fpequal_tol, cfpequal_tol) Whether to check the sign of + * the real part of the result, the imaginary part, or both. + * + * FPE_ABS_ZERO + * (fpequal_tol, cfpequal_tol) If set, treats the tolerance as an absolute + * tolerance when the expected value is 0. This is useful when there is + * round-off error in the input, e.g., cos(Pi/2) ~= 0. + */ +#define CS_REAL 0x01 +#define CS_IMAG 0x02 +#define CS_BOTH (CS_REAL | CS_IMAG) +#define FPE_ABS_ZERO 0x04 + +#ifdef DEBUG +#define debug(...) printf(__VA_ARGS__) +#else +#define debug(...) (void)0 +#endif + +/* + * XXX The ancient version of gcc in the base system doesn't support CMPLXL, + * but we can fake it most of the time. + */ +#ifndef CMPLXL +static inline long double complex +CMPLXL(long double x, long double y) +{ + long double complex z; + + __real__ z = x; + __imag__ z = y; + return (z); +} +#endif + +/* + * Compare d1 and d2 using special rules: NaN == NaN and +0 != -0. + * Fail an assertion if they differ. + */ +static int +fpequal(long double d1, long double d2) +{ + + if (d1 != d2) + return (isnan(d1) && isnan(d2)); + return (copysignl(1.0, d1) == copysignl(1.0, d2)); +} + +/* + * Determine whether x and y are equal, with two special rules: + * +0.0 != -0.0 + * NaN == NaN + * If checksign is 0, we compare the absolute values instead. + */ +static int +fpequal_cs(long double x, long double y, int checksign) +{ + if (isnan(x) && isnan(y)) + return (1); + if (checksign) + return (x == y && !signbit(x) == !signbit(y)); + else + return (fabsl(x) == fabsl(y)); +} + +static int +fpequal_tol(long double x, long double y, long double tol, unsigned int flags) +{ + fenv_t env; + int ret; + + if (isnan(x) && isnan(y)) + return (1); + if (!signbit(x) != !signbit(y) && (flags & CS_BOTH)) + return (0); + if (x == y) + return (1); + if (tol == 0) + return (0); + + /* Hard case: need to check the tolerance. */ + feholdexcept(&env); + /* + * For our purposes here, if y=0, we interpret tol as an absolute + * tolerance. This is to account for roundoff in the input, e.g., + * cos(Pi/2) ~= 0. + */ + if ((flags & FPE_ABS_ZERO) && y == 0.0) + ret = fabsl(x - y) <= fabsl(tol); + else + ret = fabsl(x - y) <= fabsl(y * tol); + fesetenv(&env); + return (ret); +} + +static int +cfpequal(long double complex d1, long double complex d2) +{ + + return (fpequal(creall(d1), creall(d2)) && + fpequal(cimagl(d1), cimagl(d2))); +} + +static int +cfpequal_cs(long double complex x, long double complex y, int checksign) +{ + return (fpequal_cs(creal(x), creal(y), checksign) + && fpequal_cs(cimag(x), cimag(y), checksign)); +} + +static int +cfpequal_tol(long double complex x, long double complex y, long double tol, + unsigned int flags) +{ + return (fpequal_tol(creal(x), creal(y), tol, flags) + && fpequal_tol(cimag(x), cimag(y), tol, flags)); +} + +#endif /* _TEST_UTILS_H_ */ -- cgit v1.1