d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove tools/regression/lib/msun (follow up to r292497)

Browse Source 
Sponsored by: EMC / Isilon Storage Division
This commit is contained in:
ngie 2016-01-18 03:56:49 +00:00
parent 2af193e575
commit f4e3dd9ef2
16 changed files with 0 additions and 3059 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
tools/regression/lib/msun/Makefile
View File

@ -1,14 +0,0 @@
# $FreeBSD$
TESTS= test-ctrig \
test-exponential test-fma \
test-lround test-nearbyint test-next test-rem test-trig
CFLAGS+= -O0 -lm -Wno-unknown-pragmas
.PHONY: tests
tests: ${TESTS}
for p in ${TESTS}; do ${.OBJDIR}/$$p; done
.PHONY: clean
clean:
-rm -f ${TESTS}

322
tools/regression/lib/msun/test-cexp.c
View File

@ -1,322 +0,0 @@
/*-
* Copyright (c) 2008-2011 David Schultz <das@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* Tests for corner cases in cexp*().
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <assert.h>
#include <complex.h>
#include <fenv.h>
#include <float.h>
#include <math.h>
#include <stdio.h>
#include "test-utils.h"
#define N(i) (sizeof(i) / sizeof((i)[0]))
#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. In some cases,
* whether cexp() raises an invalid exception is unspecified.
*
* 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, z, result, exceptmask, excepts, checksign) do { \
volatile long double complex _d = z; \
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. */
#define test_tol(func, z, result, tol) do { \
volatile long double complex _d = z; \
assert(cfpequal_tol((func)(_d), (result), (tol), \
FPE_ABS_ZERO | CS_BOTH)); \
} while (0)
/* Test all the functions that compute cexp(x). */
#define testall(x, result, exceptmask, excepts, checksign) do { \
test(cexp, x, result, exceptmask, excepts, checksign); \
test(cexpf, x, result, exceptmask, excepts, checksign); \
} while (0)
/*
* Test all the functions that compute cexp(x), within a given tolerance.
* The tolerance is specified in ulps.
*/
#define testall_tol(x, result, tol) do { \
test_tol(cexp, x, result, tol * DBL_ULP()); \
test_tol(cexpf, x, result, tol * FLT_ULP()); \
} while (0)
/* Various finite non-zero numbers to test. */
static const float finites[] =
{ -42.0e20, -1.0, -1.0e-10, -0.0, 0.0, 1.0e-10, 1.0, 42.0e20 };
/* Tests for 0 */
void
test_zero(void)
{
/* cexp(0) = 1, no exceptions raised */
testall(0.0, 1.0, ALL_STD_EXCEPT, 0, 1);
testall(-0.0, 1.0, ALL_STD_EXCEPT, 0, 1);
testall(CMPLXL(0.0, -0.0), CMPLXL(1.0, -0.0), ALL_STD_EXCEPT, 0, 1);
testall(CMPLXL(-0.0, -0.0), CMPLXL(1.0, -0.0), ALL_STD_EXCEPT, 0, 1);
}
/*
* Tests for NaN. The signs of the results are indeterminate unless the
* imaginary part is 0.
*/
void
test_nan()
{
int i;
/* cexp(x + NaNi) = NaN + NaNi and optionally raises invalid */
/* cexp(NaN + yi) = NaN + NaNi and optionally raises invalid (|y|>0) */
for (i = 0; i < N(finites); i++) {
printf("# Run %d..\n", i);
testall(CMPLXL(finites[i], NAN), CMPLXL(NAN, NAN),
ALL_STD_EXCEPT & ~FE_INVALID, 0, 0);
if (finites[i] == 0.0)
continue;
/* XXX FE_INEXACT shouldn't be raised here */
testall(CMPLXL(NAN, finites[i]), CMPLXL(NAN, NAN),
ALL_STD_EXCEPT & ~(FE_INVALID | FE_INEXACT), 0, 0);
}
/* cexp(NaN +- 0i) = NaN +- 0i */
testall(CMPLXL(NAN, 0.0), CMPLXL(NAN, 0.0), ALL_STD_EXCEPT, 0, 1);
testall(CMPLXL(NAN, -0.0), CMPLXL(NAN, -0.0), ALL_STD_EXCEPT, 0, 1);
/* cexp(inf + NaN i) = inf + nan i */
testall(CMPLXL(INFINITY, NAN), CMPLXL(INFINITY, NAN),
ALL_STD_EXCEPT, 0, 0);
/* cexp(-inf + NaN i) = 0 */
testall(CMPLXL(-INFINITY, NAN), CMPLXL(0.0, 0.0),
ALL_STD_EXCEPT, 0, 0);
/* cexp(NaN + NaN i) = NaN + NaN i */
testall(CMPLXL(NAN, NAN), CMPLXL(NAN, NAN),
ALL_STD_EXCEPT, 0, 0);
}
void
test_inf(void)
{
int i;
/* cexp(x + inf i) = NaN + NaNi and raises invalid */
for (i = 0; i < N(finites); i++) {
printf("# Run %d..\n", i);
testall(CMPLXL(finites[i], INFINITY), CMPLXL(NAN, NAN),
ALL_STD_EXCEPT, FE_INVALID, 1);
}
/* cexp(-inf + yi) = 0 * (cos(y) + sin(y)i) */
/* XXX shouldn't raise an inexact exception */
testall(CMPLXL(-INFINITY, M_PI_4), CMPLXL(0.0, 0.0),
ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1);
testall(CMPLXL(-INFINITY, 3 * M_PI_4), CMPLXL(-0.0, 0.0),
ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1);
testall(CMPLXL(-INFINITY, 5 * M_PI_4), CMPLXL(-0.0, -0.0),
ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1);
testall(CMPLXL(-INFINITY, 7 * M_PI_4), CMPLXL(0.0, -0.0),
ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1);
testall(CMPLXL(-INFINITY, 0.0), CMPLXL(0.0, 0.0),
ALL_STD_EXCEPT, 0, 1);
testall(CMPLXL(-INFINITY, -0.0), CMPLXL(0.0, -0.0),
ALL_STD_EXCEPT, 0, 1);
/* cexp(inf + yi) = inf * (cos(y) + sin(y)i) (except y=0) */
/* XXX shouldn't raise an inexact exception */
testall(CMPLXL(INFINITY, M_PI_4), CMPLXL(INFINITY, INFINITY),
ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1);
testall(CMPLXL(INFINITY, 3 * M_PI_4), CMPLXL(-INFINITY, INFINITY),
ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1);
testall(CMPLXL(INFINITY, 5 * M_PI_4), CMPLXL(-INFINITY, -INFINITY),
ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1);
testall(CMPLXL(INFINITY, 7 * M_PI_4), CMPLXL(INFINITY, -INFINITY),
ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1);
/* cexp(inf + 0i) = inf + 0i */
testall(CMPLXL(INFINITY, 0.0), CMPLXL(INFINITY, 0.0),
ALL_STD_EXCEPT, 0, 1);
testall(CMPLXL(INFINITY, -0.0), CMPLXL(INFINITY, -0.0),
ALL_STD_EXCEPT, 0, 1);
}
void
test_reals(void)
{
int i;
for (i = 0; i < N(finites); i++) {
/* XXX could check exceptions more meticulously */
printf("# Run %d..\n", i);
test(cexp, CMPLXL(finites[i], 0.0),
CMPLXL(exp(finites[i]), 0.0),
FE_INVALID | FE_DIVBYZERO, 0, 1);
test(cexp, CMPLXL(finites[i], -0.0),
CMPLXL(exp(finites[i]), -0.0),
FE_INVALID | FE_DIVBYZERO, 0, 1);
test(cexpf, CMPLXL(finites[i], 0.0),
CMPLXL(expf(finites[i]), 0.0),
FE_INVALID | FE_DIVBYZERO, 0, 1);
test(cexpf, CMPLXL(finites[i], -0.0),
CMPLXL(expf(finites[i]), -0.0),
FE_INVALID | FE_DIVBYZERO, 0, 1);
}
}
void
test_imaginaries(void)
{
int i;
for (i = 0; i < N(finites); i++) {
printf("# Run %d..\n", i);
test(cexp, CMPLXL(0.0, finites[i]),
CMPLXL(cos(finites[i]), sin(finites[i])),
ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1);
test(cexp, CMPLXL(-0.0, finites[i]),
CMPLXL(cos(finites[i]), sin(finites[i])),
ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1);
test(cexpf, CMPLXL(0.0, finites[i]),
CMPLXL(cosf(finites[i]), sinf(finites[i])),
ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1);
test(cexpf, CMPLXL(-0.0, finites[i]),
CMPLXL(cosf(finites[i]), sinf(finites[i])),
ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1);
}
}
void
test_small(void)
{
static const double tests[] = {
/* csqrt(a + bI) = x + yI */
/* a b x y */
1.0, M_PI_4, M_SQRT2 * 0.5 * M_E, M_SQRT2 * 0.5 * M_E,
-1.0, M_PI_4, M_SQRT2 * 0.5 / M_E, M_SQRT2 * 0.5 / M_E,
2.0, M_PI_2, 0.0, M_E * M_E,
M_LN2, M_PI, -2.0, 0.0,
};
double a, b;
double x, y;
int i;
for (i = 0; i < N(tests); i += 4) {
printf("# Run %d..\n", i);
a = tests[i];
b = tests[i + 1];
x = tests[i + 2];
y = tests[i + 3];
test_tol(cexp, CMPLXL(a, b), CMPLXL(x, y), 3 * DBL_ULP());
/* float doesn't have enough precision to pass these tests */
if (x == 0 || y == 0)
continue;
test_tol(cexpf, CMPLXL(a, b), CMPLXL(x, y), 1 * FLT_ULP());
}
}
/* Test inputs with a real part r that would overflow exp(r). */
void
test_large(void)
{
test_tol(cexp, CMPLXL(709.79, 0x1p-1074),
CMPLXL(INFINITY, 8.94674309915433533273e-16), DBL_ULP());
test_tol(cexp, CMPLXL(1000, 0x1p-1074),
CMPLXL(INFINITY, 9.73344457300016401328e+110), DBL_ULP());
test_tol(cexp, CMPLXL(1400, 0x1p-1074),
CMPLXL(INFINITY, 5.08228858149196559681e+284), DBL_ULP());
test_tol(cexp, CMPLXL(900, 0x1.23456789abcdep-1020),
CMPLXL(INFINITY, 7.42156649354218408074e+83), DBL_ULP());
test_tol(cexp, CMPLXL(1300, 0x1.23456789abcdep-1020),
CMPLXL(INFINITY, 3.87514844965996756704e+257), DBL_ULP());
test_tol(cexpf, CMPLXL(88.73, 0x1p-149),
CMPLXL(INFINITY, 4.80265603e-07), 2 * FLT_ULP());
test_tol(cexpf, CMPLXL(90, 0x1p-149),
CMPLXL(INFINITY, 1.7101492622e-06f), 2 * FLT_ULP());
test_tol(cexpf, CMPLXL(192, 0x1p-149),
CMPLXL(INFINITY, 3.396809344e+38f), 2 * FLT_ULP());
test_tol(cexpf, CMPLXL(120, 0x1.234568p-120),
CMPLXL(INFINITY, 1.1163382522e+16f), 2 * FLT_ULP());
test_tol(cexpf, CMPLXL(170, 0x1.234568p-120),
CMPLXL(INFINITY, 5.7878851079e+37f), 2 * FLT_ULP());
}
int
main(int argc, char *argv[])
{
printf("1..7\n");
test_zero();
printf("ok 1 - cexp zero\n");
test_nan();
printf("ok 2 - cexp nan\n");
test_inf();
printf("ok 3 - cexp inf\n");
#if defined(__i386__)
printf("not ok 4 - cexp reals # TODO: PR # 191676 fails assertion on i386\n");
#else
test_reals();
printf("ok 4 - cexp reals\n");
#endif
test_imaginaries();
printf("ok 5 - cexp imaginaries\n");
test_small();
printf("ok 6 - cexp small\n");
test_large();
printf("ok 7 - cexp large\n");
return (0);
}

