1 /* $NetBSD: t_exp.c,v 1.9 2018/11/07 03:59:36 riastradh Exp $ */ 2 3 /*- 4 * Copyright (c) 2011 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jukka Ruohonen. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 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. 18 * 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. 30 */ 31 32 #include <atf-c.h> 33 #include <float.h> 34 #include <math.h> 35 #include "t_libm.h" 36 37 /* y = exp(x) */ 38 static const struct { 39 double x; 40 double y; 41 } exp_values[] = { 42 { -10, 0.4539992976248485e-4, }, 43 { -5, 0.6737946999085467e-2, }, 44 { -1, 0.3678794411714423, }, 45 { -0.1, 0.9048374180359595, }, 46 { 0, 1.0000000000000000, }, 47 { 0.1, 1.1051709180756477, }, 48 { 1, 2.7182818284590452, }, 49 { 5, 148.41315910257660, }, 50 { 10, 22026.465794806718, }, 51 }; 52 53 /* 54 * exp2/exp2f(3) 55 */ 56 ATF_LIBM_TEST(exp2_is_nan, "Test exp2(x) == NaN") 57 { 58 #ifdef T_LIBM_NAN 59 T_LIBM_CHECK_NAN(0, exp2, T_LIBM_NAN); 60 T_LIBM_CHECK_NAN(0, exp2f, T_LIBM_NAN); 61 #else 62 atf_tc_skip("no NaN on this machine"); 63 #endif 64 } 65 66 ATF_LIBM_TEST(exp2_is_plus_zero, "Test exp2(x) == +0.0") 67 { 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); 71 #else 72 atf_tc_skip("no +/-Inf on this machine"); 73 #endif 74 } 75 76 ATF_LIBM_TEST(exp2_powers, "Test exp2(x) is correct for some integer x") 77 { 78 static const struct { 79 double x; 80 double d_y; 81 double f_y; 82 } v[] = { 83 { +0.0, 1.0, 1.0 }, 84 { -0.0, 1.0, 1.0 }, 85 { 1, 0x1p1, 0x1p1 }, 86 { 2, 0x1p2, 0x1p2 }, 87 { 100, 0x1p100, 0x1p100 }, 88 { 125, 0x1p125, 0x1p125 }, 89 { 126, 0x1p126, 0x1p126 }, 90 #if __DBL_MAX_EXP__ > 129 91 { 127, 0x1p127, 0x1p127 }, 92 #endif 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 }, 106 #endif 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}, 124 #endif 125 {-1075, 0x0, 0.0}, 126 {-1080, 0x0, 0.0}, 127 {-2000, 0x0, 0.0}, 128 {-16382, 0x0, 0.0}, 129 {-16383, 0x0, 0.0}, 130 {-16384, 0x0, 0.0}, 131 }; 132 unsigned int i; 133 134 for (i = 0; i < __arraycount(v); i++) { 135 T_LIBM_CHECK(i, exp2, v[i].x, v[i].d_y, 0.0); 136 T_LIBM_CHECK(i, exp2f, v[i].x, v[i].f_y, 0.0); 137 } 138 } 139 140 ATF_LIBM_TEST(exp2_values, "Test exp2(x) is correct for some x") 141 { 142 static const struct { 143 double x; 144 double d_y; 145 float f_y; 146 double d_eps; 147 double f_eps; 148 } v[] = { 149 #if __DBL_MAX_EXP__ > 128 150 /* The largest double constant */ 151 { 0x1.fffffffffffffp9, 0x1.ffffffffffd3ap1023, 0.00, 152 0x1p969, 0.0 }, 153 /* The largest float constant */ 154 { 0x1.fffffep6, 0x1.ffff4ep+127, 0x1.ffff4ep+127, 6e30, 0.0 }, 155 #endif 156 #ifdef T_LIBM_PLUS_INF 157 { T_LIBM_PLUS_INF, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF, 0.0, 0.0 }, 158 #endif 159 160 /* The few values from the old tests */ 161 /* Results from i386/amd64, d_eps needed on i386 */ 162 /* f_y values calculated using py-mpmath */ 163 { 1.1, 0x1.125fbee250664p+1, 0x1.125fc0p+1, 0x1p-52, 0x1.8p-22 }, 164 { 2.2, 0x1.2611186bae675p+2, 0x1.26111ap+2, 0x1p-51, 0x1.8p-21 }, 165 { 3.3, 0x1.3b2c47bff8328p+3, 0x1.3b2c48p+3, 0x1p-50, 0x1.8p-20 }, 166 { 4.4, 0x1.51cb453b9536ep+4, 0x1.51cb46p+4, 0x1p-49, 0x1.8p-19 }, 167 { 5.5, 0x1.6a09e667f3bcdp+5, 0x1.6a09e6p+5, 0x1p-48, 0x1.8p-18 }, 168 { 6.6, 0x1.8406003b2ae5bp+6, 0x1.8405fep+6, 0x1p-47, 0x1.8p-17 }, 169 { 7.7, 0x1.9fdf8bcce533ep+7, 0x1.9fdf88p+7, 0x1p-46, 0x1.8p-16 }, 170 { 8.8, 0x1.bdb8cdadbe124p+8, 0x1.bdb8d2p+8, 0x1p-45, 0x1.8p-15 }, 171 }; 172 unsigned int i; 173 174 for (i = 0; i < __arraycount(v); i++) { 175 T_LIBM_CHECK(i, exp2, v[i].x, v[i].d_y, v[i].d_eps); 176 if (i > 1) 177 T_LIBM_CHECK(i, exp2f, v[i].x, v[i].f_y, v[i].f_eps); 178 } 179 } 180 181 182 /* 183 * exp(3) 184 */ 185 ATF_TC(exp_nan); 186 ATF_TC_HEAD(exp_nan, tc) 187 { 188 atf_tc_set_md_var(tc, "descr", "Test exp(NaN) == NaN"); 189 } 190 191 ATF_TC_BODY(exp_nan, tc) 192 { 193 const double x = 0.0L / 0.0L; 194 195 if (isnan(exp(x)) == 0) 196 atf_tc_fail_nonfatal("exp(NaN) != NaN"); 197 } 198 199 ATF_TC(exp_inf_neg); 200 ATF_TC_HEAD(exp_inf_neg, tc) 201 { 202 atf_tc_set_md_var(tc, "descr", "Test exp(-Inf) == +0.0"); 203 } 204 205 ATF_TC_BODY(exp_inf_neg, tc) 206 { 207 const double x = -1.0L / 0.0L; 208 double y = exp(x); 209 210 if (fabs(y) > 0.0 || signbit(y) != 0) 211 atf_tc_fail_nonfatal("exp(-Inf) != +0.0"); 212 } 213 214 ATF_TC(exp_inf_pos); 215 ATF_TC_HEAD(exp_inf_pos, tc) 216 { 217 atf_tc_set_md_var(tc, "descr", "Test exp(+Inf) == +Inf"); 218 } 219 220 ATF_TC_BODY(exp_inf_pos, tc) 221 { 222 const double x = 1.0L / 0.0L; 223 double y = exp(x); 224 225 if (isinf(y) == 0 || signbit(y) != 0) 226 atf_tc_fail_nonfatal("exp(+Inf) != +Inf"); 227 } 228 229 ATF_TC(exp_product); 230 ATF_TC_HEAD(exp_product, tc) 231 { 232 atf_tc_set_md_var(tc, "descr", "Test some selected exp(x)"); 233 } 234 235 ATF_TC_BODY(exp_product, tc) 236 { 237 const double eps = DBL_EPSILON; 238 size_t i; 239 240 for (i = 0; i < __arraycount(exp_values); i++) { 241 double x = exp_values[i].x; 242 double e_x = exp_values[i].y; 243 244 if (!(fabs((exp(x) - e_x)/e_x) <= eps)) { 245 atf_tc_fail_nonfatal("exp(%.17g) = %.17g != %.17g", 246 x, exp(x), e_x); 247 } 248 } 249 } 250 251 ATF_TC(exp_zero_neg); 252 ATF_TC_HEAD(exp_zero_neg, tc) 253 { 254 atf_tc_set_md_var(tc, "descr", "Test exp(-0.0) == 1.0"); 255 } 256 257 ATF_TC_BODY(exp_zero_neg, tc) 258 { 259 const double x = -0.0L; 260 261 if (fabs(exp(x) - 1.0) > 0.0) 262 atf_tc_fail_nonfatal("exp(-0.0) != 1.0"); 263 } 264 265 ATF_TC(exp_zero_pos); 266 ATF_TC_HEAD(exp_zero_pos, tc) 267 { 268 atf_tc_set_md_var(tc, "descr", "Test exp(+0.0) == 1.0"); 269 } 270 271 ATF_TC_BODY(exp_zero_pos, tc) 272 { 273 const double x = 0.0L; 274 275 if (fabs(exp(x) - 1.0) > 0.0) 276 atf_tc_fail_nonfatal("exp(+0.0) != 1.0"); 277 } 278 279 /* 280 * expf(3) 281 */ 282 ATF_TC(expf_nan); 283 ATF_TC_HEAD(expf_nan, tc) 284 { 285 atf_tc_set_md_var(tc, "descr", "Test expf(NaN) == NaN"); 286 } 287 288 ATF_TC_BODY(expf_nan, tc) 289 { 290 const float x = 0.0L / 0.0L; 291 292 if (isnan(expf(x)) == 0) 293 atf_tc_fail_nonfatal("expf(NaN) != NaN"); 294 } 295 296 ATF_TC(expf_inf_neg); 297 ATF_TC_HEAD(expf_inf_neg, tc) 298 { 299 atf_tc_set_md_var(tc, "descr", "Test expf(-Inf) == +0.0"); 300 } 301 302 ATF_TC_BODY(expf_inf_neg, tc) 303 { 304 const float x = -1.0L / 0.0L; 305 float y = expf(x); 306 307 if (fabsf(y) > 0.0 || signbit(y) != 0) 308 atf_tc_fail_nonfatal("expf(-Inf) != +0.0"); 309 } 310 311 ATF_TC(expf_inf_pos); 312 ATF_TC_HEAD(expf_inf_pos, tc) 313 { 314 atf_tc_set_md_var(tc, "descr", "Test expf(+Inf) == +Inf"); 315 } 316 317 ATF_TC_BODY(expf_inf_pos, tc) 318 { 319 const float x = 1.0L / 0.0L; 320 float y = expf(x); 321 322 if (isinf(y) == 0 || signbit(y) != 0) 323 atf_tc_fail_nonfatal("expf(+Inf) != +Inf"); 324 } 325 326 ATF_TC(expf_product); 327 ATF_TC_HEAD(expf_product, tc) 328 { 329 atf_tc_set_md_var(tc, "descr", "Test some selected expf(x)"); 330 } 331 332 ATF_TC_BODY(expf_product, tc) 333 { 334 const float eps = FLT_EPSILON; 335 size_t i; 336 337 for (i = 0; i < __arraycount(exp_values); i++) { 338 float x = exp_values[i].x; 339 float e_x = exp_values[i].y; 340 341 if (!(fabsf((expf(x) - e_x)/e_x) <= eps)) { 342 atf_tc_fail_nonfatal("expf(%.8g) = %.8g != %.8g", 343 x, exp(x), e_x); 344 } 345 } 346 } 347 348 ATF_TC(expf_zero_neg); 349 ATF_TC_HEAD(expf_zero_neg, tc) 350 { 351 atf_tc_set_md_var(tc, "descr", "Test expf(-0.0) == 1.0"); 352 } 353 354 ATF_TC_BODY(expf_zero_neg, tc) 355 { 356 const float x = -0.0L; 357 358 if (fabsf(expf(x) - 1.0f) > 0.0) 359 atf_tc_fail_nonfatal("expf(-0.0) != 1.0"); 360 } 361 362 ATF_TC(expf_zero_pos); 363 ATF_TC_HEAD(expf_zero_pos, tc) 364 { 365 atf_tc_set_md_var(tc, "descr", "Test expf(+0.0) == 1.0"); 366 } 367 368 ATF_TC_BODY(expf_zero_pos, tc) 369 { 370 const float x = 0.0L; 371 372 if (fabsf(expf(x) - 1.0f) > 0.0) 373 atf_tc_fail_nonfatal("expf(+0.0) != 1.0"); 374 } 375 376 /* 377 * expm1(3) 378 */ 379 ATF_TC(expm1_nan); 380 ATF_TC_HEAD(expm1_nan, tc) 381 { 382 atf_tc_set_md_var(tc, "descr", "Test expm1(NaN) == NaN"); 383 } 384 385 ATF_TC_BODY(expm1_nan, tc) 386 { 387 const double x = 0.0L / 0.0L; 388 389 if (isnan(expm1(x)) == 0) 390 atf_tc_fail_nonfatal("expm1(NaN) != NaN"); 391 } 392 393 ATF_TC(expm1_inf_neg); 394 ATF_TC_HEAD(expm1_inf_neg, tc) 395 { 396 atf_tc_set_md_var(tc, "descr", "Test expm1(-Inf) == -1"); 397 } 398 399 ATF_TC_BODY(expm1_inf_neg, tc) 400 { 401 const double x = -1.0L / 0.0L; 402 403 if (expm1(x) != -1.0) 404 atf_tc_fail_nonfatal("expm1(-Inf) != -1.0"); 405 } 406 407 ATF_TC(expm1_inf_pos); 408 ATF_TC_HEAD(expm1_inf_pos, tc) 409 { 410 atf_tc_set_md_var(tc, "descr", "Test expm1(+Inf) == +Inf"); 411 } 412 413 ATF_TC_BODY(expm1_inf_pos, tc) 414 { 415 const double x = 1.0L / 0.0L; 416 double y = expm1(x); 417 418 if (isinf(y) == 0 || signbit(y) != 0) 419 atf_tc_fail_nonfatal("expm1(+Inf) != +Inf"); 420 } 421 422 ATF_TC(expm1_zero_neg); 423 ATF_TC_HEAD(expm1_zero_neg, tc) 424 { 425 atf_tc_set_md_var(tc, "descr", "Test expm1(-0.0) == -0.0"); 426 } 427 428 ATF_TC_BODY(expm1_zero_neg, tc) 429 { 430 const double x = -0.0L; 431 double y = expm1(x); 432 433 if (fabs(y) > 0.0 || signbit(y) == 0) 434 atf_tc_fail_nonfatal("expm1(-0.0) != -0.0"); 435 } 436 437 ATF_TC(expm1_zero_pos); 438 ATF_TC_HEAD(expm1_zero_pos, tc) 439 { 440 atf_tc_set_md_var(tc, "descr", "Test expm1(+0.0) == 1.0"); 441 } 442 443 ATF_TC_BODY(expm1_zero_pos, tc) 444 { 445 const double x = 0.0L; 446 double y = expm1(x); 447 448 if (fabs(y) > 0.0 || signbit(y) != 0) 449 atf_tc_fail_nonfatal("expm1(+0.0) != +0.0"); 450 } 451 452 /* 453 * expm1f(3) 454 */ 455 ATF_TC(expm1f_nan); 456 ATF_TC_HEAD(expm1f_nan, tc) 457 { 458 atf_tc_set_md_var(tc, "descr", "Test expm1f(NaN) == NaN"); 459 } 460 461 ATF_TC_BODY(expm1f_nan, tc) 462 { 463 const float x = 0.0L / 0.0L; 464 465 if (isnan(expm1f(x)) == 0) 466 atf_tc_fail_nonfatal("expm1f(NaN) != NaN"); 467 } 468 469 ATF_TC(expm1f_inf_neg); 470 ATF_TC_HEAD(expm1f_inf_neg, tc) 471 { 472 atf_tc_set_md_var(tc, "descr", "Test expm1f(-Inf) == -1"); 473 } 474 475 ATF_TC_BODY(expm1f_inf_neg, tc) 476 { 477 const float x = -1.0L / 0.0L; 478 479 if (expm1f(x) != -1.0) 480 atf_tc_fail_nonfatal("expm1f(-Inf) != -1.0"); 481 } 482 483 ATF_TC(expm1f_inf_pos); 484 ATF_TC_HEAD(expm1f_inf_pos, tc) 485 { 486 atf_tc_set_md_var(tc, "descr", "Test expm1f(+Inf) == +Inf"); 487 } 488 489 ATF_TC_BODY(expm1f_inf_pos, tc) 490 { 491 const float x = 1.0L / 0.0L; 492 float y = expm1f(x); 493 494 if (isinf(y) == 0 || signbit(y) != 0) 495 atf_tc_fail_nonfatal("expm1f(+Inf) != +Inf"); 496 } 497 498 ATF_TC(expm1f_zero_neg); 499 ATF_TC_HEAD(expm1f_zero_neg, tc) 500 { 501 atf_tc_set_md_var(tc, "descr", "Test expm1f(-0.0) == -0.0"); 502 } 503 504 ATF_TC_BODY(expm1f_zero_neg, tc) 505 { 506 const float x = -0.0L; 507 float y = expm1f(x); 508 509 if (fabsf(y) > 0.0 || signbit(y) == 0) 510 atf_tc_fail_nonfatal("expm1f(-0.0) != -0.0"); 511 } 512 513 ATF_TC(expm1f_zero_pos); 514 ATF_TC_HEAD(expm1f_zero_pos, tc) 515 { 516 atf_tc_set_md_var(tc, "descr", "Test expm1f(+0.0) == 1.0"); 517 } 518 519 ATF_TC_BODY(expm1f_zero_pos, tc) 520 { 521 const float x = 0.0L; 522 float y = expm1f(x); 523 524 if (fabsf(y) > 0.0 || signbit(y) != 0) 525 atf_tc_fail_nonfatal("expm1f(+0.0) != +0.0"); 526 } 527 528 ATF_TP_ADD_TCS(tp) 529 { 530 531 ATF_TP_ADD_TC(tp, exp2_is_nan); 532 ATF_TP_ADD_TC(tp, exp2_is_plus_zero); 533 ATF_TP_ADD_TC(tp, exp2_values); 534 ATF_TP_ADD_TC(tp, exp2_powers); 535 536 ATF_TP_ADD_TC(tp, exp_nan); 537 ATF_TP_ADD_TC(tp, exp_inf_neg); 538 ATF_TP_ADD_TC(tp, exp_inf_pos); 539 ATF_TP_ADD_TC(tp, exp_product); 540 ATF_TP_ADD_TC(tp, exp_zero_neg); 541 ATF_TP_ADD_TC(tp, exp_zero_pos); 542 543 ATF_TP_ADD_TC(tp, expf_nan); 544 ATF_TP_ADD_TC(tp, expf_inf_neg); 545 ATF_TP_ADD_TC(tp, expf_inf_pos); 546 ATF_TP_ADD_TC(tp, expf_product); 547 ATF_TP_ADD_TC(tp, expf_zero_neg); 548 ATF_TP_ADD_TC(tp, expf_zero_pos); 549 550 ATF_TP_ADD_TC(tp, expm1_nan); 551 ATF_TP_ADD_TC(tp, expm1_inf_neg); 552 ATF_TP_ADD_TC(tp, expm1_inf_pos); 553 ATF_TP_ADD_TC(tp, expm1_zero_neg); 554 ATF_TP_ADD_TC(tp, expm1_zero_pos); 555 556 ATF_TP_ADD_TC(tp, expm1f_nan); 557 ATF_TP_ADD_TC(tp, expm1f_inf_neg); 558 ATF_TP_ADD_TC(tp, expm1f_inf_pos); 559 ATF_TP_ADD_TC(tp, expm1f_zero_neg); 560 ATF_TP_ADD_TC(tp, expm1f_zero_pos); 561 562 return atf_no_error(); 563 } 564