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