aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorAlex Richardson <arichardson@FreeBSD.org>2021-02-22 17:19:06 +0000
committerAlex Richardson <arichardson@FreeBSD.org>2021-02-22 17:41:04 +0000
commit1ec3feb64826d2a43d41e74684690985bf20e71c (patch)
tree688b376ad6c4fe44f958a28811e48576f6a9c98e
parent9febbc4541903bb8e6b0f1c84988c98b2f7c96ef (diff)
downloadsrc-1ec3feb64826d2a43d41e74684690985bf20e71c.tar.gz
src-1ec3feb64826d2a43d41e74684690985bf20e71c.zip
Update libm tests from NetBSD
I did this without a full vendor update since that would cause too many conflicts. Since these files now almost match the NetBSD sources the next git subtree merge should work just fine. Reviewed By: lwhsu Differential Revision: https://reviews.freebsd.org/D28797
-rw-r--r--contrib/netbsd-tests/lib/libm/t_acos.c4
-rw-r--r--contrib/netbsd-tests/lib/libm/t_asin.c35
-rw-r--r--contrib/netbsd-tests/lib/libm/t_bit.c102
-rw-r--r--contrib/netbsd-tests/lib/libm/t_cabsl.cxx66
-rw-r--r--contrib/netbsd-tests/lib/libm/t_cbrt.c95
-rw-r--r--contrib/netbsd-tests/lib/libm/t_cos.c196
-rw-r--r--contrib/netbsd-tests/lib/libm/t_cosh.c58
-rw-r--r--contrib/netbsd-tests/lib/libm/t_exp.c52
-rw-r--r--contrib/netbsd-tests/lib/libm/t_fe_round.c138
-rw-r--r--contrib/netbsd-tests/lib/libm/t_fenv.c12
-rw-r--r--contrib/netbsd-tests/lib/libm/t_fmod.c8
-rw-r--r--contrib/netbsd-tests/lib/libm/t_ilogb.c8
-rw-r--r--contrib/netbsd-tests/lib/libm/t_ldexp.c37
-rw-r--r--contrib/netbsd-tests/lib/libm/t_libm.h6
-rw-r--r--contrib/netbsd-tests/lib/libm/t_log.c18
-rw-r--r--contrib/netbsd-tests/lib/libm/t_round.c55
-rw-r--r--contrib/netbsd-tests/lib/libm/t_scalbn.c58
-rw-r--r--contrib/netbsd-tests/lib/libm/t_sin.c91
-rw-r--r--contrib/netbsd-tests/lib/libm/t_sinh.c56
-rw-r--r--contrib/netbsd-tests/lib/libm/t_sqrt.c84
-rw-r--r--contrib/netbsd-tests/lib/libm/t_tan.c86
-rw-r--r--lib/msun/tests/Makefile2
22 files changed, 946 insertions, 321 deletions
diff --git a/contrib/netbsd-tests/lib/libm/t_acos.c b/contrib/netbsd-tests/lib/libm/t_acos.c
index f051fb64df42..973f0245cdab 100644
--- a/contrib/netbsd-tests/lib/libm/t_acos.c
+++ b/contrib/netbsd-tests/lib/libm/t_acos.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_acos.c,v 1.10 2014/03/05 20:14:46 dsl Exp $ */
+/* $NetBSD: t_acos.c,v 1.11 2018/11/07 03:59:36 riastradh Exp $ */
/*-
* Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -72,7 +72,7 @@ ATF_LIBM_TEST(acos_inrange, "Test acos/acosf(x) for some valid values")
{ 0, M_PI / 2, },
{ 0.1, 1.470628905633337, },
{ 0.5, 1.047197551196598, },
- { 0.99, 0.141539473324427, },
+ { 0.99, 0.1415394733244273, },
};
unsigned int i;
diff --git a/contrib/netbsd-tests/lib/libm/t_asin.c b/contrib/netbsd-tests/lib/libm/t_asin.c
index 06de85216429..213b1f875439 100644
--- a/contrib/netbsd-tests/lib/libm/t_asin.c
+++ b/contrib/netbsd-tests/lib/libm/t_asin.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_asin.c,v 1.3 2014/03/03 10:39:08 martin Exp $ */
+/* $NetBSD: t_asin.c,v 1.4 2018/11/07 03:59:36 riastradh Exp $ */
/*-
* Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -30,6 +30,7 @@
*/
#include <atf-c.h>
+#include <float.h>
#include <math.h>
static const struct {
@@ -117,13 +118,14 @@ ATF_TC_HEAD(asin_inrange, tc)
ATF_TC_BODY(asin_inrange, tc)
{
- const double eps = 1.0e-15;
- double y;
+ const double eps = DBL_EPSILON;
size_t i;
for (i = 0; i < __arraycount(values); i++) {
- y = asin(values[i].x);
- if (fabs(y - values[i].y) > eps)
+ double x = values[i].x;
+ double y = values[i].y;
+
+ if (!(fabs((asin(x) - y)/y) <= eps))
atf_tc_fail_nonfatal("asin(%g) != %g",
values[i].x, values[i].y);
}
@@ -230,16 +232,25 @@ ATF_TC_HEAD(asinf_inrange, tc)
ATF_TC_BODY(asinf_inrange, tc)
{
- const float eps = 1.0e-6;
- float x;
- float y;
+ const float eps = FLT_EPSILON;
size_t i;
for (i = 0; i < __arraycount(values); i++) {
- x = values[i].x;
- y = values[i].y;
- if (fabs(asinf(x) - y) > eps)
- atf_tc_fail_nonfatal("asinf(%g) != %g", x, y);
+ float x = values[i].x;
+ float y = values[i].y;
+
+#ifdef __NetBSD__
+ if (fabs(x) == 0.5)
+ atf_tc_expect_fail("asinf is busted,"
+ " gives ~2ulp error");
+#endif
+ if (!(fabsf((asinf(x) - y)/y) <= eps)) {
+ atf_tc_fail_nonfatal("asinf(%.8g) = %.8g != %.8g,"
+ " error=~%.1fulp",
+ x, asinf(x), y, fabsf(((asinf(x) - y)/y)/eps));
+ }
+ if (fabs(x) == 0.5)
+ atf_tc_expect_pass();
}
}
diff --git a/contrib/netbsd-tests/lib/libm/t_bit.c b/contrib/netbsd-tests/lib/libm/t_bit.c
new file mode 100644
index 000000000000..b6e0218f601c
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libm/t_bit.c
@@ -0,0 +1,102 @@
+/* $NetBSD: t_bit.c,v 1.1 2019/04/26 08:52:16 maya Exp $ */
+
+/*
+ * Written by Maya Rashish <maya@NetBSD.org>
+ * Public domain.
+ *
+ * Testing signbit{,f,l} function correctly
+ */
+
+#include <atf-c.h>
+#include <float.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+static const struct {
+ double input;
+ bool is_negative;
+} values[] = {
+ { -1, true},
+ { -123, true},
+ { -123E6, true},
+#ifdef INFINITY
+ { -INFINITY, true},
+ { INFINITY, false},
+#endif
+ { 123E6, false},
+ { 0, false},
+ { -FLT_MIN, true},
+ { FLT_MIN, false},
+ /*
+ * Cannot be accurately represented as float,
+ * but sign should be preserved
+ */
+ { DBL_MAX, false},
+ { -DBL_MAX, true},
+};
+
+#ifdef __HAVE_LONG_DOUBLE
+static const struct {
+ long double input;
+ bool is_negative;
+} ldbl_values[] = {
+ { -LDBL_MIN, true},
+ { LDBL_MIN, false},
+ { LDBL_MAX, false},
+ { -LDBL_MAX, true},
+};
+#endif
+
+ATF_TC(signbit);
+ATF_TC_HEAD(signbit, tc)
+{
+ atf_tc_set_md_var(tc, "descr","Check that signbit functions correctly");
+}
+
+ATF_TC_BODY(signbit, tc)
+{
+ double iterator_d;
+ float iterator_f;
+
+ for (unsigned int i = 0; i < __arraycount(values); i++) {
+ iterator_d = values[i].input;
+ iterator_f = (float) values[i].input;
+ if (signbit(iterator_f) != values[i].is_negative)
+ atf_tc_fail("%s:%d iteration %d signbitf is wrong"
+ " about the sign of %f", __func__,
+ __LINE__, i, iterator_f);
+ if (signbit(iterator_d) != values[i].is_negative)
+ atf_tc_fail("%s:%d iteration %d signbit is wrong"
+ "about the sign of %f", __func__,
+ __LINE__,i, iterator_d);
+
+#ifdef __HAVE_LONG_DOUBLE
+ long double iterator_l = values[i].input;
+ if (signbit(iterator_l) != values[i].is_negative)
+ atf_tc_fail("%s:%d iteration %d signbitl is wrong"
+ " about the sign of %Lf", __func__,
+ __LINE__, i, iterator_l);
+#endif
+ }
+
+#ifdef __HAVE_LONG_DOUBLE
+ for (unsigned int i = 0; i < __arraycount(ldbl_values); i++) {
+ if (signbit(ldbl_values[i].input) != ldbl_values[i].is_negative)
+ atf_tc_fail("%s:%d iteration %d signbitl is"
+ "wrong about the sign of %Lf",
+ __func__, __LINE__, i,
+ ldbl_values[i].input);
+ }
+#endif
+
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+ ATF_TP_ADD_TC(tp, signbit);
+
+ return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libm/t_cabsl.cxx b/contrib/netbsd-tests/lib/libm/t_cabsl.cxx
new file mode 100644
index 000000000000..7dd119b1da3b
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libm/t_cabsl.cxx
@@ -0,0 +1,66 @@
+/*-
+ * Copyright (c) 2018 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Maya Rashish
+ *
+ * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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 that C++ "cabsl" is usable. PR lib/50646
+ */
+
+#include <atf-c++.hpp>
+#include <complex>
+
+ATF_TEST_CASE(cabsl);
+ATF_TEST_CASE_HEAD(cabsl)
+{
+ set_md_var("descr", "Check that cabsl is usable from C++");
+}
+ATF_TEST_CASE_BODY(cabsl)
+{
+ int sum = 0;
+
+#ifdef __HAVE_LONG_DOUBLE
+ std::complex<long double> cld(3.0,4.0);
+ sum += std::abs(cld);
+#endif
+ std::complex<double> cd(3.0,4.0);
+ sum += std::abs(cd);
+
+ std::complex<float> cf(3.0,4.0);
+ sum += std::abs(cf);
+
+#ifdef __HAVE_LONG_DOUBLE
+ ATF_REQUIRE_EQ(sum, 3*5);
+#else
+ ATF_REQUIRE_EQ(sum, 2*5);
+#endif
+}
+
+ATF_INIT_TEST_CASES(tcs)
+{
+ ATF_ADD_TEST_CASE(tcs, cabsl);
+}
diff --git a/contrib/netbsd-tests/lib/libm/t_cbrt.c b/contrib/netbsd-tests/lib/libm/t_cbrt.c
index 08e9faeb145c..639bc7e06517 100644
--- a/contrib/netbsd-tests/lib/libm/t_cbrt.c
+++ b/contrib/netbsd-tests/lib/libm/t_cbrt.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_cbrt.c,v 1.3 2014/03/03 10:39:08 martin Exp $ */
+/* $NetBSD: t_cbrt.c,v 1.5 2018/11/15 05:14:20 riastradh Exp $ */
/*-
* Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,9 +29,10 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
-__RCSID("$NetBSD: t_cbrt.c,v 1.3 2014/03/03 10:39:08 martin Exp $");
+__RCSID("$NetBSD: t_cbrt.c,v 1.5 2018/11/15 05:14:20 riastradh Exp $");
#include <atf-c.h>
+#include <float.h>
#include <math.h>
#include <stdio.h>
@@ -61,18 +62,26 @@ ATF_TC_HEAD(cbrt_pow, tc)
ATF_TC_BODY(cbrt_pow, tc)
{
const double x[] = { 0.0, 0.005, 1.0, 99.0, 123.123, 9999.0 };
- const double eps = 1.0e-14;
- double y, z;
+ /* Neither cbrt nor pow is required to be correctly rounded. */
+ const double eps = 2*DBL_EPSILON;
size_t i;
for (i = 0; i < __arraycount(x); i++) {
-
- y = cbrt(x[i]);
- z = pow(x[i], 1.0 / 3.0);
-
- if (fabs(y - z) > eps)
- atf_tc_fail_nonfatal("cbrt(%0.03f) != "
- "pow(%0.03f, 1/3)\n", x[i], x[i]);
+ double x_cbrt = cbrt(x[i]);
+ double x_pow13 = pow(x[i], 1.0 / 3.0);
+ bool ok;
+
+ if (x[i] == 0) {
+ ok = (x_cbrt == x_pow13);
+ } else {
+ ok = (fabs((x_cbrt - x_pow13)/x_cbrt) <= eps);
+ }
+
+ if (!ok) {
+ atf_tc_fail_nonfatal("cbrt(%.17g) = %.17g != "
+ "pow(%.17g, 1/3) = %.17g\n",
+ x[i], x_cbrt, x[i], x_pow13);
+ }
}
}
@@ -162,18 +171,27 @@ ATF_TC_HEAD(cbrtf_powf, tc)
ATF_TC_BODY(cbrtf_powf, tc)
{
const float x[] = { 0.0, 0.005, 1.0, 99.0, 123.123, 9999.0 };
- const float eps = 1.0e-5;
- float y, z;
+ /* Neither cbrt nor pow is required to be correctly rounded. */
+ const float eps = 2*FLT_EPSILON;
size_t i;
for (i = 0; i < __arraycount(x); i++) {
-
- y = cbrtf(x[i]);
- z = powf(x[i], 1.0 / 3.0);
-
- if (fabsf(y - z) > eps)
- atf_tc_fail_nonfatal("cbrtf(%0.03f) != "
- "powf(%0.03f, 1/3)\n", x[i], x[i]);
+ float x_cbrt = cbrtf(x[i]);
+ float x_pow13 = powf(x[i], 1.0 / 3.0);
+ bool ok;
+
+ if (x[i] == 0) {
+ ok = (x_cbrt == x_pow13);
+ } else {
+ ok = (fabsf((x_cbrt - x_pow13)/x_cbrt) <= eps);
+ }
+
+ if (!ok) {
+ atf_tc_fail_nonfatal("cbrtf(%.9g) = %.9g. != "
+ "powf(%.9g, 1/3) = %.9g\n",
+ (double)x[i], (double)x_cbrt,
+ (double)x[i], (double)x_pow13);
+ }
}
}
@@ -264,27 +282,42 @@ ATF_TC_HEAD(cbrtl_powl, tc)
ATF_TC_BODY(cbrtl_powl, tc)
{
const long double x[] = { 0.0, 0.005, 1.0, 99.0, 123.123, 9999.0 };
- const long double eps = 1.0e-15;
- long double y, z;
+ /* Neither cbrt nor pow is required to be correctly rounded. */
+ const long double eps = 2*LDBL_EPSILON;
size_t i;
#if defined(__amd64__) && defined(__clang__) && __clang_major__ >= 7 && \
__clang_major__ < 10 && __FreeBSD_cc_version < 1300002
atf_tc_expect_fail("test fails with clang 7-9 - bug 234040");
#endif
-
for (i = 0; i < __arraycount(x); i++) {
-
- y = cbrtl(x[i]);
+ long double x_cbrt = cbrtl(x[i]);
#ifdef __FreeBSD__
- z = powl(x[i], (long double)1.0 / 3.0);
+ /*
+ * NetBSD doesn't have a real powl/cbrtl implementation, they
+ * just call the double version. On FreeBSD we have a real
+ * powl implementation so we have to cast the second argument
+ * to long double before dividing to get a more precise
+ * approximation of 1/3.
+ * TODO: upstream this diff.
+ */
+ long double x_pow13 = powl(x[i], (long double)1.0 / 3.0);
#else
- z = powl(x[i], 1.0 / 3.0);
+ long double x_pow13 = powl(x[i], 1.0 / 3.0);
#endif
-
- if (fabsl(y - z) > eps * fabsl(1 + x[i]))
- atf_tc_fail_nonfatal("cbrtl(%0.03Lf) != "
- "powl(%0.03Lf, 1/3)\n", x[i], x[i]);
+ bool ok;
+
+ if (x[i] == 0) {
+ ok = (x_cbrt == x_pow13);
+ } else {
+ ok = (fabsl((x_cbrt - x_pow13)/x_cbrt) <= eps);
+ }
+
+ if (!ok) {
+ atf_tc_fail_nonfatal("cbrtl(%.35Lg) = %.35Lg != "
+ "powl(%.35Lg, 1/3) = %.35Lg\n",
+ x[i], x_cbrt, x[i], x_pow13);
+ }
}
}
diff --git a/contrib/netbsd-tests/lib/libm/t_cos.c b/contrib/netbsd-tests/lib/libm/t_cos.c
index d99d60810eeb..ca5f0aab7ffa 100644
--- a/contrib/netbsd-tests/lib/libm/t_cos.c
+++ b/contrib/netbsd-tests/lib/libm/t_cos.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_cos.c,v 1.4 2014/03/03 10:39:08 martin Exp $ */
+/* $NetBSD: t_cos.c,v 1.9 2019/05/27 00:10:36 maya Exp $ */
/*-
* Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,31 +29,138 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
+#include <assert.h>
#include <atf-c.h>
+#include <float.h>
#include <math.h>
static const struct {
int angle;
double x;
double y;
+ float fy;
} angles[] = {
- { -180, -3.141592653589793, -1.0000000000000000 },
- { -135, -2.356194490192345, -0.7071067811865476 },
- { -90, -1.570796326794897, 0.0000000000000000 },
- { -45, -0.785398163397448, 0.7071067811865476 },
- { 0, 0.000000000000000, 1.0000000000000000 },
- { 30, 0.523598775598299, 0.8660254037844386 },
- { 45, 0.785398163397448, 0.7071067811865476 },
- { 60, 1.047197551196598, 0.5000000000000000 },
- { 90, 1.570796326794897, 0.0000000000000000 },
- { 120, 2.094395102393195, -0.5000000000000000 },
- { 135, 2.356194490192345, -0.7071067811865476 },
- { 150, 2.617993877991494, -0.8660254037844386 },
- { 180, 3.141592653589793, -1.0000000000000000 },
- { 270, 4.712388980384690, 0.0000000000000000 },
- { 360, 6.283185307179586, 1.0000000000000000 }
+ { -180, -3.141592653589793, -1.0000000000000000, 999 },
+ { -135, -2.356194490192345, -0.7071067811865476, 999 },
+ { -90, -1.5707963267948966, 6.123233995736766e-17, -4.3711388e-08 },
+ { -90, -1.5707963267948968, -1.6081226496766366e-16, -4.3711388e-08 },
+ { -45, -0.785398163397448, 0.7071067811865478, 999 },
+ { 0, 0.000000000000000, 1.0000000000000000, 999 },
+ { 30, 0.523598775598299, 0.8660254037844386, 999 },
+ { 45, 0.785398163397448, 0.7071067811865478, 999 },
+ { 60, 1.0471975511965976, 0.5000000000000001, 999 },
+ { 60, 1.0471975511965979, 0.4999999999999999, 999 },
+ { 90, 1.570796326794897, -3.8285686989269494e-16, -4.3711388e-08 },
+ { 120, 2.0943951023931953, -0.4999999999999998, 999 },
+ { 120, 2.0943951023931957, -0.5000000000000002, 999 },
+ { 135, 2.356194490192345, -0.7071067811865476, 999 },
+ { 150, 2.617993877991494, -0.8660254037844386, 999 },
+ { 180, 3.141592653589793, -1.0000000000000000, 999 },
+ { 270, 4.712388980384690, -1.8369701987210297e-16, 1.1924881e-08 },
+ { 360, 6.283185307179586, 1.0000000000000000, 999 },
};
+#ifdef __HAVE_LONG_DOUBLE
+/*
+ * cosl(3)
+ */
+ATF_TC(cosl_angles);
+ATF_TC_HEAD(cosl_angles, tc)
+{
+ atf_tc_set_md_var(tc, "descr", "Test some selected angles");
+}
+
+ATF_TC_BODY(cosl_angles, tc)
+{
+ /*
+ * XXX The given data is for double, so take that
+ * into account and expect less precise results..
+ */
+ const long double eps = DBL_EPSILON;
+ size_t i;
+
+ for (i = 0; i < __arraycount(angles); i++) {
+ int deg = angles[i].angle;
+ long double theta = angles[i].x;
+ long double cos_theta = angles[i].y;
+
+ assert(cos_theta != 0);
+ if (!(fabsl((cosl(theta) - cos_theta)/cos_theta) <= eps)) {
+ atf_tc_fail_nonfatal("cos(%d deg = %.17Lg) = %.17Lg"
+ " != %.17Lg",
+ deg, theta, cosl(theta), cos_theta);
+ }
+ }
+}
+
+ATF_TC(cosl_nan);
+ATF_TC_HEAD(cosl_nan, tc)
+{
+ atf_tc_set_md_var(tc, "descr", "Test cosl(NaN) == NaN");
+}
+
+ATF_TC_BODY(cosl_nan, tc)
+{
+ const long double x = 0.0L / 0.0L;
+
+ ATF_CHECK(isnan(x) != 0);
+ ATF_CHECK(isnan(cosl(x)) != 0);
+}
+
+ATF_TC(cosl_inf_neg);
+ATF_TC_HEAD(cosl_inf_neg, tc)
+{
+ atf_tc_set_md_var(tc, "descr", "Test cosl(-Inf) == NaN");
+}
+
+ATF_TC_BODY(cosl_inf_neg, tc)
+{
+ const long double x = -1.0L / 0.0L;
+
+ ATF_CHECK(isnan(cosl(x)) != 0);
+}
+
+ATF_TC(cosl_inf_pos);
+ATF_TC_HEAD(cosl_inf_pos, tc)
+{
+ atf_tc_set_md_var(tc, "descr", "Test cosl(+Inf) == NaN");
+}
+
+ATF_TC_BODY(cosl_inf_pos, tc)
+{
+ const long double x = 1.0L / 0.0L;
+
+ ATF_CHECK(isnan(cosl(x)) != 0);
+}
+
+
+ATF_TC(cosl_zero_neg);
+ATF_TC_HEAD(cosl_zero_neg, tc)
+{
+ atf_tc_set_md_var(tc, "descr", "Test cosl(-0.0) == 1.0");
+}
+
+ATF_TC_BODY(cosl_zero_neg, tc)
+{
+ const long double x = -0.0L;
+
+ ATF_CHECK(cosl(x) == 1.0);
+}
+
+ATF_TC(cosl_zero_pos);
+ATF_TC_HEAD(cosl_zero_pos, tc)
+{
+ atf_tc_set_md_var(tc, "descr", "Test cosl(+0.0) == 1.0");
+}
+
+ATF_TC_BODY(cosl_zero_pos, tc)
+{
+ const long double x = 0.0L;
+
+ ATF_CHECK(cosl(x) == 1.0);
+}
+#endif
+
/*
* cos(3)
*/
@@ -65,14 +172,20 @@ ATF_TC_HEAD(cos_angles, tc)
ATF_TC_BODY(cos_angles, tc)
{
- const double eps = 1.0e-15;
+ const double eps = DBL_EPSILON;
size_t i;
for (i = 0; i < __arraycount(angles); i++) {
-
- if (fabs(cos(angles[i].x) - angles[i].y) > eps)
- atf_tc_fail_nonfatal("cos(%d deg) != %0.01f",
- angles[i].angle, angles[i].y);
+ int deg = angles[i].angle;
+ double theta = angles[i].x;
+ double cos_theta = angles[i].y;
+
+ assert(cos_theta != 0);
+ if (!(fabs((cos(theta) - cos_theta)/cos_theta) <= eps)) {
+ atf_tc_fail_nonfatal("cos(%d deg = %.17g) = %.17g"
+ " != %.17g",
+ deg, theta, cos(theta), cos_theta);
+ }
}
}
@@ -154,18 +267,33 @@ ATF_TC_HEAD(cosf_angles, tc)
ATF_TC_BODY(cosf_angles, tc)
{
- const float eps = 1.0e-7;
- float x, y;
+ const float eps = FLT_EPSILON;
size_t i;
for (i = 0; i < __arraycount(angles); i++) {
-
- x = angles[i].x;
- y = angles[i].y;
-
- if (fabsf(cosf(x) - y) > eps)
- atf_tc_fail_nonfatal("cosf(%d deg) != %0.01f",
- angles[i].angle, angles[i].y);
+ int deg = angles[i].angle;
+ float theta = angles[i].x;
+ float cos_theta = angles[i].fy;
+
+ /*
+ * Force rounding to float even if FLT_EVAL_METHOD=2,
+ * as is the case on i386.
+ *
+ * The volatile should not be necessary, by C99 Sec.
+ * 5.2.4.2.2. para. 8 on p. 24 which specifies that
+ * assignment and cast remove all extra range and precision,
+ * but seems to be needed to work around a compiler bug.
+ */
+ volatile float result = cosf(theta);
+
+ if (cos_theta == 999)
+ cos_theta = angles[i].y;
+
+ assert(cos_theta != 0);
+ if (!(fabsf((result - cos_theta)/cos_theta) <= eps)) {
+ atf_tc_fail_nonfatal("cosf(%d deg = %.8g) = %.8g"
+ " != %.8g", deg, theta, result, cos_theta);
+ }
}
}
@@ -244,6 +372,14 @@ ATF_TC_BODY(cosf_zero_pos, tc)
ATF_TP_ADD_TCS(tp)
{
+#ifdef __HAVE_LONG_DOUBLE
+ ATF_TP_ADD_TC(tp, cosl_angles);
+ ATF_TP_ADD_TC(tp, cosl_nan);
+ ATF_TP_ADD_TC(tp, cosl_inf_neg);
+ ATF_TP_ADD_TC(tp, cosl_inf_pos);
+ ATF_TP_ADD_TC(tp, cosl_zero_neg);
+ ATF_TP_ADD_TC(tp, cosl_zero_pos);
+#endif
ATF_TP_ADD_TC(tp, cos_angles);
ATF_TP_ADD_TC(tp, cos_nan);
diff --git a/contrib/netbsd-tests/lib/libm/t_cosh.c b/contrib/netbsd-tests/lib/libm/t_cosh.c
index 3f998de761bb..aac3a39b0236 100644
--- a/contrib/netbsd-tests/lib/libm/t_cosh.c
+++ b/contrib/netbsd-tests/lib/libm/t_cosh.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_cosh.c,v 1.6 2014/03/03 10:39:08 martin Exp $ */
+/* $NetBSD: t_cosh.c,v 1.7 2018/11/07 03:59:36 riastradh Exp $ */
/*-
* Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,28 +29,28 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
-__RCSID("$NetBSD: t_cosh.c,v 1.6 2014/03/03 10:39:08 martin Exp $");
+__RCSID("$NetBSD: t_cosh.c,v 1.7 2018/11/07 03:59:36 riastradh Exp $");
#include <atf-c.h>
+#include <float.h>
#include <math.h>
#include <stdio.h>
static const struct {
double x;
double y;
- double e;
} values[] = {
- { -10, 11013.23292010332, 1e4, },
- { -2, 3.762195691083631, 1, },
- { -1, 1.543080634815244, 1, },
- { -0.05, 1.001250260438369, 1, },
- { -0.001, 1.000000500000042, 1, },
- { 0, 1, 1, },
- { 0.001, 1.000000500000042, 1, },
- { 0.05, 1.001250260438369, 1, },
- { 1, 1.543080634815244, 1, },
- { 2, 3.762195691083631, 1, },
- { 10, 11013.23292010332, 1e4, },
+ { -10, 11013.232920103323, },
+ { -2, 3.762195691083631, },
+ { -1, 1.543080634815244, },
+ { -0.05, 1.001250260438369, },
+ { -0.001, 1.0000005000000418, },
+ { 0, 1, },
+ { 0.001, 1.0000005000000418, },
+ { 0.05, 1.001250260438369, },
+ { 1, 1.543080634815244, },
+ { 2, 3.762195691083631, },
+ { 10, 11013.232920103323, },
};
/*
@@ -64,18 +64,17 @@ ATF_TC_HEAD(cosh_inrange, tc)
ATF_TC_BODY(cosh_inrange, tc)
{
- double eps;
- double x;
- double y;
+ const double eps = DBL_EPSILON;
size_t i;
for (i = 0; i < __arraycount(values); i++) {
- x = values[i].x;
- y = values[i].y;
- eps = 1e-15 * values[i].e;
+ double x = values[i].x;
+ double cosh_x = values[i].y;
- if (fabs(cosh(x) - y) > eps)
- atf_tc_fail_nonfatal("cosh(%g) != %g\n", x, y);
+ if (!(fabs((cosh(x) - cosh_x)/cosh_x) <= eps)) {
+ atf_tc_fail_nonfatal("cosh(%.17g) = %.17g != %.17g\n",
+ x, cosh(x), cosh_x);
+ }
}
}
@@ -162,18 +161,17 @@ ATF_TC_HEAD(coshf_inrange, tc)
ATF_TC_BODY(coshf_inrange, tc)
{
- float eps;
- float x;
- float y;
+ const float eps = FLT_EPSILON;
size_t i;
for (i = 0; i < __arraycount(values); i++) {
- x = values[i].x;
- y = values[i].y;
- eps = 1e-6 * values[i].e;
+ float x = values[i].x;
+ float cosh_x = values[i].y;
- if (fabsf(coshf(x) - y) > eps)
- atf_tc_fail_nonfatal("coshf(%g) != %g\n", x, y);
+ if (!(fabsf((coshf(x) - cosh_x)/cosh_x) <= eps)) {
+ atf_tc_fail_nonfatal("coshf(%.17g) = %.17g != %.17g\n",
+ x, coshf(x), cosh_x);
+ }
}
}
diff --git a/contrib/netbsd-tests/lib/libm/t_exp.c b/contrib/netbsd-tests/lib/libm/t_exp.c
index 0eb6412b566e..acef4c0e91de 100644
--- a/contrib/netbsd-tests/lib/libm/t_exp.c
+++ b/contrib/netbsd-tests/lib/libm/t_exp.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_exp.c,v 1.8 2014/10/07 16:53:44 gson Exp $ */
+/* $NetBSD: t_exp.c,v 1.9 2018/11/07 03:59:36 riastradh Exp $ */
/*-
* Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -30,6 +30,7 @@
*/
#include <atf-c.h>
+#include <float.h>
#include <math.h>
#include "t_libm.h"
@@ -37,17 +38,16 @@
static const struct {
double x;
double y;
- double e;
} exp_values[] = {
- { -10, 0.4539992976248485e-4, 1e-4, },
- { -5, 0.6737946999085467e-2, 1e-2, },
- { -1, 0.3678794411714423, 1e-1, },
- { -0.1, 0.9048374180359595, 1e-1, },
- { 0, 1.0000000000000000, 1, },
- { 0.1, 1.1051709180756477, 1, },
- { 1, 2.7182818284590452, 1, },
- { 5, 148.41315910257660, 1e2, },
- { 10, 22026.465794806718, 1e4, },
+ { -10, 0.4539992976248485e-4, },
+ { -5, 0.6737946999085467e-2, },
+ { -1, 0.3678794411714423, },
+ { -0.1, 0.9048374180359595, },
+ { 0, 1.0000000000000000, },
+ { 0.1, 1.1051709180756477, },
+ { 1, 2.7182818284590452, },
+ { 5, 148.41315910257660, },
+ { 10, 22026.465794806718, },
};
/*
@@ -238,18 +238,17 @@ ATF_TC_HEAD(exp_product, tc)
ATF_TC_BODY(exp_product, tc)
{
- double eps;
- double x;
- double y;
+ const double eps = DBL_EPSILON;
size_t i;
for (i = 0; i < __arraycount(exp_values); i++) {
- x = exp_values[i].x;
- y = exp_values[i].y;
- eps = 1e-15 * exp_values[i].e;
+ double x = exp_values[i].x;
+ double e_x = exp_values[i].y;
- if (fabs(exp(x) - y) > eps)
- atf_tc_fail_nonfatal("exp(%0.01f) != %18.18e", x, y);
+ if (!(fabs((exp(x) - e_x)/e_x) <= eps)) {
+ atf_tc_fail_nonfatal("exp(%.17g) = %.17g != %.17g",
+ x, exp(x), e_x);
+ }
}
}
@@ -336,18 +335,17 @@ ATF_TC_HEAD(expf_product, tc)
ATF_TC_BODY(expf_product, tc)
{
- float eps;
- float x;
- float y;
+ const float eps = FLT_EPSILON;
size_t i;
for (i = 0; i < __arraycount(exp_values); i++) {
- x = exp_values[i].x;
- y = exp_values[i].y;
- eps = 1e-6 * exp_values[i].e;
+ float x = exp_values[i].x;
+ float e_x = exp_values[i].y;
- if (fabsf(expf(x) - y) > eps)
- atf_tc_fail_nonfatal("expf(%0.01f) != %18.18e", x, y);
+ if (!(fabsf((expf(x) - e_x)/e_x) <= eps)) {
+ atf_tc_fail_nonfatal("expf(%.8g) = %.8g != %.8g",
+ x, exp(x), e_x);
+ }
}
}
diff --git a/contrib/netbsd-tests/lib/libm/t_fe_round.c b/contrib/netbsd-tests/lib/libm/t_fe_round.c
index fe805b4f86b8..33da289eb156 100644
--- a/contrib/netbsd-tests/lib/libm/t_fe_round.c
+++ b/contrib/netbsd-tests/lib/libm/t_fe_round.c
@@ -89,7 +89,97 @@ ATF_TC_BODY(fe_round, tc)
(fegetround() == values[i].round_mode),
"Didn't get the same rounding mode out!\n"
"(index %d) fed in %d rounding mode, got %d out\n",
- i, fegetround(), values[i].round_mode);
+ i, values[i].round_mode, fegetround());
+ }
+}
+
+ATF_TC(fe_nearbyint);
+ATF_TC_HEAD(fe_nearbyint, tc)
+{
+ atf_tc_set_md_var(tc, "descr","Checking IEEE 754 rounding modes using nearbyint");
+}
+
+ATF_TC_BODY(fe_nearbyint, tc)
+{
+ double received;
+
+ for (unsigned int i = 0; i < __arraycount(values); i++) {
+ fesetround(values[i].round_mode);
+
+ received = nearbyint(values[i].input);
+ ATF_CHECK_MSG(
+ (fabs(received - values[i].expected) < EPSILON),
+ "nearbyint rounding wrong, difference too large\n"
+ "input: %f (index %d): got %f, expected %ld\n",
+ values[i].input, i, received, values[i].expected);
+
+ /* Do we get the same rounding mode out? */
+ ATF_CHECK_MSG(
+ (fegetround() == values[i].round_mode),
+ "Didn't get the same rounding mode out!\n"
+ "(index %d) fed in %d rounding mode, got %d out\n",
+ i, values[i].round_mode, fegetround());
+ }
+}
+
+static const struct {
+ double input;
+ double toward;
+ double expected;
+} values2[] = {
+ { 10.0, 11.0, 10.0 },
+ { -5.0, -6.0, -5.0 },
+};
+
+ATF_TC(fe_nextafter);
+ATF_TC_HEAD(fe_nextafter, tc)
+{
+ atf_tc_set_md_var(tc, "descr", "Checking IEEE 754 rounding using nextafter()");
+}
+
+ATF_TC_BODY(fe_nextafter, tc)
+{
+ double received;
+ int res;
+
+ for (unsigned int i = 0; i < __arraycount(values2); i++) {
+ received = nextafter(values2[i].input, values2[i].toward);
+ if (values2[i].input < values2[i].toward) {
+ res = (received > values2[i].input);
+ } else {
+ res = (received < values2[i].input);
+ }
+ ATF_CHECK_MSG(
+ res && (fabs(received - values2[i].expected) < EPSILON),
+ "nextafter() rounding wrong, difference too large\n"
+ "input: %f (index %d): got %f, expected %f, res %d\n",
+ values2[i].input, i, received, values2[i].expected, res);
+ }
+}
+
+ATF_TC(fe_nexttoward);
+ATF_TC_HEAD(fe_nexttoward, tc)
+{
+ atf_tc_set_md_var(tc, "descr", "Checking IEEE 754 rounding using nexttoward()");
+}
+
+ATF_TC_BODY(fe_nexttoward, tc)
+{
+ double received;
+ int res;
+
+ for (unsigned int i = 0; i < __arraycount(values2); i++) {
+ received = nexttoward(values2[i].input, values2[i].toward);
+ if (values2[i].input < values2[i].toward) {
+ res = (received > values2[i].input);
+ } else {
+ res = (received < values2[i].input);
+ }
+ ATF_CHECK_MSG(
+ res && (fabs(received - values2[i].expected) < EPSILON),
+ "nexttoward() rounding wrong, difference too large\n"
+ "input: %f (index %d): got %f, expected %f, res %d\n",
+ values2[i].input, i, received, values2[i].expected, res);
}
}
@@ -97,6 +187,9 @@ ATF_TP_ADD_TCS(tp)
{
ATF_TP_ADD_TC(tp, fe_round);
+ ATF_TP_ADD_TC(tp, fe_nearbyint);
+ ATF_TP_ADD_TC(tp, fe_nextafter);
+ ATF_TP_ADD_TC(tp, fe_nexttoward);
return atf_no_error();
}
@@ -109,15 +202,56 @@ ATF_TC_HEAD(t_nofe_round, tc)
"dummy test case - no fenv.h support");
}
-
ATF_TC_BODY(t_nofe_round, tc)
{
atf_tc_skip("no fenv.h support on this architecture");
}
+ATF_TC(t_nofe_nearbyint);
+
+ATF_TC_HEAD(t_nofe_nearbyint, tc)
+{
+ atf_tc_set_md_var(tc, "descr",
+ "dummy test case - no fenv.h support");
+}
+
+ATF_TC_BODY(t_nofe_nearbyint, tc)
+{
+ atf_tc_skip("no fenv.h support on this architecture");
+}
+
+ATF_TC(t_nofe_nextafter);
+
+ATF_TC_HEAD(t_nofe_nextafter, tc)
+{
+ atf_tc_set_md_var(tc, "descr",
+ "dummy test case - no fenv.h support");
+}
+
+ATF_TC_BODY(t_nofe_nextafter, tc)
+{
+ atf_tc_skip("no fenv.h support on this architecture");
+}
+
+ATF_TC(t_nofe_nexttoward);
+
+ATF_TC_HEAD(t_nofe_nexttoward, tc)
+{
+ atf_tc_set_md_var(tc, "descr",
+ "dummy test case - no fenv.h support");
+}
+
+ATF_TC_BODY(t_nofe_nexttoward, tc)
+{
+ atf_tc_skip("no fenv.h support on this architecture");
+}
+
ATF_TP_ADD_TCS(tp)
{
ATF_TP_ADD_TC(tp, t_nofe_round);
+ ATF_TP_ADD_TC(tp, t_nofe_nearbyint);
+ ATF_TP_ADD_TC(tp, t_nofe_nextafter);
+ ATF_TP_ADD_TC(tp, t_nofe_nexttoward);
return atf_no_error();
}
diff --git a/contrib/netbsd-tests/lib/libm/t_fenv.c b/contrib/netbsd-tests/lib/libm/t_fenv.c
index 544503673a98..613bf3027950 100644
--- a/contrib/netbsd-tests/lib/libm/t_fenv.c
+++ b/contrib/netbsd-tests/lib/libm/t_fenv.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_fenv.c,v 1.3 2015/12/22 14:20:59 christos Exp $ */
+/* $NetBSD: t_fenv.c,v 1.6 2019/04/25 20:48:54 kamil Exp $ */
/*-
* Copyright (c) 2014 The NetBSD Foundation, Inc.
@@ -29,7 +29,7 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
-__RCSID("$NetBSD: t_fenv.c,v 1.3 2015/12/22 14:20:59 christos Exp $");
+__RCSID("$NetBSD: t_fenv.c,v 1.6 2019/04/25 20:48:54 kamil Exp $");
#include <atf-c.h>
@@ -40,15 +40,15 @@ __RCSID("$NetBSD: t_fenv.c,v 1.3 2015/12/22 14:20:59 christos Exp $");
#include <stdlib.h>
-#if __arm__ && !__SOFTFP__
+#if (__arm__ && !__SOFTFP__) || __aarch64__
/*
- * Some NEON fpus do not implement IEEE exception handling,
- * skip these tests if running on them and compiled for
+ * Some NEON fpus do not trap on IEEE 754 FP exceptions.
+ * Skip these tests if running on them and compiled for
* hard float.
*/
#define FPU_EXC_PREREQ() \
if (0 == fpsetmask(fpsetmask(FP_X_INV))) \
- atf_tc_skip("FPU does not implement exception handling");
+ atf_tc_skip("FPU does not implement traps on FP exceptions");
/*
* Same as above: some don't allow configuring the rounding mode.
diff --git a/contrib/netbsd-tests/lib/libm/t_fmod.c b/contrib/netbsd-tests/lib/libm/t_fmod.c
index 2a221f5f62e1..1866c3d23d21 100644
--- a/contrib/netbsd-tests/lib/libm/t_fmod.c
+++ b/contrib/netbsd-tests/lib/libm/t_fmod.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_fmod.c,v 1.3 2015/01/03 14:23:53 gson Exp $ */
+/* $NetBSD: t_fmod.c,v 1.4 2020/08/25 13:39:16 gson Exp $ */
/*-
* Copyright (c) 2013 The NetBSD Foundation, Inc.
@@ -50,21 +50,15 @@ ATF_TC_BODY(fmod, tc)
ATF_CHECK(fmodf(2.0, 1.0) == 0);
ATF_CHECK(fmod(2.0, 1.0) == 0);
-#if !defined(__FreeBSD__) || LDBL_PREC != 53
ATF_CHECK(fmodl(2.0, 1.0) == 0);
-#endif
ATF_CHECK(fmodf(2.0, 0.5) == 0);
ATF_CHECK(fmod(2.0, 0.5) == 0);
-#if !defined(__FreeBSD__) || LDBL_PREC != 53
ATF_CHECK(fmodl(2.0, 0.5) == 0);
-#endif
ATF_CHECK(fabsf(fmodf(1.0, 0.1) - 0.1f) <= 55 * FLT_EPSILON);
ATF_CHECK(fabs(fmod(1.0, 0.1) - 0.1) <= 55 * DBL_EPSILON);
-#if !defined(__FreeBSD__) || LDBL_PREC != 53
ATF_CHECK(fabsl(fmodl(1.0, 0.1L) - 0.1L) <= 55 * LDBL_EPSILON);
-#endif
}
ATF_TP_ADD_TCS(tp)
diff --git a/contrib/netbsd-tests/lib/libm/t_ilogb.c b/contrib/netbsd-tests/lib/libm/t_ilogb.c
index 1d35cb64127b..bbccaca39bc1 100644
--- a/contrib/netbsd-tests/lib/libm/t_ilogb.c
+++ b/contrib/netbsd-tests/lib/libm/t_ilogb.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_ilogb.c,v 1.7 2017/01/13 19:23:40 christos Exp $ */
+/* $NetBSD: t_ilogb.c,v 1.9 2018/06/14 21:57:25 maya Exp $ */
/*-
* Copyright (c) 2016 The NetBSD Foundation, Inc.
@@ -29,7 +29,7 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
-__RCSID("$NetBSD: t_ilogb.c,v 1.7 2017/01/13 19:23:40 christos Exp $");
+__RCSID("$NetBSD: t_ilogb.c,v 1.9 2018/06/14 21:57:25 maya Exp $");
#include <atf-c.h>
#include <fenv.h>
@@ -44,7 +44,9 @@ __RCSID("$NetBSD: t_ilogb.c,v 1.7 2017/01/13 19:23:40 christos Exp $");
#else
# define ATF_CHECK_RAISED_INVALID do { \
int r = fetestexcept(FE_ALL_EXCEPT); \
- ATF_CHECK_MSG(r == FE_INVALID, "r=%#x != %#x\n", r, FE_INVALID); \
+ ATF_CHECK_MSG((r & FE_INVALID) != 0, \
+ "r & FE_INVALID == 0 (r=%#x, FE_INVALID=%#x)\n", \
+ r, FE_INVALID); \
(void)feclearexcept(FE_ALL_EXCEPT); \
} while (/*CONSTCOND*/0)
diff --git a/contrib/netbsd-tests/lib/libm/t_ldexp.c b/contrib/netbsd-tests/lib/libm/t_ldexp.c
index 251f2aeba5fb..977b2219873b 100644
--- a/contrib/netbsd-tests/lib/libm/t_ldexp.c
+++ b/contrib/netbsd-tests/lib/libm/t_ldexp.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_ldexp.c,v 1.16 2016/08/25 00:32:31 maya Exp $ */
+/* $NetBSD: t_ldexp.c,v 1.17 2018/11/07 03:59:36 riastradh Exp $ */
/*-
* Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,14 +29,15 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
-__RCSID("$NetBSD: t_ldexp.c,v 1.16 2016/08/25 00:32:31 maya Exp $");
+__RCSID("$NetBSD: t_ldexp.c,v 1.17 2018/11/07 03:59:36 riastradh Exp $");
#include <sys/param.h>
#include <atf-c.h>
-#include <math.h>
+#include <float.h>
#include <limits.h>
+#include <math.h>
#include <stdio.h>
#include <string.h>
@@ -195,22 +196,17 @@ ATF_TC_HEAD(ldexp_exp2, tc)
ATF_TC_BODY(ldexp_exp2, tc)
{
const double n[] = { 1, 2, 3, 10, 50, 100 };
-#if __DBL_MIN_10_EXP__ <= -40
- const double eps = 1.0e-40;
-#else
- const double eps = __DBL_MIN__*4.0;
-#endif
+ const double eps = DBL_EPSILON;
const double x = 12.0;
- double y;
size_t i;
for (i = 0; i < __arraycount(n); i++) {
+ double y = ldexp(x, n[i]);
- y = ldexp(x, n[i]);
-
- if (fabs(y - (x * exp2(n[i]))) > eps) {
- atf_tc_fail_nonfatal("ldexp(%0.01f, %0.01f) "
- "!= %0.01f * exp2(%0.01f)", x, n[i], x, n[i]);
+ if (!(fabs((y - (x * exp2(n[i])))/y) <= eps)) {
+ atf_tc_fail_nonfatal("ldexp(%.17g, %.17g) = %.17g "
+ "!= %.17g * exp2(%.17g) = %.17g",
+ x, n[i], y, x, n[i], (x * exp2(n[i])));
}
}
}
@@ -320,18 +316,17 @@ ATF_TC_HEAD(ldexpf_exp2f, tc)
ATF_TC_BODY(ldexpf_exp2f, tc)
{
const float n[] = { 1, 2, 3, 10, 50, 100 };
- const float eps = 1.0e-9;
+ const float eps = FLT_EPSILON;
const float x = 12.0;
- float y;
size_t i;
for (i = 0; i < __arraycount(n); i++) {
+ float y = ldexpf(x, n[i]);
- y = ldexpf(x, n[i]);
-
- if (fabsf(y - (x * exp2f(n[i]))) > eps) {
- atf_tc_fail_nonfatal("ldexpf(%0.01f, %0.01f) "
- "!= %0.01f * exp2f(%0.01f)", x, n[i], x, n[i]);
+ if (!(fabsf((y - (x * exp2f(n[i])))/y) <= eps)) {
+ atf_tc_fail_nonfatal("ldexpf(%.17g, %.17g) = %.17g "
+ "!= %.17g * exp2f(%.17g) = %.17g",
+ x, n[i], y, x, n[i], (x * exp2f(n[i])));
}
}
}
diff --git a/contrib/netbsd-tests/lib/libm/t_libm.h b/contrib/netbsd-tests/lib/libm/t_libm.h
index 34e3cb28abf5..0831f22d468d 100644
--- a/contrib/netbsd-tests/lib/libm/t_libm.h
+++ b/contrib/netbsd-tests/lib/libm/t_libm.h
@@ -1,4 +1,4 @@
-/* $NetBSD: t_libm.h,v 1.6 2014/03/25 17:30:14 joerg Exp $ */
+/* $NetBSD: t_libm.h,v 1.7 2018/11/07 03:59:36 riastradh Exp $ */
/*
* Check result of fn(arg) is correct within the bounds.
@@ -11,8 +11,8 @@
long double epsilon = epsilon_; \
long double expect = expect_; \
long double r = fn(arg); \
- long double e = fabsl(r - expect); \
- if (r != expect && e > epsilon) \
+ long double e = fabsl((r - expect)/expect); \
+ if (!(r == expect || e <= epsilon)) \
atf_tc_fail_nonfatal( \
"subtest %u: " #fn "(%g) is %Lg (%.14La) " \
"not %Lg (%.13La), error %Lg (%.6La) > %Lg", \
diff --git a/contrib/netbsd-tests/lib/libm/t_log.c b/contrib/netbsd-tests/lib/libm/t_log.c
index 756efcf39769..41aae4c7c967 100644
--- a/contrib/netbsd-tests/lib/libm/t_log.c
+++ b/contrib/netbsd-tests/lib/libm/t_log.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_log.c,v 1.13 2015/02/09 19:39:48 martin Exp $ */
+/* $NetBSD: t_log.c,v 1.14 2018/11/07 03:59:36 riastradh Exp $ */
/*-
* Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,10 +29,11 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
-__RCSID("$NetBSD: t_log.c,v 1.13 2015/02/09 19:39:48 martin Exp $");
+__RCSID("$NetBSD: t_log.c,v 1.14 2018/11/07 03:59:36 riastradh Exp $");
#include <atf-c.h>
+#include <float.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
@@ -614,10 +615,10 @@ ATF_TC_HEAD(log_base, tc)
ATF_TC_BODY(log_base, tc)
{
- const double eps = 1.0e-38;
+ const double eps = DBL_EPSILON;
- if (fabs(log(M_E) - 1.0) > eps)
- atf_tc_fail_nonfatal("log(e) != 1");
+ if (!(fabs(log(M_E) - 1.0) <= eps))
+ atf_tc_fail_nonfatal("log(e) = %.17g != 1", log(M_E));
}
ATF_TC(log_nan);
@@ -714,10 +715,11 @@ ATF_TC_HEAD(logf_base, tc)
ATF_TC_BODY(logf_base, tc)
{
- const float eps = 1.0e-7;
+ const float eps = FLT_EPSILON;
- if (fabsf(logf(M_E) - 1.0f) > eps)
- atf_tc_fail_nonfatal("logf(e) != 1");
+ if (!(fabsf(logf(M_E) - 1.0f) <= eps))
+ atf_tc_fail_nonfatal("logf(e) = %.17g != 1",
+ (double)logf(M_E));
}
ATF_TC(logf_nan);
diff --git a/contrib/netbsd-tests/lib/libm/t_round.c b/contrib/netbsd-tests/lib/libm/t_round.c
index f47e1a0f8a13..7d32586f1aa5 100644
--- a/contrib/netbsd-tests/lib/libm/t_round.c
+++ b/contrib/netbsd-tests/lib/libm/t_round.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_round.c,v 1.4 2013/11/11 23:57:34 joerg Exp $ */
+/* $NetBSD: t_round.c,v 1.9 2017/09/03 13:41:19 wiz Exp $ */
/*-
* Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -26,9 +26,14 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
+#include <sys/param.h>
+
#include <atf-c.h>
#include <float.h>
#include <math.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <inttypes.h>
/*
* This tests for a bug in the initial implementation where
@@ -76,10 +81,58 @@ ATF_TC_BODY(round_dir, tc)
ATF_CHECK(fabsl(cl) < SMALL_NUM);
}
+ATF_TC(rounding_alpha);
+ATF_TC_HEAD(rounding_alpha, tc)
+{
+ atf_tc_set_md_var(tc, "descr","Checking MPFR's config failure with -mieee on Alpha");
+}
+
+typedef uint64_t gimpy_limb_t;
+#define GIMPY_NUMB_BITS 64
+
+ATF_TC_BODY(rounding_alpha, tc)
+{
+ double d;
+ gimpy_limb_t u;
+ int i;
+
+ d = 1.0;
+ for (i = 0; i < GIMPY_NUMB_BITS - 1; i++)
+ d = d + d;
+
+ printf("d = %g\n", d);
+ u = (gimpy_limb_t) d;
+
+ for (; i > 0; i--) {
+ ATF_CHECK_MSG((u % 2 == 0),
+ "%"PRIu64" is not an even number! (iteration %d)", u , i);
+ u = u >> 1;
+ }
+}
+
+ATF_TC(rounding_alpha_simple);
+ATF_TC_HEAD(rounding_alpha_simple, tc)
+{
+ atf_tc_set_md_var(tc, "descr","Checking double to uint64_t edge case");
+}
+
+
+double rounding_alpha_simple_even = 9223372036854775808.000000; /* 2^63 */
+
+ATF_TC_BODY(rounding_alpha_simple, tc)
+{
+ uint64_t unsigned_even = rounding_alpha_simple_even;
+
+ ATF_CHECK_MSG(unsigned_even % 2 == 0,
+ "2^63 cast to uint64_t is odd (got %"PRIu64")", unsigned_even);
+
+}
ATF_TP_ADD_TCS(tp)
{
ATF_TP_ADD_TC(tp, round_dir);
+ ATF_TP_ADD_TC(tp, rounding_alpha);
+ ATF_TP_ADD_TC(tp, rounding_alpha_simple);
return atf_no_error();
}
diff --git a/contrib/netbsd-tests/lib/libm/t_scalbn.c b/contrib/netbsd-tests/lib/libm/t_scalbn.c
index 4bf00c3415d1..f6adaaa993ec 100644
--- a/contrib/netbsd-tests/lib/libm/t_scalbn.c
+++ b/contrib/netbsd-tests/lib/libm/t_scalbn.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_scalbn.c,v 1.14 2017/01/13 21:09:12 agc Exp $ */
+/* $NetBSD: t_scalbn.c,v 1.16 2018/11/07 03:59:36 riastradh Exp $ */
/*-
* Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,12 +29,13 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
-__RCSID("$NetBSD: t_scalbn.c,v 1.14 2017/01/13 21:09:12 agc Exp $");
+__RCSID("$NetBSD: t_scalbn.c,v 1.16 2018/11/07 03:59:36 riastradh Exp $");
#include <math.h>
#include <limits.h>
#include <float.h>
#include <errno.h>
+#include <fenv.h>
#include <atf-c.h>
@@ -46,16 +47,17 @@ struct testcase {
double inval;
double result;
int error;
+ int except;
};
struct testcase test_vals[] = {
- { 0, 1.00085, 1.00085, 0 },
- { 0, 0.99755, 0.99755, 0 },
- { 0, -1.00085, -1.00085, 0 },
- { 0, -0.99755, -0.99755, 0 },
- { 1, 1.00085, 2.0* 1.00085, 0 },
- { 1, 0.99755, 2.0* 0.99755, 0 },
- { 1, -1.00085, 2.0* -1.00085, 0 },
- { 1, -0.99755, 2.0* -0.99755, 0 },
+ { 0, 1.00085, 1.00085, 0, 0 },
+ { 0, 0.99755, 0.99755, 0, 0 },
+ { 0, -1.00085, -1.00085, 0, 0 },
+ { 0, -0.99755, -0.99755, 0, 0 },
+ { 1, 1.00085, 2.0* 1.00085, 0, 0 },
+ { 1, 0.99755, 2.0* 0.99755, 0, 0 },
+ { 1, -1.00085, 2.0* -1.00085, 0, 0 },
+ { 1, -0.99755, 2.0* -0.99755, 0, 0 },
/*
* We could add more corner test cases here, but we would have to
@@ -82,13 +84,25 @@ ATF_TC_BODY(scalbn_val, tc)
for (i = 0; i < tcnt; i++) {
errno = 0;
+#ifndef __vax__
+ feclearexcept(FE_ALL_EXCEPT);
+#endif
rv = scalbn(tests[i].inval, tests[i].exp);
ATF_CHECK_EQ_MSG(errno, tests[i].error,
"test %zu: errno %d instead of %d", i, errno,
tests[i].error);
- ATF_CHECK_MSG(fabs(rv-tests[i].result)<2.0*DBL_EPSILON,
- "test %zu: return value %g instead of %g (difference %g)",
- i, rv, tests[i].result, tests[i].result-rv);
+#ifndef __vax__
+ ATF_CHECK_EQ_MSG(errno, tests[i].error,
+ "test %zu: fetestexcept %d instead of %d", i,
+ fetestexcept(FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW | FE_UNDERFLOW),
+ tests[i].except);
+#endif
+ /* scalbn is always exact except for underflow or overflow. */
+ ATF_CHECK_MSG(rv == tests[i].result,
+ "test %zu: return value %.17g instead of %.17g"
+ " (error %.17g)",
+ i, rv, tests[i].result,
+ fabs((tests[i].result - rv)/tests[i].result));
}
}
@@ -228,9 +242,12 @@ ATF_TC_BODY(scalbnf_val, tc)
ATF_CHECK_EQ_MSG(errno, tests[i].error,
"test %zu: errno %d instead of %d", i, errno,
tests[i].error);
- ATF_CHECK_MSG(fabs(rv-tests[i].result)<2.0*FLT_EPSILON,
- "test %zu: return value %g instead of %g (difference %g)",
- i, rv, tests[i].result, tests[i].result-rv);
+ /* scalbn is always exact except for underflow or overflow. */
+ ATF_CHECK_MSG(rv == (float)tests[i].result,
+ "test %zu: return value %.8g instead of %.8g"
+ " (error %.8g)",
+ i, rv, tests[i].result,
+ fabs((tests[i].result - rv)/tests[i].result));
}
}
@@ -373,9 +390,12 @@ ATF_TC_BODY(scalbnl_val, tc)
ATF_CHECK_EQ_MSG(errno, tests[i].error,
"test %zu: errno %d instead of %d", i, errno,
tests[i].error);
- ATF_CHECK_MSG(fabsl(rv-(long double)tests[i].result)<2.0*LDBL_EPSILON,
- "test %zu: return value %Lg instead of %Lg (difference %Lg)",
- i, rv, (long double)tests[i].result, (long double)tests[i].result-rv);
+ /* scalbn is always exact except for underflow or overflow. */
+ ATF_CHECK_MSG(rv == (long double)tests[i].result,
+ "test %zu: return value %.35Lg instead of %.35Lg"
+ " (error %.35Lg)",
+ i, rv, (long double)tests[i].result,
+ fabsl(((long double)tests[i].result - rv)/tests[i].result));
}
#endif
}
diff --git a/contrib/netbsd-tests/lib/libm/t_sin.c b/contrib/netbsd-tests/lib/libm/t_sin.c
index a82f49dc65d6..ca581f03fad0 100644
--- a/contrib/netbsd-tests/lib/libm/t_sin.c
+++ b/contrib/netbsd-tests/lib/libm/t_sin.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_sin.c,v 1.4 2014/03/03 10:39:08 martin Exp $ */
+/* $NetBSD: t_sin.c,v 1.7 2019/05/27 00:24:37 maya Exp $ */
/*-
* Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,29 +29,33 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
+#include <assert.h>
#include <atf-c.h>
+#include <float.h>
#include <math.h>
static const struct {
int angle;
double x;
double y;
+ float fy;
} angles[] = {
- { -180, -3.141592653589793, 0.0000000000000000 },
- { -135, -2.356194490192345, -0.7071067811865476 },
- { -90, -1.570796326794897, -1.0000000000000000 },
- { -45, -0.785398163397448, -0.7071067811865476 },
- { 0, 0.000000000000000, 0.0000000000000000 },
- { 30, 0.523598775598299, 0.5000000000000000 },
- { 45, 0.785398163397448, 0.7071067811865476 },
- { 60, 1.047197551196598, 0.8660254037844386 },
- { 90, 1.570796326794897, 1.0000000000000000 },
- { 120, 2.094395102393195, 0.8660254037844386 },
- { 135, 2.356194490192345, 0.7071067811865476 },
- { 150, 2.617993877991494, 0.5000000000000000 },
- { 180, 3.141592653589793, 0.0000000000000000 },
- { 270, 4.712388980384690, -1.0000000000000000 },
- { 360, 6.283185307179586, 0.0000000000000000 }
+ { -360, -6.283185307179586, 2.4492935982947064e-16, -1.7484555e-07 },
+ { -180, -3.141592653589793, -1.2246467991473532e-16, 8.7422777e-08 },
+ { -135, -2.356194490192345, -0.7071067811865476, 999 },
+ { -90, -1.570796326794897, -1.0000000000000000, 999 },
+ { -45, -0.785398163397448, -0.7071067811865472, 999 },
+ { 0, 0.000000000000000, 0.0000000000000000, 999 },
+ { 30, 0.5235987755982989, 0.5000000000000000, 999 },
+ { 45, 0.785398163397448, 0.7071067811865472, 999 },
+ { 60, 1.047197551196598, 0.8660254037844388, 999 },
+ { 90, 1.570796326794897, 1.0000000000000000, 999 },
+ { 120, 2.094395102393195, 0.8660254037844389, 999 },
+ { 135, 2.356194490192345, 0.7071067811865476, 999 },
+ { 150, 2.617993877991494, 0.5000000000000003, 999 },
+ { 180, 3.141592653589793, 1.2246467991473532e-16, -8.7422777e-08 },
+ { 270, 4.712388980384690, -1.0000000000000000, 999 },
+ { 360, 6.283185307179586, -2.4492935982947064e-16, 1.7484555e-07 },
};
/*
@@ -65,14 +69,29 @@ ATF_TC_HEAD(sin_angles, tc)
ATF_TC_BODY(sin_angles, tc)
{
- const double eps = 1.0e-15;
+ const double eps = DBL_EPSILON;
size_t i;
for (i = 0; i < __arraycount(angles); i++) {
-
- if (fabs(sin(angles[i].x) - angles[i].y) > eps)
- atf_tc_fail_nonfatal("sin(%d deg) != %0.01f",
- angles[i].angle, angles[i].y);
+ int deg = angles[i].angle;
+ double theta = angles[i].x;
+ double sin_theta = angles[i].y;
+ bool ok;
+
+ if (sin_theta == 0) {
+ /* Should be computed exactly. */
+ assert(sin_theta == 0);
+ ok = (sin(theta) == 0);
+ } else {
+ assert(sin_theta != 0);
+ ok = (fabs((sin(theta) - sin_theta)/sin_theta) <= eps);
+ }
+
+ if (!ok) {
+ atf_tc_fail_nonfatal("sin(%d deg = %.17g) = %.17g"
+ " != %.17g",
+ deg, theta, sin(theta), sin_theta);
+ }
}
}
@@ -154,18 +173,30 @@ ATF_TC_HEAD(sinf_angles, tc)
ATF_TC_BODY(sinf_angles, tc)
{
- const float eps = 1.0e-6;
- float x, y;
+ const float eps = FLT_EPSILON;
size_t i;
for (i = 0; i < __arraycount(angles); i++) {
-
- x = angles[i].x;
- y = angles[i].y;
-
- if (fabsf(sinf(x) - y) > eps)
- atf_tc_fail_nonfatal("sinf(%d deg) != %0.01f",
- angles[i].angle, angles[i].y);
+ int deg = angles[i].angle;
+ float theta = angles[i].x;
+ float sin_theta = angles[i].fy;
+ bool ok;
+
+ if (sin_theta == 999)
+ sin_theta = angles[i].y;
+
+ if (sin_theta == 0) {
+ /* Should be computed exactly. */
+ ok = (sinf(theta) == 0);
+ } else {
+ ok = (fabsf((sinf(theta) - sin_theta)/sin_theta)
+ <= eps);
+ }
+
+ if (!ok) {
+ atf_tc_fail_nonfatal("sinf(%d deg) = %.8g != %.8g",
+ deg, sinf(theta), sin_theta);
+ }
}
}
diff --git a/contrib/netbsd-tests/lib/libm/t_sinh.c b/contrib/netbsd-tests/lib/libm/t_sinh.c
index d935f0ea7ffb..d5f764fea573 100644
--- a/contrib/netbsd-tests/lib/libm/t_sinh.c
+++ b/contrib/netbsd-tests/lib/libm/t_sinh.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_sinh.c,v 1.6 2014/03/03 10:39:08 martin Exp $ */
+/* $NetBSD: t_sinh.c,v 1.7 2018/11/07 03:59:36 riastradh Exp $ */
/*-
* Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,27 +29,27 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
-__RCSID("$NetBSD: t_sinh.c,v 1.6 2014/03/03 10:39:08 martin Exp $");
+__RCSID("$NetBSD: t_sinh.c,v 1.7 2018/11/07 03:59:36 riastradh Exp $");
#include <atf-c.h>
+#include <float.h>
#include <math.h>
#include <stdio.h>
static const struct {
double x;
double y;
- double e;
} values[] = {
- { -10, -11013.23287470339, 1e4, },
- { -2, -3.626860407847019, 1, },
- { -1, -1.175201193643801, 1, },
- { -0.05, -0.050020835937655, 1, },
- { -0.001,-0.001000000166667, 1, },
- { 0.001, 0.001000000166667, 1, },
- { 0.05, 0.050020835937655, 1, },
- { 1, 1.175201193643801, 1, },
- { 2, 3.626860407847019, 1, },
- { 10, 11013.23287470339, 1e4, },
+ { -10, -11013.232874703393, },
+ { -2, -3.626860407847019, },
+ { -1, -1.1752011936438014, },
+ { -0.05, -0.050020835937655016, },
+ { -0.001,-0.0010000001666666751, },
+ { 0.001, 0.0010000001666666751, },
+ { 0.05, 0.050020835937655016, },
+ { 1, 1.1752011936438014, },
+ { 2, 3.626860407847019, },
+ { 10, 11013.232874703393, },
};
/*
@@ -63,18 +63,17 @@ ATF_TC_HEAD(sinh_inrange, tc)
ATF_TC_BODY(sinh_inrange, tc)
{
- double eps;
- double x;
- double y;
+ const double eps = DBL_EPSILON;
size_t i;
for (i = 0; i < __arraycount(values); i++) {
- x = values[i].x;
- y = values[i].y;
- eps = 1e-15 * values[i].e;
+ double x = values[i].x;
+ double sinh_x = values[i].y;
- if (fabs(sinh(x) - y) > eps)
- atf_tc_fail_nonfatal("sinh(%g) != %g\n", x, y);
+ if (!(fabs((sinh(x) - sinh_x)/sinh_x) <= eps)) {
+ atf_tc_fail_nonfatal("sinh(%.17g) = %.17g != %.17g\n",
+ x, sinh(x), sinh_x);
+ }
}
}
@@ -163,18 +162,17 @@ ATF_TC_HEAD(sinhf_inrange, tc)
ATF_TC_BODY(sinhf_inrange, tc)
{
- float eps;
- float x;
- float y;
+ const float eps = FLT_EPSILON;
size_t i;
for (i = 0; i < __arraycount(values); i++) {
- x = values[i].x;
- y = values[i].y;
- eps = 1e-6 * values[i].e;
+ float x = values[i].x;
+ float sinh_x = values[i].y;
- if (fabsf(sinhf(x) - y) > eps)
- atf_tc_fail_nonfatal("sinhf(%g) != %g\n", x, y);
+ if (!(fabsf((sinhf(x) - sinh_x)/sinh_x) <= eps)) {
+ atf_tc_fail_nonfatal("sinhf(%.8g) = %.8g != %.8g\n",
+ (double)x, (double)sinhf(x), (double)sinh_x);
+ }
}
}
diff --git a/contrib/netbsd-tests/lib/libm/t_sqrt.c b/contrib/netbsd-tests/lib/libm/t_sqrt.c
index 1d551ec3101d..080aff1c40e8 100644
--- a/contrib/netbsd-tests/lib/libm/t_sqrt.c
+++ b/contrib/netbsd-tests/lib/libm/t_sqrt.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_sqrt.c,v 1.7 2014/03/12 21:40:07 martin Exp $ */
+/* $NetBSD: t_sqrt.c,v 1.8 2018/11/07 03:59:36 riastradh Exp $ */
/*-
* Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,7 +29,7 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
-__RCSID("$NetBSD: t_sqrt.c,v 1.7 2014/03/12 21:40:07 martin Exp $");
+__RCSID("$NetBSD: t_sqrt.c,v 1.8 2018/11/07 03:59:36 riastradh Exp $");
#include <atf-c.h>
#include <math.h>
@@ -62,22 +62,25 @@ ATF_TC_HEAD(sqrt_pow, tc)
ATF_TC_BODY(sqrt_pow, tc)
{
const double x[] = { 0.0, 0.005, 1.0, 99.0, 123.123, 9999.9999 };
-#if __DBL_MIN_10_EXP__ <= -40
- const double eps = 1.0e-40;
-#else
- const double eps = __DBL_MIN__*4.0;
-#endif
- double y, z;
+ const double eps = DBL_EPSILON;
size_t i;
for (i = 0; i < __arraycount(x); i++) {
-
- y = sqrt(x[i]);
- z = pow(x[i], 1.0 / 2.0);
-
- if (fabs(y - z) > eps)
- atf_tc_fail_nonfatal("sqrt(%0.03f) != "
- "pow(%0.03f, 1/2)\n", x[i], x[i]);
+ double x_sqrt = sqrt(x[i]);
+ double x_pow12 = pow(x[i], 1.0 / 2.0);
+ bool ok;
+
+ if (x[i] == 0) {
+ ok = (x_sqrt == x_pow12);
+ } else {
+ ok = (fabs((x_sqrt - x_pow12)/x_sqrt) <= eps);
+ }
+
+ if (!ok) {
+ atf_tc_fail_nonfatal("sqrt(%.17g) = %.17g != "
+ "pow(%.17g, 1/2) = %.17g\n",
+ x[i], x_sqrt, x[i], x_pow12);
+ }
}
}
@@ -166,18 +169,26 @@ ATF_TC_HEAD(sqrtf_powf, tc)
ATF_TC_BODY(sqrtf_powf, tc)
{
const float x[] = { 0.0, 0.005, 1.0, 99.0, 123.123, 9999.9999 };
- const float eps = 1.0e-30;
- volatile float y, z;
+ const float eps = FLT_EPSILON;
size_t i;
for (i = 0; i < __arraycount(x); i++) {
-
- y = sqrtf(x[i]);
- z = powf(x[i], 1.0 / 2.0);
-
- if (fabsf(y - z) > eps)
- atf_tc_fail_nonfatal("sqrtf(%0.03f) != "
- "powf(%0.03f, 1/2)\n", x[i], x[i]);
+ float x_sqrt = sqrtf(x[i]);
+ float x_pow12 = powf(x[i], 1.0 / 2.0);
+ bool ok;
+
+ if (x[i] == 0) {
+ ok = (x_sqrt == x_pow12);
+ } else {
+ ok = (fabsf((x_sqrt - x_pow12)/x_sqrt) <= eps);
+ }
+
+ if (!ok) {
+ atf_tc_fail_nonfatal("sqrtf(%.8g) = %.8g != "
+ "powf(%.8g, 1/2) = %.8g\n",
+ (double)x[i], (double)x_sqrt,
+ (double)x[i], (double)x_pow12);
+ }
}
}
@@ -266,18 +277,25 @@ ATF_TC_HEAD(sqrtl_powl, tc)
ATF_TC_BODY(sqrtl_powl, tc)
{
const long double x[] = { 0.0, 0.005, 1.0, 99.0, 123.123, 9999.9999 };
- const long double eps = 5.0*DBL_EPSILON; /* XXX powl == pow for now */
- volatile long double y, z;
+ const long double eps = DBL_EPSILON; /* XXX powl == pow for now */
size_t i;
for (i = 0; i < __arraycount(x); i++) {
-
- y = sqrtl(x[i]);
- z = powl(x[i], 1.0 / 2.0);
-
- if (fabsl(y - z) > eps)
- atf_tc_fail_nonfatal("sqrtl(%0.03Lf) != "
- "powl(%0.03Lf, 1/2)\n", x[i], x[i]);
+ long double x_sqrt = sqrtl(x[i]);
+ long double x_pow12 = powl(x[i], 1.0 / 2.0);
+ bool ok;
+
+ if (x[i] == 0) {
+ ok = (x_sqrt == x_pow12);
+ } else {
+ ok = (fabsl((x_sqrt - x_pow12)/x_sqrt) <= eps);
+ }
+
+ if (!ok) {
+ atf_tc_fail_nonfatal("sqrtl(%.35Lg) = %.35Lg != "
+ "powl(%.35Lg, 1/2) = %.35Lg\n",
+ x[i], x_sqrt, x[i], x_pow12);
+ }
}
}
diff --git a/contrib/netbsd-tests/lib/libm/t_tan.c b/contrib/netbsd-tests/lib/libm/t_tan.c
index 807e3d1f3364..1bbc4b4d4c95 100644
--- a/contrib/netbsd-tests/lib/libm/t_tan.c
+++ b/contrib/netbsd-tests/lib/libm/t_tan.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_tan.c,v 1.5 2014/03/03 10:39:08 martin Exp $ */
+/* $NetBSD: t_tan.c,v 1.7 2018/11/07 04:00:13 riastradh Exp $ */
/*-
* Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,26 +29,29 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
+#include <assert.h>
#include <atf-c.h>
+#include <float.h>
#include <math.h>
static const struct {
int angle;
double x;
double y;
+ float fy;
} angles[] = {
- { -180, -3.141592653589793, 0.0000000000000000 },
- { -135, -2.356194490192345, 1.0000000000000000 },
- { -45, -0.785398163397448, -1.0000000000000000 },
- { 0, 0.000000000000000, 0.0000000000000000 },
- { 30, 0.523598775598299, 0.5773502691896258 },
- { 45, 0.785398163397448, 1.0000000000000000 },
- { 60, 1.047197551196598, 1.7320508075688773 },
- { 120, 2.094395102393195, -1.7320508075688773 },
- { 135, 2.356194490192345, -1.0000000000000000 },
- { 150, 2.617993877991494, -0.5773502691896258 },
- { 180, 3.141592653589793, 0.0000000000000000 },
- { 360, 6.283185307179586, 0.0000000000000000 }
+ { -180, -3.141592653589793, 1.2246467991473532e-16, -8.7422777e-08 },
+ { -135, -2.356194490192345, 1.0000000000000002, 999 },
+ { -45, -0.785398163397448, -0.9999999999999992, 999 },
+ { 0, 0.000000000000000, 0.0000000000000000, 999 },
+ { 30, 0.5235987755982988, 0.57735026918962573, 999 },
+ { 45, 0.785398163397448, 0.9999999999999992, 999 },
+ { 60, 1.047197551196598, 1.7320508075688785, 1.7320509 },
+ { 120, 2.094395102393195, -1.7320508075688801, -1.7320505 },
+ { 135, 2.356194490192345, -1.0000000000000002, 999 },
+ { 150, 2.617993877991494, -0.57735026918962629, -0.57735032 },
+ { 180, 3.141592653589793, -1.2246467991473532e-16, 8.7422777e-08 },
+ { 360, 6.283185307179586, -2.4492935982947064e-16, 1.7484555e-07 },
};
/*
@@ -62,14 +65,29 @@ ATF_TC_HEAD(tan_angles, tc)
ATF_TC_BODY(tan_angles, tc)
{
- const double eps = 1.0e-14;
+ const double eps = DBL_EPSILON;
size_t i;
for (i = 0; i < __arraycount(angles); i++) {
-
- if (fabs(tan(angles[i].x) - angles[i].y) > eps)
- atf_tc_fail_nonfatal("tan(%d deg) != %0.01f",
- angles[i].angle, angles[i].y);
+ int deg = angles[i].angle;
+ double theta = angles[i].x;
+ double tan_theta = angles[i].y;
+ bool ok;
+
+ if (theta == 0) {
+ /* Should be computed exactly. */
+ assert(tan_theta == 0);
+ ok = (tan(theta) == 0);
+ } else {
+ assert(tan_theta != 0);
+ ok = (fabs((tan(theta) - tan_theta)/tan_theta) <= eps);
+ }
+
+ if (!ok) {
+ atf_tc_fail_nonfatal("tan(%d deg = %.17g) = %.17g"
+ " != %.17g",
+ deg, theta, tan(theta), tan_theta);
+ }
}
}
@@ -151,18 +169,32 @@ ATF_TC_HEAD(tanf_angles, tc)
ATF_TC_BODY(tanf_angles, tc)
{
- const float eps = 1.0e-6;
- float x, y;
+ const float eps = FLT_EPSILON;
size_t i;
for (i = 0; i < __arraycount(angles); i++) {
-
- x = angles[i].x;
- y = angles[i].y;
-
- if (fabsf(tanf(x) - y) > eps)
- atf_tc_fail_nonfatal("tanf(%d deg) != %0.01f",
- angles[i].angle, angles[i].y);
+ int deg = angles[i].angle;
+ float theta = angles[i].x;
+ float tan_theta = angles[i].fy;
+ bool ok;
+
+ if (tan_theta == 999)
+ tan_theta = angles[i].y;
+
+ if (theta == 0) {
+ /* Should be computed exactly. */
+ assert(tan_theta == 0);
+ ok = (tan(theta) == 0);
+ } else {
+ assert(tan_theta != 0);
+ ok = (fabsf((tanf(theta) - tan_theta)/tan_theta)
+ <= eps);
+ }
+
+ if (!ok) {
+ atf_tc_fail_nonfatal("tanf(%d deg) = %.8g != %.8g",
+ deg, tanf(theta), tan_theta);
+ }
}
}
diff --git a/lib/msun/tests/Makefile b/lib/msun/tests/Makefile
index 67a38855309e..d58333271e9b 100644
--- a/lib/msun/tests/Makefile
+++ b/lib/msun/tests/Makefile
@@ -22,6 +22,8 @@ CFLAGS+= -D__HAVE_LONG_DOUBLE
NETBSD_ATF_TESTS_C= acos_test
NETBSD_ATF_TESTS_C+= asin_test
NETBSD_ATF_TESTS_C+= atan_test
+NETBSD_ATF_TESTS_C+= bit_test
+# TODO: NETBSD_ATF_TESTS_CXX+= cabsl_test
NETBSD_ATF_TESTS_C+= cbrt_test
NETBSD_ATF_TESTS_C+= ceil_test
NETBSD_ATF_TESTS_C+= casinh_test