t_log.c revision 1.10
1 /* $NetBSD: t_log.c,v 1.10 2014/02/27 17:26:02 joerg 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 #include <sys/cdefs.h> 32 __RCSID("$NetBSD: t_log.c,v 1.10 2014/02/27 17:26:02 joerg Exp $"); 33 34 #include <atf-c.h> 35 #include <atf-c/config.h> 36 37 #include <math.h> 38 #include <stdio.h> 39 #include <string.h> 40 41 /* 42 * log10(3) 43 */ 44 ATF_TC(log10_base); 45 ATF_TC_HEAD(log10_base, tc) 46 { 47 atf_tc_set_md_var(tc, "descr", "Test log10(10) == 1"); 48 } 49 50 ATF_TC_BODY(log10_base, tc) 51 { 52 ATF_CHECK(log10(10.0) == 1.0); 53 } 54 55 ATF_TC(log10_nan); 56 ATF_TC_HEAD(log10_nan, tc) 57 { 58 atf_tc_set_md_var(tc, "descr", "Test log10(NaN) == NaN"); 59 } 60 61 ATF_TC_BODY(log10_nan, tc) 62 { 63 #ifndef __vax__ 64 const double x = 0.0L / 0.0L; 65 66 ATF_CHECK(isnan(x) != 0); 67 ATF_CHECK(isnan(log10(x)) != 0); 68 #endif 69 } 70 71 ATF_TC(log10_inf_neg); 72 ATF_TC_HEAD(log10_inf_neg, tc) 73 { 74 atf_tc_set_md_var(tc, "descr", "Test log10(-Inf) == NaN"); 75 } 76 77 ATF_TC_BODY(log10_inf_neg, tc) 78 { 79 #ifndef __vax__ 80 const double x = -1.0L / 0.0L; 81 const double y = log10(x); 82 83 ATF_CHECK(isnan(y) != 0); 84 #endif 85 } 86 87 ATF_TC(log10_inf_pos); 88 ATF_TC_HEAD(log10_inf_pos, tc) 89 { 90 atf_tc_set_md_var(tc, "descr", "Test log10(+Inf) == +Inf"); 91 } 92 93 ATF_TC_BODY(log10_inf_pos, tc) 94 { 95 #ifndef __vax__ 96 const double x = 1.0L / 0.0L; 97 98 ATF_CHECK(log10(x) == x); 99 #endif 100 } 101 102 ATF_TC(log10_one_pos); 103 ATF_TC_HEAD(log10_one_pos, tc) 104 { 105 atf_tc_set_md_var(tc, "descr", "Test log10(1.0) == +0.0"); 106 } 107 108 ATF_TC_BODY(log10_one_pos, tc) 109 { 110 #ifndef __vax__ 111 const double x = log10(1.0); 112 const double y = 0.0L; 113 114 ATF_CHECK(x == y); 115 ATF_CHECK(signbit(x) == 0); 116 ATF_CHECK(signbit(y) == 0); 117 #endif 118 } 119 120 ATF_TC(log10_zero_neg); 121 ATF_TC_HEAD(log10_zero_neg, tc) 122 { 123 atf_tc_set_md_var(tc, "descr", "Test log10(-0.0) == -HUGE_VAL"); 124 } 125 126 ATF_TC_BODY(log10_zero_neg, tc) 127 { 128 #ifndef __vax__ 129 const double x = -0.0L; 130 131 ATF_CHECK(log10(x) == -HUGE_VAL); 132 #endif 133 } 134 135 ATF_TC(log10_zero_pos); 136 ATF_TC_HEAD(log10_zero_pos, tc) 137 { 138 atf_tc_set_md_var(tc, "descr", "Test log10(+0.0) == -HUGE_VAL"); 139 } 140 141 ATF_TC_BODY(log10_zero_pos, tc) 142 { 143 #ifndef __vax__ 144 const double x = 0.0L; 145 146 ATF_CHECK(log10(x) == -HUGE_VAL); 147 #endif 148 } 149 150 /* 151 * log10f(3) 152 */ 153 ATF_TC(log10f_base); 154 ATF_TC_HEAD(log10f_base, tc) 155 { 156 atf_tc_set_md_var(tc, "descr", "Test log10f(10) == 1"); 157 } 158 159 ATF_TC_BODY(log10f_base, tc) 160 { 161 ATF_CHECK(log10f(10.0) == 1.0); 162 } 163 164 ATF_TC(log10f_nan); 165 ATF_TC_HEAD(log10f_nan, tc) 166 { 167 atf_tc_set_md_var(tc, "descr", "Test log10f(NaN) == NaN"); 168 } 169 170 ATF_TC_BODY(log10f_nan, tc) 171 { 172 #ifndef __vax__ 173 const float x = 0.0L / 0.0L; 174 175 ATF_CHECK(isnan(x) != 0); 176 ATF_CHECK(isnan(log10f(x)) != 0); 177 #endif 178 } 179 180 ATF_TC(log10f_inf_neg); 181 ATF_TC_HEAD(log10f_inf_neg, tc) 182 { 183 atf_tc_set_md_var(tc, "descr", "Test log10f(-Inf) == NaN"); 184 } 185 186 ATF_TC_BODY(log10f_inf_neg, tc) 187 { 188 #ifndef __vax__ 189 const float x = -1.0L / 0.0L; 190 const float y = log10f(x); 191 192 ATF_CHECK(isnan(y) != 0); 193 #endif 194 } 195 196 ATF_TC(log10f_inf_pos); 197 ATF_TC_HEAD(log10f_inf_pos, tc) 198 { 199 atf_tc_set_md_var(tc, "descr", "Test log10f(+Inf) == +Inf"); 200 } 201 202 ATF_TC_BODY(log10f_inf_pos, tc) 203 { 204 #ifndef __vax__ 205 const float x = 1.0L / 0.0L; 206 207 #if defined(__alpha__) 208 atf_tc_expect_fail("PR port-alpha/46301"); 209 #endif 210 211 ATF_CHECK(log10f(x) == x); 212 #endif 213 } 214 215 ATF_TC(log10f_one_pos); 216 ATF_TC_HEAD(log10f_one_pos, tc) 217 { 218 atf_tc_set_md_var(tc, "descr", "Test log10f(1.0) == +0.0"); 219 } 220 221 ATF_TC_BODY(log10f_one_pos, tc) 222 { 223 #ifndef __vax__ 224 const float x = log10f(1.0); 225 const float y = 0.0L; 226 227 ATF_CHECK(x == y); 228 ATF_CHECK(signbit(x) == 0); 229 ATF_CHECK(signbit(y) == 0); 230 #endif 231 } 232 233 ATF_TC(log10f_zero_neg); 234 ATF_TC_HEAD(log10f_zero_neg, tc) 235 { 236 atf_tc_set_md_var(tc, "descr", "Test log10f(-0.0) == -HUGE_VALF"); 237 } 238 239 ATF_TC_BODY(log10f_zero_neg, tc) 240 { 241 #ifndef __vax__ 242 const float x = -0.0L; 243 244 ATF_CHECK(log10f(x) == -HUGE_VALF); 245 #endif 246 } 247 248 ATF_TC(log10f_zero_pos); 249 ATF_TC_HEAD(log10f_zero_pos, tc) 250 { 251 atf_tc_set_md_var(tc, "descr", "Test log10f(+0.0) == -HUGE_VALF"); 252 } 253 254 ATF_TC_BODY(log10f_zero_pos, tc) 255 { 256 #ifndef __vax__ 257 const float x = 0.0L; 258 259 ATF_CHECK(log10f(x) == -HUGE_VALF); 260 #endif 261 } 262 263 /* 264 * log1p(3) 265 */ 266 ATF_TC(log1p_nan); 267 ATF_TC_HEAD(log1p_nan, tc) 268 { 269 atf_tc_set_md_var(tc, "descr", "Test log1p(NaN) == NaN"); 270 } 271 272 ATF_TC_BODY(log1p_nan, tc) 273 { 274 #ifndef __vax__ 275 const double x = 0.0L / 0.0L; 276 277 ATF_CHECK(isnan(x) != 0); 278 ATF_CHECK(isnan(log1p(x)) != 0); 279 #endif 280 } 281 282 ATF_TC(log1p_inf_neg); 283 ATF_TC_HEAD(log1p_inf_neg, tc) 284 { 285 atf_tc_set_md_var(tc, "descr", "Test log1p(-Inf) == NaN"); 286 } 287 288 ATF_TC_BODY(log1p_inf_neg, tc) 289 { 290 #ifndef __vax__ 291 const double x = -1.0L / 0.0L; 292 const double y = log1p(x); 293 294 if (isnan(y) == 0) { 295 atf_tc_expect_fail("PR lib/45362"); 296 atf_tc_fail("log1p(-Inf) != NaN"); 297 } 298 #endif 299 } 300 301 ATF_TC(log1p_inf_pos); 302 ATF_TC_HEAD(log1p_inf_pos, tc) 303 { 304 atf_tc_set_md_var(tc, "descr", "Test log1p(+Inf) == +Inf"); 305 } 306 307 ATF_TC_BODY(log1p_inf_pos, tc) 308 { 309 #ifndef __vax__ 310 const double x = 1.0L / 0.0L; 311 312 ATF_CHECK(log1p(x) == x); 313 #endif 314 } 315 316 ATF_TC(log1p_one_neg); 317 ATF_TC_HEAD(log1p_one_neg, tc) 318 { 319 atf_tc_set_md_var(tc, "descr", "Test log1p(-1.0) == -HUGE_VAL"); 320 } 321 322 ATF_TC_BODY(log1p_one_neg, tc) 323 { 324 #ifndef __vax__ 325 const double x = log1p(-1.0); 326 327 if (x != -HUGE_VAL) { 328 atf_tc_expect_fail("PR lib/45362"); 329 atf_tc_fail("log1p(-1.0) != -HUGE_VAL"); 330 } 331 #endif 332 } 333 334 ATF_TC(log1p_zero_neg); 335 ATF_TC_HEAD(log1p_zero_neg, tc) 336 { 337 atf_tc_set_md_var(tc, "descr", "Test log1p(-0.0) == -0.0"); 338 } 339 340 ATF_TC_BODY(log1p_zero_neg, tc) 341 { 342 #ifndef __vax__ 343 const double x = -0.0L; 344 345 ATF_CHECK(log1p(x) == x); 346 #endif 347 } 348 349 ATF_TC(log1p_zero_pos); 350 ATF_TC_HEAD(log1p_zero_pos, tc) 351 { 352 atf_tc_set_md_var(tc, "descr", "Test log1p(+0.0) == +0.0"); 353 } 354 355 ATF_TC_BODY(log1p_zero_pos, tc) 356 { 357 #ifndef __vax__ 358 const double x = 0.0L; 359 360 ATF_CHECK(log1p(x) == x); 361 #endif 362 } 363 364 /* 365 * log1pf(3) 366 */ 367 ATF_TC(log1pf_nan); 368 ATF_TC_HEAD(log1pf_nan, tc) 369 { 370 atf_tc_set_md_var(tc, "descr", "Test log1pf(NaN) == NaN"); 371 } 372 373 ATF_TC_BODY(log1pf_nan, tc) 374 { 375 #ifndef __vax__ 376 const float x = 0.0L / 0.0L; 377 378 ATF_CHECK(isnan(x) != 0); 379 ATF_CHECK(isnan(log1pf(x)) != 0); 380 #endif 381 } 382 383 ATF_TC(log1pf_inf_neg); 384 ATF_TC_HEAD(log1pf_inf_neg, tc) 385 { 386 atf_tc_set_md_var(tc, "descr", "Test log1pf(-Inf) == NaN"); 387 } 388 389 ATF_TC_BODY(log1pf_inf_neg, tc) 390 { 391 #ifndef __vax__ 392 const float x = -1.0L / 0.0L; 393 const float y = log1pf(x); 394 395 if (isnan(y) == 0) { 396 atf_tc_expect_fail("PR lib/45362"); 397 atf_tc_fail("log1pf(-Inf) != NaN"); 398 } 399 #endif 400 } 401 402 ATF_TC(log1pf_inf_pos); 403 ATF_TC_HEAD(log1pf_inf_pos, tc) 404 { 405 atf_tc_set_md_var(tc, "descr", "Test log1pf(+Inf) == +Inf"); 406 } 407 408 ATF_TC_BODY(log1pf_inf_pos, tc) 409 { 410 #ifndef __vax__ 411 const float x = 1.0L / 0.0L; 412 413 ATF_CHECK(log1pf(x) == x); 414 #endif 415 } 416 417 ATF_TC(log1pf_one_neg); 418 ATF_TC_HEAD(log1pf_one_neg, tc) 419 { 420 atf_tc_set_md_var(tc, "descr", "Test log1pf(-1.0) == -HUGE_VALF"); 421 } 422 423 ATF_TC_BODY(log1pf_one_neg, tc) 424 { 425 #ifndef __vax__ 426 const float x = log1pf(-1.0); 427 428 if (x != -HUGE_VALF) { 429 atf_tc_expect_fail("PR lib/45362"); 430 atf_tc_fail("log1pf(-1.0) != -HUGE_VALF"); 431 } 432 #endif 433 } 434 435 ATF_TC(log1pf_zero_neg); 436 ATF_TC_HEAD(log1pf_zero_neg, tc) 437 { 438 atf_tc_set_md_var(tc, "descr", "Test log1pf(-0.0) == -0.0"); 439 } 440 441 ATF_TC_BODY(log1pf_zero_neg, tc) 442 { 443 #ifndef __vax__ 444 const float x = -0.0L; 445 446 ATF_CHECK(log1pf(x) == x); 447 #endif 448 } 449 450 ATF_TC(log1pf_zero_pos); 451 ATF_TC_HEAD(log1pf_zero_pos, tc) 452 { 453 atf_tc_set_md_var(tc, "descr", "Test log1pf(+0.0) == +0.0"); 454 } 455 456 ATF_TC_BODY(log1pf_zero_pos, tc) 457 { 458 #ifndef __vax__ 459 const float x = 0.0L; 460 461 ATF_CHECK(log1pf(x) == x); 462 #endif 463 } 464 465 /* 466 * log2(3) 467 */ 468 ATF_TC(log2_base); 469 ATF_TC_HEAD(log2_base, tc) 470 { 471 atf_tc_set_md_var(tc, "descr", "Test log2(2) == 1"); 472 } 473 474 ATF_TC_BODY(log2_base, tc) 475 { 476 ATF_CHECK(log2(2.0) == 1.0); 477 } 478 479 ATF_TC(log2_nan); 480 ATF_TC_HEAD(log2_nan, tc) 481 { 482 atf_tc_set_md_var(tc, "descr", "Test log2(NaN) == NaN"); 483 } 484 485 ATF_TC_BODY(log2_nan, tc) 486 { 487 #ifndef __vax__ 488 const double x = 0.0L / 0.0L; 489 490 ATF_CHECK(isnan(x) != 0); 491 ATF_CHECK(isnan(log2(x)) != 0); 492 #endif 493 } 494 495 ATF_TC(log2_inf_neg); 496 ATF_TC_HEAD(log2_inf_neg, tc) 497 { 498 atf_tc_set_md_var(tc, "descr", "Test log2(-Inf) == NaN"); 499 } 500 501 ATF_TC_BODY(log2_inf_neg, tc) 502 { 503 #ifndef __vax__ 504 const double x = -1.0L / 0.0L; 505 const double y = log2(x); 506 507 ATF_CHECK(isnan(y) != 0); 508 #endif 509 } 510 511 ATF_TC(log2_inf_pos); 512 ATF_TC_HEAD(log2_inf_pos, tc) 513 { 514 atf_tc_set_md_var(tc, "descr", "Test log2(+Inf) == +Inf"); 515 } 516 517 ATF_TC_BODY(log2_inf_pos, tc) 518 { 519 #ifndef __vax__ 520 const double x = 1.0L / 0.0L; 521 522 ATF_CHECK(log2(x) == x); 523 #endif 524 } 525 526 ATF_TC(log2_one_pos); 527 ATF_TC_HEAD(log2_one_pos, tc) 528 { 529 atf_tc_set_md_var(tc, "descr", "Test log2(1.0) == +0.0"); 530 } 531 532 ATF_TC_BODY(log2_one_pos, tc) 533 { 534 #ifndef __vax__ 535 const double x = log2(1.0); 536 const double y = 0.0L; 537 538 ATF_CHECK(x == y); 539 ATF_CHECK(signbit(x) == 0); 540 ATF_CHECK(signbit(y) == 0); 541 #endif 542 } 543 544 ATF_TC(log2_zero_neg); 545 ATF_TC_HEAD(log2_zero_neg, tc) 546 { 547 atf_tc_set_md_var(tc, "descr", "Test log2(-0.0) == -HUGE_VAL"); 548 } 549 550 ATF_TC_BODY(log2_zero_neg, tc) 551 { 552 #ifndef __vax__ 553 const double x = -0.0L; 554 555 ATF_CHECK(log2(x) == -HUGE_VAL); 556 #endif 557 } 558 559 ATF_TC(log2_zero_pos); 560 ATF_TC_HEAD(log2_zero_pos, tc) 561 { 562 atf_tc_set_md_var(tc, "descr", "Test log2(+0.0) == -HUGE_VAL"); 563 } 564 565 ATF_TC_BODY(log2_zero_pos, tc) 566 { 567 #ifndef __vax__ 568 const double x = 0.0L; 569 570 ATF_CHECK(log2(x) == -HUGE_VAL); 571 #endif 572 } 573 574 /* 575 * log2f(3) 576 */ 577 ATF_TC(log2f_base); 578 ATF_TC_HEAD(log2f_base, tc) 579 { 580 atf_tc_set_md_var(tc, "descr", "Test log2f(2) == 1"); 581 } 582 583 ATF_TC_BODY(log2f_base, tc) 584 { 585 ATF_CHECK(log2f(2.0) == 1.0); 586 } 587 588 ATF_TC(log2f_nan); 589 ATF_TC_HEAD(log2f_nan, tc) 590 { 591 atf_tc_set_md_var(tc, "descr", "Test log2f(NaN) == NaN"); 592 } 593 594 ATF_TC_BODY(log2f_nan, tc) 595 { 596 #ifndef __vax__ 597 const float x = 0.0L / 0.0L; 598 599 ATF_CHECK(isnan(x) != 0); 600 ATF_CHECK(isnan(log2f(x)) != 0); 601 #endif 602 } 603 604 ATF_TC(log2f_inf_neg); 605 ATF_TC_HEAD(log2f_inf_neg, tc) 606 { 607 atf_tc_set_md_var(tc, "descr", "Test log2f(-Inf) == NaN"); 608 } 609 610 ATF_TC_BODY(log2f_inf_neg, tc) 611 { 612 #ifndef __vax__ 613 const float x = -1.0L / 0.0L; 614 const float y = log2f(x); 615 616 ATF_CHECK(isnan(y) != 0); 617 #endif 618 } 619 620 ATF_TC(log2f_inf_pos); 621 ATF_TC_HEAD(log2f_inf_pos, tc) 622 { 623 atf_tc_set_md_var(tc, "descr", "Test log2f(+Inf) == +Inf"); 624 } 625 626 ATF_TC_BODY(log2f_inf_pos, tc) 627 { 628 #ifndef __vax__ 629 const float x = 1.0L / 0.0L; 630 631 #if defined(__alpha__) 632 atf_tc_expect_fail("PR port-alpha/46301"); 633 #endif 634 635 ATF_CHECK(log2f(x) == x); 636 #endif 637 } 638 639 ATF_TC(log2f_one_pos); 640 ATF_TC_HEAD(log2f_one_pos, tc) 641 { 642 atf_tc_set_md_var(tc, "descr", "Test log2f(1.0) == +0.0"); 643 } 644 645 ATF_TC_BODY(log2f_one_pos, tc) 646 { 647 #ifndef __vax__ 648 const float x = log2f(1.0); 649 const float y = 0.0L; 650 651 ATF_CHECK(x == y); 652 ATF_CHECK(signbit(x) == 0); 653 ATF_CHECK(signbit(y) == 0); 654 #endif 655 } 656 657 ATF_TC(log2f_zero_neg); 658 ATF_TC_HEAD(log2f_zero_neg, tc) 659 { 660 atf_tc_set_md_var(tc, "descr", "Test log2f(-0.0) == -HUGE_VALF"); 661 } 662 663 ATF_TC_BODY(log2f_zero_neg, tc) 664 { 665 #ifndef __vax__ 666 const float x = -0.0L; 667 668 ATF_CHECK(log2f(x) == -HUGE_VALF); 669 #endif 670 } 671 672 ATF_TC(log2f_zero_pos); 673 ATF_TC_HEAD(log2f_zero_pos, tc) 674 { 675 atf_tc_set_md_var(tc, "descr", "Test log2f(+0.0) == -HUGE_VALF"); 676 } 677 678 ATF_TC_BODY(log2f_zero_pos, tc) 679 { 680 #ifndef __vax__ 681 const float x = 0.0L; 682 683 ATF_CHECK(log2f(x) == -HUGE_VALF); 684 #endif 685 } 686 687 /* 688 * log(3) 689 */ 690 ATF_TC(log_base); 691 ATF_TC_HEAD(log_base, tc) 692 { 693 atf_tc_set_md_var(tc, "descr", "Test log(e) == 1"); 694 } 695 696 ATF_TC_BODY(log_base, tc) 697 { 698 const double eps = 1.0e-38; 699 700 if (fabs(log(M_E) - 1.0) > eps) 701 atf_tc_fail_nonfatal("log(e) != 1"); 702 } 703 704 ATF_TC(log_nan); 705 ATF_TC_HEAD(log_nan, tc) 706 { 707 atf_tc_set_md_var(tc, "descr", "Test log(NaN) == NaN"); 708 } 709 710 ATF_TC_BODY(log_nan, tc) 711 { 712 #ifndef __vax__ 713 const double x = 0.0L / 0.0L; 714 715 ATF_CHECK(isnan(x) != 0); 716 ATF_CHECK(isnan(log(x)) != 0); 717 #endif 718 } 719 720 ATF_TC(log_inf_neg); 721 ATF_TC_HEAD(log_inf_neg, tc) 722 { 723 atf_tc_set_md_var(tc, "descr", "Test log(-Inf) == NaN"); 724 } 725 726 ATF_TC_BODY(log_inf_neg, tc) 727 { 728 #ifndef __vax__ 729 const double x = -1.0L / 0.0L; 730 const double y = log(x); 731 732 ATF_CHECK(isnan(y) != 0); 733 #endif 734 } 735 736 ATF_TC(log_inf_pos); 737 ATF_TC_HEAD(log_inf_pos, tc) 738 { 739 atf_tc_set_md_var(tc, "descr", "Test log(+Inf) == +Inf"); 740 } 741 742 ATF_TC_BODY(log_inf_pos, tc) 743 { 744 #ifndef __vax__ 745 const double x = 1.0L / 0.0L; 746 747 ATF_CHECK(log(x) == x); 748 #endif 749 } 750 751 ATF_TC(log_one_pos); 752 ATF_TC_HEAD(log_one_pos, tc) 753 { 754 atf_tc_set_md_var(tc, "descr", "Test log(1.0) == +0.0"); 755 } 756 757 ATF_TC_BODY(log_one_pos, tc) 758 { 759 #ifndef __vax__ 760 const double x = log(1.0); 761 const double y = 0.0L; 762 763 ATF_CHECK(x == y); 764 ATF_CHECK(signbit(x) == 0); 765 ATF_CHECK(signbit(y) == 0); 766 #endif 767 } 768 769 ATF_TC(log_zero_neg); 770 ATF_TC_HEAD(log_zero_neg, tc) 771 { 772 atf_tc_set_md_var(tc, "descr", "Test log(-0.0) == -HUGE_VAL"); 773 } 774 775 ATF_TC_BODY(log_zero_neg, tc) 776 { 777 #ifndef __vax__ 778 const double x = -0.0L; 779 780 ATF_CHECK(log(x) == -HUGE_VAL); 781 #endif 782 } 783 784 ATF_TC(log_zero_pos); 785 ATF_TC_HEAD(log_zero_pos, tc) 786 { 787 atf_tc_set_md_var(tc, "descr", "Test log(+0.0) == -HUGE_VAL"); 788 } 789 790 ATF_TC_BODY(log_zero_pos, tc) 791 { 792 #ifndef __vax__ 793 const double x = 0.0L; 794 795 ATF_CHECK(log(x) == -HUGE_VAL); 796 #endif 797 } 798 799 /* 800 * logf(3) 801 */ 802 ATF_TC(logf_base); 803 ATF_TC_HEAD(logf_base, tc) 804 { 805 atf_tc_set_md_var(tc, "descr", "Test logf(e) == 1"); 806 } 807 808 ATF_TC_BODY(logf_base, tc) 809 { 810 const float eps = 1.0e-7; 811 812 if (fabsf(logf(M_E) - 1.0f) > eps) 813 atf_tc_fail_nonfatal("logf(e) != 1"); 814 } 815 816 ATF_TC(logf_nan); 817 ATF_TC_HEAD(logf_nan, tc) 818 { 819 atf_tc_set_md_var(tc, "descr", "Test logf(NaN) == NaN"); 820 } 821 822 ATF_TC_BODY(logf_nan, tc) 823 { 824 #ifndef __vax__ 825 const float x = 0.0L / 0.0L; 826 827 ATF_CHECK(isnan(x) != 0); 828 ATF_CHECK(isnan(logf(x)) != 0); 829 #endif 830 } 831 832 ATF_TC(logf_inf_neg); 833 ATF_TC_HEAD(logf_inf_neg, tc) 834 { 835 atf_tc_set_md_var(tc, "descr", "Test logf(-Inf) == NaN"); 836 } 837 838 ATF_TC_BODY(logf_inf_neg, tc) 839 { 840 #ifndef __vax__ 841 const float x = -1.0L / 0.0L; 842 const float y = logf(x); 843 844 ATF_CHECK(isnan(y) != 0); 845 #endif 846 } 847 848 ATF_TC(logf_inf_pos); 849 ATF_TC_HEAD(logf_inf_pos, tc) 850 { 851 atf_tc_set_md_var(tc, "descr", "Test logf(+Inf) == +Inf"); 852 } 853 854 ATF_TC_BODY(logf_inf_pos, tc) 855 { 856 #ifndef __vax__ 857 const float x = 1.0L / 0.0L; 858 859 #if defined(__alpha__) 860 atf_tc_expect_fail("PR port-alpha/46301"); 861 #endif 862 863 ATF_CHECK(logf(x) == x); 864 #endif 865 } 866 867 ATF_TC(logf_one_pos); 868 ATF_TC_HEAD(logf_one_pos, tc) 869 { 870 atf_tc_set_md_var(tc, "descr", "Test logf(1.0) == +0.0"); 871 } 872 873 ATF_TC_BODY(logf_one_pos, tc) 874 { 875 #ifndef __vax__ 876 const float x = logf(1.0); 877 const float y = 0.0L; 878 879 ATF_CHECK(x == y); 880 ATF_CHECK(signbit(x) == 0); 881 ATF_CHECK(signbit(y) == 0); 882 #endif 883 } 884 885 ATF_TC(logf_zero_neg); 886 ATF_TC_HEAD(logf_zero_neg, tc) 887 { 888 atf_tc_set_md_var(tc, "descr", "Test logf(-0.0) == -HUGE_VALF"); 889 } 890 891 ATF_TC_BODY(logf_zero_neg, tc) 892 { 893 #ifndef __vax__ 894 const float x = -0.0L; 895 896 ATF_CHECK(logf(x) == -HUGE_VALF); 897 #endif 898 } 899 900 ATF_TC(logf_zero_pos); 901 ATF_TC_HEAD(logf_zero_pos, tc) 902 { 903 atf_tc_set_md_var(tc, "descr", "Test logf(+0.0) == -HUGE_VALF"); 904 } 905 906 ATF_TC_BODY(logf_zero_pos, tc) 907 { 908 #ifndef __vax__ 909 const float x = 0.0L; 910 911 ATF_CHECK(logf(x) == -HUGE_VALF); 912 #endif 913 } 914 915 ATF_TP_ADD_TCS(tp) 916 { 917 918 ATF_TP_ADD_TC(tp, log10_base); 919 ATF_TP_ADD_TC(tp, log10_nan); 920 ATF_TP_ADD_TC(tp, log10_inf_neg); 921 ATF_TP_ADD_TC(tp, log10_inf_pos); 922 ATF_TP_ADD_TC(tp, log10_one_pos); 923 ATF_TP_ADD_TC(tp, log10_zero_neg); 924 ATF_TP_ADD_TC(tp, log10_zero_pos); 925 926 ATF_TP_ADD_TC(tp, log10f_base); 927 ATF_TP_ADD_TC(tp, log10f_nan); 928 ATF_TP_ADD_TC(tp, log10f_inf_neg); 929 ATF_TP_ADD_TC(tp, log10f_inf_pos); 930 ATF_TP_ADD_TC(tp, log10f_one_pos); 931 ATF_TP_ADD_TC(tp, log10f_zero_neg); 932 ATF_TP_ADD_TC(tp, log10f_zero_pos); 933 934 ATF_TP_ADD_TC(tp, log1p_nan); 935 ATF_TP_ADD_TC(tp, log1p_inf_neg); 936 ATF_TP_ADD_TC(tp, log1p_inf_pos); 937 ATF_TP_ADD_TC(tp, log1p_one_neg); 938 ATF_TP_ADD_TC(tp, log1p_zero_neg); 939 ATF_TP_ADD_TC(tp, log1p_zero_pos); 940 941 ATF_TP_ADD_TC(tp, log1pf_nan); 942 ATF_TP_ADD_TC(tp, log1pf_inf_neg); 943 ATF_TP_ADD_TC(tp, log1pf_inf_pos); 944 ATF_TP_ADD_TC(tp, log1pf_one_neg); 945 ATF_TP_ADD_TC(tp, log1pf_zero_neg); 946 ATF_TP_ADD_TC(tp, log1pf_zero_pos); 947 948 ATF_TP_ADD_TC(tp, log2_base); 949 ATF_TP_ADD_TC(tp, log2_nan); 950 ATF_TP_ADD_TC(tp, log2_inf_neg); 951 ATF_TP_ADD_TC(tp, log2_inf_pos); 952 ATF_TP_ADD_TC(tp, log2_one_pos); 953 ATF_TP_ADD_TC(tp, log2_zero_neg); 954 ATF_TP_ADD_TC(tp, log2_zero_pos); 955 956 ATF_TP_ADD_TC(tp, log2f_base); 957 ATF_TP_ADD_TC(tp, log2f_nan); 958 ATF_TP_ADD_TC(tp, log2f_inf_neg); 959 ATF_TP_ADD_TC(tp, log2f_inf_pos); 960 ATF_TP_ADD_TC(tp, log2f_one_pos); 961 ATF_TP_ADD_TC(tp, log2f_zero_neg); 962 ATF_TP_ADD_TC(tp, log2f_zero_pos); 963 964 ATF_TP_ADD_TC(tp, log_base); 965 ATF_TP_ADD_TC(tp, log_nan); 966 ATF_TP_ADD_TC(tp, log_inf_neg); 967 ATF_TP_ADD_TC(tp, log_inf_pos); 968 ATF_TP_ADD_TC(tp, log_one_pos); 969 ATF_TP_ADD_TC(tp, log_zero_neg); 970 ATF_TP_ADD_TC(tp, log_zero_pos); 971 972 ATF_TP_ADD_TC(tp, logf_base); 973 ATF_TP_ADD_TC(tp, logf_nan); 974 ATF_TP_ADD_TC(tp, logf_inf_neg); 975 ATF_TP_ADD_TC(tp, logf_inf_pos); 976 ATF_TP_ADD_TC(tp, logf_one_pos); 977 ATF_TP_ADD_TC(tp, logf_zero_neg); 978 ATF_TP_ADD_TC(tp, logf_zero_pos); 979 980 return atf_no_error(); 981 } 982
Indexes created Fri Oct 03 02:09:57 GMT 2025