139
tools/regression/lib/msun/test-conj.c
View File

@ -1,139 +0,0 @@
/*-
* Copyright (c) 2008 David Schultz <das@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* Tests for conj{,f,l}()
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <assert.h>
#include <complex.h>
#include <fenv.h>
#include <math.h>
#include <stdio.h>
#include "test-utils.h"
#pragma STDC CX_LIMITED_RANGE off
/* Make sure gcc doesn't use builtin versions of these or honor __pure2. */
static float complex (*libconjf)(float complex) = conjf;
static double complex (*libconj)(double complex) = conj;
static long double complex (*libconjl)(long double complex) = conjl;
static float (*libcrealf)(float complex) = crealf;
static double (*libcreal)(double complex) = creal;
static long double (*libcreall)(long double complex) = creall;
static float (*libcimagf)(float complex) = cimagf;
static double (*libcimag)(double complex) = cimag;
static long double (*libcimagl)(long double complex) = cimagl;
static const double tests[] = {
/* a + bI */
0.0, 0.0,
0.0, 1.0,
1.0, 0.0,
-1.0, 0.0,
1.0, -0.0,
0.0, -1.0,
2.0, 4.0,
0.0, INFINITY,
0.0, -INFINITY,
INFINITY, 0.0,
NAN, 1.0,
1.0, NAN,
NAN, NAN,
-INFINITY, INFINITY,
};
int
main(int argc, char *argv[])
{
static const int ntests = sizeof(tests) / sizeof(tests[0]) / 2;
complex float in;
complex long double expected;
int i;
printf("1..%d\n", ntests * 3);
for (i = 0; i < ntests; i++) {
__real__ expected = __real__ in = tests[2 * i];
__imag__ in = tests[2 * i + 1];
__imag__ expected = -cimag(in);
assert(fpequal(libcrealf(in), __real__ in));
assert(fpequal(libcreal(in), __real__ in));
assert(fpequal(libcreall(in), __real__ in));
assert(fpequal(libcimagf(in), __imag__ in));
assert(fpequal(libcimag(in), __imag__ in));
assert(fpequal(libcimagl(in), __imag__ in));
feclearexcept(FE_ALL_EXCEPT);
if (!cfpequal(libconjf(in), expected)) {
printf("not ok %d\t# conjf(%#.2g + %#.2gI): "
"wrong value\n",
3 * i + 1, creal(in), cimag(in));
} else if (fetestexcept(FE_ALL_EXCEPT)) {
printf("not ok %d\t# conjf(%#.2g + %#.2gI): "
"threw an exception\n",
3 * i + 1, creal(in), cimag(in));
} else {
printf("ok %d\t\t# conjf(%#.2g + %#.2gI)\n",
3 * i + 1, creal(in), cimag(in));
}
feclearexcept(FE_ALL_EXCEPT);
if (!cfpequal(libconj(in), expected)) {
printf("not ok %d\t# conj(%#.2g + %#.2gI): "
"wrong value\n",
3 * i + 2, creal(in), cimag(in));
} else if (fetestexcept(FE_ALL_EXCEPT)) {
printf("not ok %d\t# conj(%#.2g + %#.2gI): "
"threw an exception\n",
3 * i + 2, creal(in), cimag(in));
} else {
printf("ok %d\t\t# conj(%#.2g + %#.2gI)\n",
3 * i + 2, creal(in), cimag(in));
}
feclearexcept(FE_ALL_EXCEPT);
if (!cfpequal(libconjl(in), expected)) {
printf("not ok %d\t# conjl(%#.2g + %#.2gI): "
"wrong value\n",
3 * i + 3, creal(in), cimag(in));
} else if (fetestexcept(FE_ALL_EXCEPT)) {
printf("not ok %d\t# conjl(%#.2g + %#.2gI): "
"threw an exception\n",
3 * i + 3, creal(in), cimag(in));
} else {
printf("ok %d\t\t# conjl(%#.2g + %#.2gI)\n",
3 * i + 3, creal(in), cimag(in));
}
}
return (0);
}

