1 /* $NetBSD: t_exp.c,v 1.7 2014/03/17 11:08:11 martin Exp $ */
4 * Copyright (c) 2011 The NetBSD Foundation, Inc.
7 * This code is derived from software contributed to The NetBSD Foundation
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
42 { -10, 0.4539992976248485e-4, 1e-4, },
43 { -5, 0.6737946999085467e-2, 1e-2, },
44 { -1, 0.3678794411714423, 1e-1, },
45 { -0.1, 0.9048374180359595, 1e-1, },
46 { 0, 1.0000000000000000, 1, },
47 { 0.1, 1.1051709180756477, 1, },
48 { 1, 2.7182818284590452, 1, },
49 { 5, 148.41315910257660, 1e2, },
50 { 10, 22026.465794806718, 1e4, },
56 ATF_LIBM_TEST(exp2_is_nan, "Test exp2(x) == NaN")
59 T_LIBM_CHECK_NAN(0, exp2, T_LIBM_NAN);
60 T_LIBM_CHECK_NAN(0, exp2f, T_LIBM_NAN);
62 atf_tc_skip("no NaN on this machine");
66 ATF_LIBM_TEST(exp2_is_plus_zero, "Test exp2(x) == +0.0")
68 #ifdef T_LIBM_MINUS_INF
69 T_LIBM_CHECK_PLUS_ZERO(0, exp2, T_LIBM_MINUS_INF);
70 T_LIBM_CHECK_PLUS_ZERO(0, exp2f, T_LIBM_MINUS_INF);
72 atf_tc_skip("no +/-Inf on this machine");
76 ATF_LIBM_TEST(exp2_powers, "Test exp2(x) is correct for some integer x")
87 { 100, 0x1p100, 0x1p100 },
88 { 125, 0x1p125, 0x1p125 },
89 { 126, 0x1p126, 0x1p126 },
90 #if __DBL_MAX_EXP__ > 129
91 { 127, 0x1p127, 0x1p127 },
93 #ifdef T_LIBM_PLUS_INF
94 { 128, 0x1p128, T_LIBM_PLUS_INF },
95 { 129, 0x1p129, T_LIBM_PLUS_INF },
96 { 1000, 0x1p1000, T_LIBM_PLUS_INF },
97 { 1020, 0x1p1020, T_LIBM_PLUS_INF },
98 { 1023, 0x1p1023, T_LIBM_PLUS_INF },
99 { 1024, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF },
100 { 1030, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF },
101 { 1050, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF },
102 { 2000, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF },
103 { 16383, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF },
104 { 16384, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF },
105 { 16385, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF },
107 { -1, 0x1p-1, 0x1p-1 },
108 { -2, 0x1p-2, 0x1p-2 },
109 { -100, 0x1p-100, 0x1p-100 },
110 { -127, 0x1p-127, 0x1p-127 },
111 { -128, 0x1p-128, 0x1p-128 },
112 #if __LDBL_MIN_EXP__ < -129
113 { -300, 0x1p-300, 0.0},
114 { -400, 0x1p-400, 0.0},
115 {-1000, 0x1p-1000, 0.0},
116 {-1022, 0x1p-1022, 0.0},
117 /* These should be denormal numbers */
118 {-1023, 0x1p-1023, 0.0},
119 {-1024, 0x1p-1024, 0.0},
120 {-1040, 0x1p-1040, 0.0},
121 {-1060, 0x1p-1060, 0.0},
122 /* This is the smallest result gcc will allow */
123 {-1074, 0x1p-1074, 0.0},
134 #if defined(__FreeBSD__) && defined(__i386__)
135 atf_tc_expect_fail("a number of the assertions fail on i386");
138 for (i = 0; i < __arraycount(v); i++) {
139 T_LIBM_CHECK(i, exp2, v[i].x, v[i].d_y, 0.0);
140 T_LIBM_CHECK(i, exp2f, v[i].x, v[i].f_y, 0.0);
144 ATF_LIBM_TEST(exp2_values, "Test exp2(x) is correct for some x")
146 static const struct {
152 #if __DBL_MAX_EXP__ > 128
153 /* The largest double constant */
154 { 0x1.fffffffffffffp9, 0x1.ffffffffffd3ap1023,
156 /* The largest float constant */
157 { 0x1.fffffep6, 0x1.ffff4ep+127, 6e30, 0.0 },
159 #ifdef T_LIBM_PLUS_INF
160 { T_LIBM_PLUS_INF, T_LIBM_PLUS_INF, 0.0, 0.0 },
163 /* The few values from the old tests */
164 /* Results from i386/amd64, d_eps needed on i386 */
165 { 1.1, 0x1.125fbee250664p+1, 0x1p-52, 0x1.8p-22 },
166 { 2.2, 0x1.2611186bae675p+2, 0x1p-51, 0x1.8p-21 },
167 { 3.3, 0x1.3b2c47bff8328p+3, 0x1p-50, 0x1.8p-20 },
168 { 4.4, 0x1.51cb453b9536ep+4, 0x1p-49, 0x1.8p-19 },
169 { 5.5, 0x1.6a09e667f3bcdp+5, 0x1p-48, 0x1.8p-18 },
170 { 6.6, 0x1.8406003b2ae5bp+6, 0x1p-47, 0x1.8p-17 },
172 * These two currently fail for 'float'.
173 * 8.8 is definitely out by more than it should be.
175 { 7.7, 0x1.9fdf8bcce533ep+7, 0x1p-46, 0x1.8p-16 },
176 { 8.8, 0x1.bdb8cdadbe124p+8, 0x1p-45, 0x1.8p-15 },
181 atf_tc_expect_fail("Some of the cases produce failures on FreeBSD "
182 "due to the error epsilon being so small");
185 for (i = 0; i < __arraycount(v); i++) {
186 T_LIBM_CHECK(i, exp2, v[i].x, v[i].y, v[i].d_eps);
188 T_LIBM_CHECK(i, exp2f, v[i].x, v[i].y, v[i].f_eps);
197 ATF_TC_HEAD(exp_nan, tc)
199 atf_tc_set_md_var(tc, "descr", "Test exp(NaN) == NaN");
202 ATF_TC_BODY(exp_nan, tc)
204 const double x = 0.0L / 0.0L;
206 if (isnan(exp(x)) == 0)
207 atf_tc_fail_nonfatal("exp(NaN) != NaN");
211 ATF_TC_HEAD(exp_inf_neg, tc)
213 atf_tc_set_md_var(tc, "descr", "Test exp(-Inf) == +0.0");
216 ATF_TC_BODY(exp_inf_neg, tc)
218 const double x = -1.0L / 0.0L;
221 if (fabs(y) > 0.0 || signbit(y) != 0)
222 atf_tc_fail_nonfatal("exp(-Inf) != +0.0");
226 ATF_TC_HEAD(exp_inf_pos, tc)
228 atf_tc_set_md_var(tc, "descr", "Test exp(+Inf) == +Inf");
231 ATF_TC_BODY(exp_inf_pos, tc)
233 const double x = 1.0L / 0.0L;
236 if (isinf(y) == 0 || signbit(y) != 0)
237 atf_tc_fail_nonfatal("exp(+Inf) != +Inf");
241 ATF_TC_HEAD(exp_product, tc)
243 atf_tc_set_md_var(tc, "descr", "Test some selected exp(x)");
246 ATF_TC_BODY(exp_product, tc)
253 for (i = 0; i < __arraycount(exp_values); i++) {
256 eps = 1e-15 * exp_values[i].e;
258 if (fabs(exp(x) - y) > eps)
259 atf_tc_fail_nonfatal("exp(%0.01f) != %18.18e", x, y);
263 ATF_TC(exp_zero_neg);
264 ATF_TC_HEAD(exp_zero_neg, tc)
266 atf_tc_set_md_var(tc, "descr", "Test exp(-0.0) == 1.0");
269 ATF_TC_BODY(exp_zero_neg, tc)
271 const double x = -0.0L;
273 if (fabs(exp(x) - 1.0) > 0.0)
274 atf_tc_fail_nonfatal("exp(-0.0) != 1.0");
277 ATF_TC(exp_zero_pos);
278 ATF_TC_HEAD(exp_zero_pos, tc)
280 atf_tc_set_md_var(tc, "descr", "Test exp(+0.0) == 1.0");
283 ATF_TC_BODY(exp_zero_pos, tc)
285 const double x = 0.0L;
287 if (fabs(exp(x) - 1.0) > 0.0)
288 atf_tc_fail_nonfatal("exp(+0.0) != 1.0");
295 ATF_TC_HEAD(expf_nan, tc)
297 atf_tc_set_md_var(tc, "descr", "Test expf(NaN) == NaN");
300 ATF_TC_BODY(expf_nan, tc)
302 const float x = 0.0L / 0.0L;
304 if (isnan(expf(x)) == 0)
305 atf_tc_fail_nonfatal("expf(NaN) != NaN");
308 ATF_TC(expf_inf_neg);
309 ATF_TC_HEAD(expf_inf_neg, tc)
311 atf_tc_set_md_var(tc, "descr", "Test expf(-Inf) == +0.0");
314 ATF_TC_BODY(expf_inf_neg, tc)
316 const float x = -1.0L / 0.0L;
319 if (fabsf(y) > 0.0 || signbit(y) != 0)
320 atf_tc_fail_nonfatal("expf(-Inf) != +0.0");
323 ATF_TC(expf_inf_pos);
324 ATF_TC_HEAD(expf_inf_pos, tc)
326 atf_tc_set_md_var(tc, "descr", "Test expf(+Inf) == +Inf");
329 ATF_TC_BODY(expf_inf_pos, tc)
331 const float x = 1.0L / 0.0L;
334 if (isinf(y) == 0 || signbit(y) != 0)
335 atf_tc_fail_nonfatal("expf(+Inf) != +Inf");
338 ATF_TC(expf_product);
339 ATF_TC_HEAD(expf_product, tc)
341 atf_tc_set_md_var(tc, "descr", "Test some selected expf(x)");
344 ATF_TC_BODY(expf_product, tc)
351 for (i = 0; i < __arraycount(exp_values); i++) {
354 eps = 1e-6 * exp_values[i].e;
356 if (fabsf(expf(x) - y) > eps)
357 atf_tc_fail_nonfatal("expf(%0.01f) != %18.18e", x, y);
361 ATF_TC(expf_zero_neg);
362 ATF_TC_HEAD(expf_zero_neg, tc)
364 atf_tc_set_md_var(tc, "descr", "Test expf(-0.0) == 1.0");
367 ATF_TC_BODY(expf_zero_neg, tc)
369 const float x = -0.0L;
371 if (fabsf(expf(x) - 1.0f) > 0.0)
372 atf_tc_fail_nonfatal("expf(-0.0) != 1.0");
375 ATF_TC(expf_zero_pos);
376 ATF_TC_HEAD(expf_zero_pos, tc)
378 atf_tc_set_md_var(tc, "descr", "Test expf(+0.0) == 1.0");
381 ATF_TC_BODY(expf_zero_pos, tc)
383 const float x = 0.0L;
385 if (fabsf(expf(x) - 1.0f) > 0.0)
386 atf_tc_fail_nonfatal("expf(+0.0) != 1.0");
393 ATF_TC_HEAD(expm1_nan, tc)
395 atf_tc_set_md_var(tc, "descr", "Test expm1(NaN) == NaN");
398 ATF_TC_BODY(expm1_nan, tc)
400 const double x = 0.0L / 0.0L;
402 if (isnan(expm1(x)) == 0)
403 atf_tc_fail_nonfatal("expm1(NaN) != NaN");
406 ATF_TC(expm1_inf_neg);
407 ATF_TC_HEAD(expm1_inf_neg, tc)
409 atf_tc_set_md_var(tc, "descr", "Test expm1(-Inf) == -1");
412 ATF_TC_BODY(expm1_inf_neg, tc)
414 const double x = -1.0L / 0.0L;
416 if (expm1(x) != -1.0)
417 atf_tc_fail_nonfatal("expm1(-Inf) != -1.0");
420 ATF_TC(expm1_inf_pos);
421 ATF_TC_HEAD(expm1_inf_pos, tc)
423 atf_tc_set_md_var(tc, "descr", "Test expm1(+Inf) == +Inf");
426 ATF_TC_BODY(expm1_inf_pos, tc)
428 const double x = 1.0L / 0.0L;
431 if (isinf(y) == 0 || signbit(y) != 0)
432 atf_tc_fail_nonfatal("expm1(+Inf) != +Inf");
435 ATF_TC(expm1_zero_neg);
436 ATF_TC_HEAD(expm1_zero_neg, tc)
438 atf_tc_set_md_var(tc, "descr", "Test expm1(-0.0) == -0.0");
441 ATF_TC_BODY(expm1_zero_neg, tc)
443 const double x = -0.0L;
446 if (fabs(y) > 0.0 || signbit(y) == 0)
447 atf_tc_fail_nonfatal("expm1(-0.0) != -0.0");
450 ATF_TC(expm1_zero_pos);
451 ATF_TC_HEAD(expm1_zero_pos, tc)
453 atf_tc_set_md_var(tc, "descr", "Test expm1(+0.0) == 1.0");
456 ATF_TC_BODY(expm1_zero_pos, tc)
458 const double x = 0.0L;
461 if (fabs(y) > 0.0 || signbit(y) != 0)
462 atf_tc_fail_nonfatal("expm1(+0.0) != +0.0");
469 ATF_TC_HEAD(expm1f_nan, tc)
471 atf_tc_set_md_var(tc, "descr", "Test expm1f(NaN) == NaN");
474 ATF_TC_BODY(expm1f_nan, tc)
476 const float x = 0.0L / 0.0L;
478 if (isnan(expm1f(x)) == 0)
479 atf_tc_fail_nonfatal("expm1f(NaN) != NaN");
482 ATF_TC(expm1f_inf_neg);
483 ATF_TC_HEAD(expm1f_inf_neg, tc)
485 atf_tc_set_md_var(tc, "descr", "Test expm1f(-Inf) == -1");
488 ATF_TC_BODY(expm1f_inf_neg, tc)
490 const float x = -1.0L / 0.0L;
492 if (expm1f(x) != -1.0)
493 atf_tc_fail_nonfatal("expm1f(-Inf) != -1.0");
496 ATF_TC(expm1f_inf_pos);
497 ATF_TC_HEAD(expm1f_inf_pos, tc)
499 atf_tc_set_md_var(tc, "descr", "Test expm1f(+Inf) == +Inf");
502 ATF_TC_BODY(expm1f_inf_pos, tc)
504 const float x = 1.0L / 0.0L;
507 if (isinf(y) == 0 || signbit(y) != 0)
508 atf_tc_fail_nonfatal("expm1f(+Inf) != +Inf");
511 ATF_TC(expm1f_zero_neg);
512 ATF_TC_HEAD(expm1f_zero_neg, tc)
514 atf_tc_set_md_var(tc, "descr", "Test expm1f(-0.0) == -0.0");
517 ATF_TC_BODY(expm1f_zero_neg, tc)
519 const float x = -0.0L;
522 if (fabsf(y) > 0.0 || signbit(y) == 0)
523 atf_tc_fail_nonfatal("expm1f(-0.0) != -0.0");
526 ATF_TC(expm1f_zero_pos);
527 ATF_TC_HEAD(expm1f_zero_pos, tc)
529 atf_tc_set_md_var(tc, "descr", "Test expm1f(+0.0) == 1.0");
532 ATF_TC_BODY(expm1f_zero_pos, tc)
534 const float x = 0.0L;
537 if (fabsf(y) > 0.0 || signbit(y) != 0)
538 atf_tc_fail_nonfatal("expm1f(+0.0) != +0.0");
544 ATF_TP_ADD_TC(tp, exp2_is_nan);
545 ATF_TP_ADD_TC(tp, exp2_is_plus_zero);
546 ATF_TP_ADD_TC(tp, exp2_values);
547 ATF_TP_ADD_TC(tp, exp2_powers);
549 ATF_TP_ADD_TC(tp, exp_nan);
550 ATF_TP_ADD_TC(tp, exp_inf_neg);
551 ATF_TP_ADD_TC(tp, exp_inf_pos);
552 ATF_TP_ADD_TC(tp, exp_product);
553 ATF_TP_ADD_TC(tp, exp_zero_neg);
554 ATF_TP_ADD_TC(tp, exp_zero_pos);
556 ATF_TP_ADD_TC(tp, expf_nan);
557 ATF_TP_ADD_TC(tp, expf_inf_neg);
558 ATF_TP_ADD_TC(tp, expf_inf_pos);
559 ATF_TP_ADD_TC(tp, expf_product);
560 ATF_TP_ADD_TC(tp, expf_zero_neg);
561 ATF_TP_ADD_TC(tp, expf_zero_pos);
563 ATF_TP_ADD_TC(tp, expm1_nan);
564 ATF_TP_ADD_TC(tp, expm1_inf_neg);
565 ATF_TP_ADD_TC(tp, expm1_inf_pos);
566 ATF_TP_ADD_TC(tp, expm1_zero_neg);
567 ATF_TP_ADD_TC(tp, expm1_zero_pos);
569 ATF_TP_ADD_TC(tp, expm1f_nan);
570 ATF_TP_ADD_TC(tp, expm1f_inf_neg);
571 ATF_TP_ADD_TC(tp, expm1f_inf_pos);
572 ATF_TP_ADD_TC(tp, expm1f_zero_neg);
573 ATF_TP_ADD_TC(tp, expm1f_zero_pos);
575 return atf_no_error();