295
tools/regression/lib/msun/test-csqrt.c
View File

@ -1,295 +0,0 @@
/*-
* Copyright (c) 2007 David Schultz <das@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* Tests for csqrt{,f}()
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <assert.h>
#include <complex.h>
#include <float.h>
#include <math.h>
#include <stdio.h>
#include "test-utils.h"
#define N(i) (sizeof(i) / sizeof((i)[0]))
/*
* This is a test hook that can point to csqrtl(), _csqrt(), or to _csqrtf().
* The latter two convert to float or double, respectively, and test csqrtf()
* and csqrt() with the same arguments.
*/
long double complex (*t_csqrt)(long double complex);
static long double complex
_csqrtf(long double complex d)
{
return (csqrtf((float complex)d));
}
static long double complex
_csqrt(long double complex d)
{
return (csqrt((double complex)d));
}
#pragma STDC CX_LIMITED_RANGE off
/*
* Compare d1 and d2 using special rules: NaN == NaN and +0 != -0.
* Fail an assertion if they differ.
*/
static void
assert_equal(long double complex d1, long double complex d2)
{
assert(cfpequal(d1, d2));
}
/*
* Test csqrt for some finite arguments where the answer is exact.
* (We do not test if it produces correctly rounded answers when the
* result is inexact, nor do we check whether it throws spurious
* exceptions.)
*/
static void
test_finite()
{
static const double tests[] = {
/* csqrt(a + bI) = x + yI */
/* a b x y */
0, 8, 2, 2,
0, -8, 2, -2,
4, 0, 2, 0,
-4, 0, 0, 2,
3, 4, 2, 1,
3, -4, 2, -1,
-3, 4, 1, 2,
-3, -4, 1, -2,
5, 12, 3, 2,
7, 24, 4, 3,
9, 40, 5, 4,
11, 60, 6, 5,
13, 84, 7, 6,
33, 56, 7, 4,
39, 80, 8, 5,
65, 72, 9, 4,
987, 9916, 74, 67,
5289, 6640, 83, 40,
460766389075.0, 16762287900.0, 678910, 12345
};
/*
* We also test some multiples of the above arguments. This
* array defines which multiples we use. Note that these have
* to be small enough to not cause overflow for float precision
* with all of the constants in the above table.
*/
static const double mults[] = {
1,
2,
3,
13,
16,
0x1.p30,
0x1.p-30,
};
double a, b;
double x, y;
int i, j;
for (i = 0; i < N(tests); i += 4) {
for (j = 0; j < N(mults); j++) {
a = tests[i] * mults[j] * mults[j];
b = tests[i + 1] * mults[j] * mults[j];
x = tests[i + 2] * mults[j];
y = tests[i + 3] * mults[j];
assert(t_csqrt(CMPLXL(a, b)) == CMPLXL(x, y));
}
}
}
/*
* Test the handling of +/- 0.
*/
static void
test_zeros()
{
assert_equal(t_csqrt(CMPLXL(0.0, 0.0)), CMPLXL(0.0, 0.0));
assert_equal(t_csqrt(CMPLXL(-0.0, 0.0)), CMPLXL(0.0, 0.0));
assert_equal(t_csqrt(CMPLXL(0.0, -0.0)), CMPLXL(0.0, -0.0));
assert_equal(t_csqrt(CMPLXL(-0.0, -0.0)), CMPLXL(0.0, -0.0));
}
/*
* Test the handling of infinities when the other argument is not NaN.
*/
static void
test_infinities()
{
static const double vals[] = {
0.0,
-0.0,
42.0,
-42.0,
INFINITY,
-INFINITY,
};
int i;
for (i = 0; i < N(vals); i++) {
if (isfinite(vals[i])) {
assert_equal(t_csqrt(CMPLXL(-INFINITY, vals[i])),
CMPLXL(0.0, copysignl(INFINITY, vals[i])));
assert_equal(t_csqrt(CMPLXL(INFINITY, vals[i])),
CMPLXL(INFINITY, copysignl(0.0, vals[i])));
}
assert_equal(t_csqrt(CMPLXL(vals[i], INFINITY)),
CMPLXL(INFINITY, INFINITY));
assert_equal(t_csqrt(CMPLXL(vals[i], -INFINITY)),
CMPLXL(INFINITY, -INFINITY));
}
}
/*
* Test the handling of NaNs.
*/
static void
test_nans()
{
assert(creall(t_csqrt(CMPLXL(INFINITY, NAN))) == INFINITY);
assert(isnan(cimagl(t_csqrt(CMPLXL(INFINITY, NAN)))));
assert(isnan(creall(t_csqrt(CMPLXL(-INFINITY, NAN)))));
assert(isinf(cimagl(t_csqrt(CMPLXL(-INFINITY, NAN)))));
assert_equal(t_csqrt(CMPLXL(NAN, INFINITY)),
CMPLXL(INFINITY, INFINITY));
assert_equal(t_csqrt(CMPLXL(NAN, -INFINITY)),
CMPLXL(INFINITY, -INFINITY));
assert_equal(t_csqrt(CMPLXL(0.0, NAN)), CMPLXL(NAN, NAN));
assert_equal(t_csqrt(CMPLXL(-0.0, NAN)), CMPLXL(NAN, NAN));
assert_equal(t_csqrt(CMPLXL(42.0, NAN)), CMPLXL(NAN, NAN));
assert_equal(t_csqrt(CMPLXL(-42.0, NAN)), CMPLXL(NAN, NAN));
assert_equal(t_csqrt(CMPLXL(NAN, 0.0)), CMPLXL(NAN, NAN));
assert_equal(t_csqrt(CMPLXL(NAN, -0.0)), CMPLXL(NAN, NAN));
assert_equal(t_csqrt(CMPLXL(NAN, 42.0)), CMPLXL(NAN, NAN));
assert_equal(t_csqrt(CMPLXL(NAN, -42.0)), CMPLXL(NAN, NAN));
assert_equal(t_csqrt(CMPLXL(NAN, NAN)), CMPLXL(NAN, NAN));
}
/*
* Test whether csqrt(a + bi) works for inputs that are large enough to
* cause overflow in hypot(a, b) + a. In this case we are using
* csqrt(115 + 252*I) == 14 + 9*I
* scaled up to near MAX_EXP.
*/
static void
test_overflow(int maxexp)
{
long double a, b;
long double complex result;
a = ldexpl(115 * 0x1p-8, maxexp);
b = ldexpl(252 * 0x1p-8, maxexp);
result = t_csqrt(CMPLXL(a, b));
assert(creall(result) == ldexpl(14 * 0x1p-4, maxexp / 2));
assert(cimagl(result) == ldexpl(9 * 0x1p-4, maxexp / 2));
}
int
main(int argc, char *argv[])
{
printf("1..15\n");
/* Test csqrt() */
t_csqrt = _csqrt;
test_finite();
printf("ok 1 - csqrt\n");
test_zeros();
printf("ok 2 - csqrt\n");
test_infinities();
printf("ok 3 - csqrt\n");
test_nans();
printf("ok 4 - csqrt\n");
test_overflow(DBL_MAX_EXP);
printf("ok 5 - csqrt\n");
/* Now test csqrtf() */
t_csqrt = _csqrtf;
test_finite();
printf("ok 6 - csqrt\n");
test_zeros();
printf("ok 7 - csqrt\n");
test_infinities();
printf("ok 8 - csqrt\n");
test_nans();
printf("ok 9 - csqrt\n");
test_overflow(FLT_MAX_EXP);
printf("ok 10 - csqrt\n");
/* Now test csqrtl() */
t_csqrt = csqrtl;
test_finite();
printf("ok 11 - csqrt\n");
test_zeros();
printf("ok 12 - csqrt\n");
test_infinities();
printf("ok 13 - csqrt\n");
test_nans();
printf("ok 14 - csqrt\n");
test_overflow(LDBL_MAX_EXP);
printf("ok 15 - csqrt\n");
return (0);
}

482
tools/regression/lib/msun/test-ctrig.c
View File

@ -1,482 +0,0 @@
/*-
* Copyright (c) 2008-2011 David Schultz <das@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* Tests for csin[h](), ccos[h](), and ctan[h]().
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <assert.h>
#include <complex.h>
#include <fenv.h>
#include <float.h>
#include <math.h>
#include <stdio.h>
#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 <format>_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);
}

10
tools/regression/lib/msun/test-ctrig.t
View File

@ -1,10 +0,0 @@
#!/bin/sh
# $FreeBSD$
cd `dirname $0`
executable=`basename $0 .t`
make $executable 2>&1 > /dev/null
exec ./$executable

169
tools/regression/lib/msun/test-exponential.c
View File

@ -1,169 +0,0 @@
/*-
* Copyright (c) 2008 David Schultz <das@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* Tests for corner cases in exp*().
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <assert.h>
#include <fenv.h>
#include <float.h>
#include <math.h>
#include <stdio.h>
#ifdef __i386__
#include <ieeefp.h>
#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);
}

10
tools/regression/lib/msun/test-exponential.t
View File

@ -1,10 +0,0 @@
#!/bin/sh
# $FreeBSD$
cd `dirname $0`
executable=`basename $0 .t`
make $executable 2>&1 > /dev/null
exec ./$executable

538
tools/regression/lib/msun/test-fma.c
View File

@ -1,538 +0,0 @@
/*-
* Copyright (c) 2008 David Schultz <das@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* Tests for fma{,f,l}().
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <assert.h>
#include <fenv.h>
#include <float.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#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++) {
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 %d - fma NaNs\n", j);
j++;
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);
}

10
tools/regression/lib/msun/test-fma.t
View File

@ -1,10 +0,0 @@
#!/bin/sh
# $FreeBSD$
cd `dirname $0`
executable=`basename $0 .t`
make $executable 2>&1 > /dev/null
exec ./$executable

481
tools/regression/lib/msun/test-invtrig.c
View File

@ -1,481 +0,0 @@
/*-
* Copyright (c) 2008 David Schultz <das@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* 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 <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <assert.h>
#include <fenv.h>
#include <float.h>
#include <math.h>
#include <stdio.h>
#include "test-utils.h"
#define LEN(a) (sizeof(a) / sizeof((a)[0]))
#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);
}

10
tools/regression/lib/msun/test-invtrig.t
View File

@ -1,10 +0,0 @@
#!/bin/sh
# $FreeBSD$
cd `dirname $0`
executable=`basename $0 .t`
make $executable 2>&1 > /dev/null
exec ./$executable

115
tools/regression/lib/msun/test-lround.c
View File

@ -1,115 +0,0 @@
/*-
* Copyright (c) 2005 David Schultz <das@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* Test for lround(), lroundf(), llround(), and llroundf().
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <assert.h>
#include <fenv.h>
#include <limits.h>
#include <math.h>
#include <stdio.h>
/*
* 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);
}

10
tools/regression/lib/msun/test-lround.t
View File

@ -1,10 +0,0 @@
#!/bin/sh
# $FreeBSD$
cd `dirname $0`
executable=`basename $0 .t`
make $executable 2>&1 > /dev/null
exec ./$executable

280
tools/regression/lib/msun/test-trig.c
View File

@ -1,280 +0,0 @@
/*-
* Copyright (c) 2008 David Schultz <das@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* Tests for corner cases in trigonometric functions. Some accuracy tests
* are included as well, but these are very basic sanity checks, not
* intended to be comprehensive.
*
* The program for generating representable numbers near multiples of pi is
* available at http://www.cs.berkeley.edu/~wkahan/testpi/ .
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <assert.h>
#include <fenv.h>
#include <float.h>
#include <math.h>
#include <stdio.h>
#include "test-utils.h"
#define LEN(a) (sizeof(a) / sizeof((a)[0]))
#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.
*
* 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)
#define testall(prefix, x, result, exceptmask, excepts) do { \
test(prefix, x, (double)result, exceptmask, excepts); \
test(prefix##f, x, (float)result, exceptmask, excepts); \
test(prefix##l, x, result, exceptmask, excepts); \
} while (0)
#define testdf(prefix, x, result, exceptmask, excepts) do { \
test(prefix, x, (double)result, exceptmask, excepts); \
test(prefix##f, x, (float)result, exceptmask, excepts); \
} while (0)
/*
* Test special cases in sin(), cos(), and tan().
*/
static void
run_special_tests(void)
{
/* Values at 0 should be exact. */
testall(tan, 0.0, 0.0, ALL_STD_EXCEPT, 0);
testall(tan, -0.0, -0.0, ALL_STD_EXCEPT, 0);
testall(cos, 0.0, 1.0, ALL_STD_EXCEPT, 0);
testall(cos, -0.0, 1.0, ALL_STD_EXCEPT, 0);
testall(sin, 0.0, 0.0, ALL_STD_EXCEPT, 0);
testall(sin, -0.0, -0.0, ALL_STD_EXCEPT, 0);
/* func(+-Inf) == NaN */
testall(tan, INFINITY, NAN, ALL_STD_EXCEPT, FE_INVALID);
testall(sin, INFINITY, NAN, ALL_STD_EXCEPT, FE_INVALID);
testall(cos, INFINITY, NAN, ALL_STD_EXCEPT, FE_INVALID);
testall(tan, -INFINITY, NAN, ALL_STD_EXCEPT, FE_INVALID);
testall(sin, -INFINITY, NAN, ALL_STD_EXCEPT, FE_INVALID);
testall(cos, -INFINITY, NAN, ALL_STD_EXCEPT, FE_INVALID);
/* func(NaN) == NaN */
testall(tan, NAN, NAN, ALL_STD_EXCEPT, 0);
testall(sin, NAN, NAN, ALL_STD_EXCEPT, 0);
testall(cos, NAN, NAN, ALL_STD_EXCEPT, 0);
}
/*
* Tests to ensure argument reduction for large arguments is accurate.
*/
static void
run_reduction_tests(void)
{
/* floats very close to odd multiples of pi */
static const float f_pi_odd[] = {
85563208.0f,
43998769152.0f,
9.2763667655669323e+25f,
1.5458357838905804e+29f,
};
/* doubles very close to odd multiples of pi */
static const double d_pi_odd[] = {
3.1415926535897931,
91.106186954104004,
642615.9188844458,
3397346.5699258847,
6134899525417045.0,
3.0213551960457761e+43,
1.2646209897993783e+295,
6.2083625380677099e+307,
};
/* long doubles very close to odd multiples of pi */
#if LDBL_MANT_DIG == 64
static const long double ld_pi_odd[] = {
1.1891886960373841596e+101L,
1.07999475322710967206e+2087L,
6.522151627890431836e+2147L,
8.9368974898260328229e+2484L,
9.2961044110572205863e+2555L,
4.90208421886578286e+3189L,
1.5275546401232615884e+3317L,
1.7227465626338900093e+3565L,
2.4160090594000745334e+3808L,
9.8477555741888350649e+4314L,
1.6061597222105160737e+4326L,
};
#elif LDBL_MANT_DIG == 113
static const long double ld_pi_odd[] = {
/* XXX */
};
#endif
int i;
for (i = 0; i < LEN(f_pi_odd); i++) {
assert(fabs(sinf(f_pi_odd[i])) < FLT_EPSILON);
assert(cosf(f_pi_odd[i]) == -1.0);
assert(fabs(tan(f_pi_odd[i])) < FLT_EPSILON);
assert(fabs(sinf(-f_pi_odd[i])) < FLT_EPSILON);
assert(cosf(-f_pi_odd[i]) == -1.0);
assert(fabs(tanf(-f_pi_odd[i])) < FLT_EPSILON);
assert(fabs(sinf(f_pi_odd[i] * 2)) < FLT_EPSILON);
assert(cosf(f_pi_odd[i] * 2) == 1.0);
assert(fabs(tanf(f_pi_odd[i] * 2)) < FLT_EPSILON);
assert(fabs(sinf(-f_pi_odd[i] * 2)) < FLT_EPSILON);
assert(cosf(-f_pi_odd[i] * 2) == 1.0);
assert(fabs(tanf(-f_pi_odd[i] * 2)) < FLT_EPSILON);
}
for (i = 0; i < LEN(d_pi_odd); i++) {
assert(fabs(sin(d_pi_odd[i])) < 2 * DBL_EPSILON);
assert(cos(d_pi_odd[i]) == -1.0);
assert(fabs(tan(d_pi_odd[i])) < 2 * DBL_EPSILON);
assert(fabs(sin(-d_pi_odd[i])) < 2 * DBL_EPSILON);
assert(cos(-d_pi_odd[i]) == -1.0);
assert(fabs(tan(-d_pi_odd[i])) < 2 * DBL_EPSILON);
assert(fabs(sin(d_pi_odd[i] * 2)) < 2 * DBL_EPSILON);
assert(cos(d_pi_odd[i] * 2) == 1.0);
assert(fabs(tan(d_pi_odd[i] * 2)) < 2 * DBL_EPSILON);
assert(fabs(sin(-d_pi_odd[i] * 2)) < 2 * DBL_EPSILON);
assert(cos(-d_pi_odd[i] * 2) == 1.0);
assert(fabs(tan(-d_pi_odd[i] * 2)) < 2 * DBL_EPSILON);
}
#if LDBL_MANT_DIG > 53
for (i = 0; i < LEN(ld_pi_odd); i++) {
assert(fabsl(sinl(ld_pi_odd[i])) < LDBL_EPSILON);
assert(cosl(ld_pi_odd[i]) == -1.0);
assert(fabsl(tanl(ld_pi_odd[i])) < LDBL_EPSILON);
assert(fabsl(sinl(-ld_pi_odd[i])) < LDBL_EPSILON);
assert(cosl(-ld_pi_odd[i]) == -1.0);
assert(fabsl(tanl(-ld_pi_odd[i])) < LDBL_EPSILON);
assert(fabsl(sinl(ld_pi_odd[i] * 2)) < LDBL_EPSILON);
assert(cosl(ld_pi_odd[i] * 2) == 1.0);
assert(fabsl(tanl(ld_pi_odd[i] * 2)) < LDBL_EPSILON);
assert(fabsl(sinl(-ld_pi_odd[i] * 2)) < LDBL_EPSILON);
assert(cosl(-ld_pi_odd[i] * 2) == 1.0);
assert(fabsl(tanl(-ld_pi_odd[i] * 2)) < LDBL_EPSILON);
}
#endif
}
/*
* Tests the accuracy of these functions over the primary range.
*/
static void
run_accuracy_tests(void)
{
/* For small args, sin(x) = tan(x) = x, and cos(x) = 1. */
testall(sin, 0xd.50ee515fe4aea16p-114L, 0xd.50ee515fe4aea16p-114L,
ALL_STD_EXCEPT, FE_INEXACT);
testall(tan, 0xd.50ee515fe4aea16p-114L, 0xd.50ee515fe4aea16p-114L,
ALL_STD_EXCEPT, FE_INEXACT);
testall(cos, 0xd.50ee515fe4aea16p-114L, 1.0,
ALL_STD_EXCEPT, FE_INEXACT);
/*
* These tests should pass for f32, d64, and ld80 as long as
* the error is <= 0.75 ulp (round to nearest)
*/
#if LDBL_MANT_DIG <= 64
#define testacc testall
#else
#define testacc testdf
#endif
testacc(sin, 0.17255452780841205174L, 0.17169949801444412683L,
ALL_STD_EXCEPT, FE_INEXACT);
testacc(sin, -0.75431944555904520893L, -0.68479288156557286353L,
ALL_STD_EXCEPT, FE_INEXACT);
testacc(cos, 0.70556358769838947292L, 0.76124620693117771850L,
ALL_STD_EXCEPT, FE_INEXACT);
testacc(cos, -0.34061437849088045332L, 0.94254960031831729956L,
ALL_STD_EXCEPT, FE_INEXACT);
testacc(tan, -0.15862817413325692897L, -0.15997221861309522115L,
ALL_STD_EXCEPT, FE_INEXACT);
testacc(tan, 0.38374784931303813530L, 0.40376500259976759951L,
ALL_STD_EXCEPT, FE_INEXACT);
/*
* XXX missing:
* - tests for ld128
* - tests for other rounding modes (probably won't pass for now)
* - tests for large numbers that get reduced to hi+lo with lo!=0
*/
}
int
main(int argc, char *argv[])
{
printf("1..3\n");
run_special_tests();
printf("ok 1 - trig\n");
#ifndef __i386__
run_reduction_tests();
#endif
printf("ok 2 - trig\n");
#ifndef __i386__
run_accuracy_tests();
#endif
printf("ok 3 - trig\n");
return (0);
}

174
tools/regression/lib/msun/test-utils.h
View File

@ -1,174 +0,0 @@
/*-
* Copyright (c) 2005-2013 David Schultz <das@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#ifndef _TEST_UTILS_H_
#define _TEST_UTILS_H_
#include <complex.h>
#include <fenv.h>
/*
* 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_ */