t_log.c revision 1.9
1/* $NetBSD: t_log.c,v 1.9 2014/02/09 21:26:07 jmmv 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.9 2014/02/09 21:26:07 jmmv 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 */ 44ATF_TC(log10_base); 45ATF_TC_HEAD(log10_base, tc) 46{ 47 atf_tc_set_md_var(tc, "descr", "Test log10(10) == 1"); 48} 49 50ATF_TC_BODY(log10_base, tc) 51{ 52 ATF_CHECK(log10(10.0) == 1.0); 53} 54 55ATF_TC(log10_nan); 56ATF_TC_HEAD(log10_nan, tc) 57{ 58 atf_tc_set_md_var(tc, "descr", "Test log10(NaN) == NaN"); 59} 60 61ATF_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 71ATF_TC(log10_inf_neg); 72ATF_TC_HEAD(log10_inf_neg, tc) 73{ 74 atf_tc_set_md_var(tc, "descr", "Test log10(-Inf) == NaN"); 75} 76 77ATF_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 87ATF_TC(log10_inf_pos); 88ATF_TC_HEAD(log10_inf_pos, tc) 89{ 90 atf_tc_set_md_var(tc, "descr", "Test log10(+Inf) == +Inf"); 91} 92 93ATF_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 102ATF_TC(log10_one_pos); 103ATF_TC_HEAD(log10_one_pos, tc) 104{ 105 atf_tc_set_md_var(tc, "descr", "Test log10(1.0) == +0.0"); 106} 107 108ATF_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 120ATF_TC(log10_zero_neg); 121ATF_TC_HEAD(log10_zero_neg, tc) 122{ 123 atf_tc_set_md_var(tc, "descr", "Test log10(-0.0) == -HUGE_VAL"); 124} 125 126ATF_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 135ATF_TC(log10_zero_pos); 136ATF_TC_HEAD(log10_zero_pos, tc) 137{ 138 atf_tc_set_md_var(tc, "descr", "Test log10(+0.0) == -HUGE_VAL"); 139} 140 141ATF_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 */ 153ATF_TC(log10f_base); 154ATF_TC_HEAD(log10f_base, tc) 155{ 156 atf_tc_set_md_var(tc, "descr", "Test log10f(10) == 1"); 157} 158 159ATF_TC_BODY(log10f_base, tc) 160{ 161 ATF_CHECK(log10f(10.0) == 1.0); 162} 163 164ATF_TC(log10f_nan); 165ATF_TC_HEAD(log10f_nan, tc) 166{ 167 atf_tc_set_md_var(tc, "descr", "Test log10f(NaN) == NaN"); 168} 169 170ATF_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 180ATF_TC(log10f_inf_neg); 181ATF_TC_HEAD(log10f_inf_neg, tc) 182{ 183 atf_tc_set_md_var(tc, "descr", "Test log10f(-Inf) == NaN"); 184} 185 186ATF_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 196ATF_TC(log10f_inf_pos); 197ATF_TC_HEAD(log10f_inf_pos, tc) 198{ 199 atf_tc_set_md_var(tc, "descr", "Test log10f(+Inf) == +Inf"); 200} 201 202ATF_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 215ATF_TC(log10f_one_pos); 216ATF_TC_HEAD(log10f_one_pos, tc) 217{ 218 atf_tc_set_md_var(tc, "descr", "Test log10f(1.0) == +0.0"); 219} 220 221ATF_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 233ATF_TC(log10f_zero_neg); 234ATF_TC_HEAD(log10f_zero_neg, tc) 235{ 236 atf_tc_set_md_var(tc, "descr", "Test log10f(-0.0) == -HUGE_VALF"); 237} 238 239ATF_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 248ATF_TC(log10f_zero_pos); 249ATF_TC_HEAD(log10f_zero_pos, tc) 250{ 251 atf_tc_set_md_var(tc, "descr", "Test log10f(+0.0) == -HUGE_VALF"); 252} 253 254ATF_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 */ 266ATF_TC(log1p_nan); 267ATF_TC_HEAD(log1p_nan, tc) 268{ 269 atf_tc_set_md_var(tc, "descr", "Test log1p(NaN) == NaN"); 270} 271 272ATF_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 282ATF_TC(log1p_inf_neg); 283ATF_TC_HEAD(log1p_inf_neg, tc) 284{ 285 atf_tc_set_md_var(tc, "descr", "Test log1p(-Inf) == NaN"); 286} 287 288ATF_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 301ATF_TC(log1p_inf_pos); 302ATF_TC_HEAD(log1p_inf_pos, tc) 303{ 304 atf_tc_set_md_var(tc, "descr", "Test log1p(+Inf) == +Inf"); 305} 306 307ATF_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 316ATF_TC(log1p_one_neg); 317ATF_TC_HEAD(log1p_one_neg, tc) 318{ 319 atf_tc_set_md_var(tc, "descr", "Test log1p(-1.0) == -HUGE_VAL"); 320} 321 322ATF_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 334ATF_TC(log1p_zero_neg); 335ATF_TC_HEAD(log1p_zero_neg, tc) 336{ 337 atf_tc_set_md_var(tc, "descr", "Test log1p(-0.0) == -0.0"); 338} 339 340ATF_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 349ATF_TC(log1p_zero_pos); 350ATF_TC_HEAD(log1p_zero_pos, tc) 351{ 352 atf_tc_set_md_var(tc, "descr", "Test log1p(+0.0) == +0.0"); 353} 354 355ATF_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 */ 367ATF_TC(log1pf_nan); 368ATF_TC_HEAD(log1pf_nan, tc) 369{ 370 atf_tc_set_md_var(tc, "descr", "Test log1pf(NaN) == NaN"); 371} 372 373ATF_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 383ATF_TC(log1pf_inf_neg); 384ATF_TC_HEAD(log1pf_inf_neg, tc) 385{ 386 atf_tc_set_md_var(tc, "descr", "Test log1pf(-Inf) == NaN"); 387} 388 389ATF_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 402ATF_TC(log1pf_inf_pos); 403ATF_TC_HEAD(log1pf_inf_pos, tc) 404{ 405 atf_tc_set_md_var(tc, "descr", "Test log1pf(+Inf) == +Inf"); 406} 407 408ATF_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 417ATF_TC(log1pf_one_neg); 418ATF_TC_HEAD(log1pf_one_neg, tc) 419{ 420 atf_tc_set_md_var(tc, "descr", "Test log1pf(-1.0) == -HUGE_VALF"); 421} 422 423ATF_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 435ATF_TC(log1pf_zero_neg); 436ATF_TC_HEAD(log1pf_zero_neg, tc) 437{ 438 atf_tc_set_md_var(tc, "descr", "Test log1pf(-0.0) == -0.0"); 439} 440 441ATF_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 450ATF_TC(log1pf_zero_pos); 451ATF_TC_HEAD(log1pf_zero_pos, tc) 452{ 453 atf_tc_set_md_var(tc, "descr", "Test log1pf(+0.0) == +0.0"); 454} 455 456ATF_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 */ 468ATF_TC(log2_base); 469ATF_TC_HEAD(log2_base, tc) 470{ 471 atf_tc_set_md_var(tc, "descr", "Test log2(2) == 1"); 472} 473 474ATF_TC_BODY(log2_base, tc) 475{ 476 ATF_CHECK(log2(2.0) == 1.0); 477} 478 479ATF_TC(log2_nan); 480ATF_TC_HEAD(log2_nan, tc) 481{ 482 atf_tc_set_md_var(tc, "descr", "Test log2(NaN) == NaN"); 483} 484 485ATF_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 495ATF_TC(log2_inf_neg); 496ATF_TC_HEAD(log2_inf_neg, tc) 497{ 498 atf_tc_set_md_var(tc, "descr", "Test log2(-Inf) == NaN"); 499} 500 501ATF_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 511ATF_TC(log2_inf_pos); 512ATF_TC_HEAD(log2_inf_pos, tc) 513{ 514 atf_tc_set_md_var(tc, "descr", "Test log2(+Inf) == +Inf"); 515} 516 517ATF_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 526ATF_TC(log2_one_pos); 527ATF_TC_HEAD(log2_one_pos, tc) 528{ 529 atf_tc_set_md_var(tc, "descr", "Test log2(1.0) == +0.0"); 530} 531 532ATF_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 544ATF_TC(log2_zero_neg); 545ATF_TC_HEAD(log2_zero_neg, tc) 546{ 547 atf_tc_set_md_var(tc, "descr", "Test log2(-0.0) == -HUGE_VAL"); 548} 549 550ATF_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 559ATF_TC(log2_zero_pos); 560ATF_TC_HEAD(log2_zero_pos, tc) 561{ 562 atf_tc_set_md_var(tc, "descr", "Test log2(+0.0) == -HUGE_VAL"); 563} 564 565ATF_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 */ 577ATF_TC(log2f_base); 578ATF_TC_HEAD(log2f_base, tc) 579{ 580 atf_tc_set_md_var(tc, "descr", "Test log2f(2) == 1"); 581} 582 583ATF_TC_BODY(log2f_base, tc) 584{ 585 ATF_CHECK(log2f(2.0) == 1.0); 586} 587 588ATF_TC(log2f_nan); 589ATF_TC_HEAD(log2f_nan, tc) 590{ 591 atf_tc_set_md_var(tc, "descr", "Test log2f(NaN) == NaN"); 592} 593 594ATF_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 604ATF_TC(log2f_inf_neg); 605ATF_TC_HEAD(log2f_inf_neg, tc) 606{ 607 atf_tc_set_md_var(tc, "descr", "Test log2f(-Inf) == NaN"); 608} 609 610ATF_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 620ATF_TC(log2f_inf_pos); 621ATF_TC_HEAD(log2f_inf_pos, tc) 622{ 623 atf_tc_set_md_var(tc, "descr", "Test log2f(+Inf) == +Inf"); 624} 625 626ATF_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 639ATF_TC(log2f_one_pos); 640ATF_TC_HEAD(log2f_one_pos, tc) 641{ 642 atf_tc_set_md_var(tc, "descr", "Test log2f(1.0) == +0.0"); 643} 644 645ATF_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 657ATF_TC(log2f_zero_neg); 658ATF_TC_HEAD(log2f_zero_neg, tc) 659{ 660 atf_tc_set_md_var(tc, "descr", "Test log2f(-0.0) == -HUGE_VALF"); 661} 662 663ATF_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 672ATF_TC(log2f_zero_pos); 673ATF_TC_HEAD(log2f_zero_pos, tc) 674{ 675 atf_tc_set_md_var(tc, "descr", "Test log2f(+0.0) == -HUGE_VALF"); 676} 677 678ATF_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 */ 690ATF_TC(log_base); 691ATF_TC_HEAD(log_base, tc) 692{ 693 atf_tc_set_md_var(tc, "descr", "Test log(e) == 1"); 694} 695 696ATF_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 704ATF_TC(log_nan); 705ATF_TC_HEAD(log_nan, tc) 706{ 707 atf_tc_set_md_var(tc, "descr", "Test log(NaN) == NaN"); 708} 709 710ATF_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 720ATF_TC(log_inf_neg); 721ATF_TC_HEAD(log_inf_neg, tc) 722{ 723 atf_tc_set_md_var(tc, "descr", "Test log(-Inf) == NaN"); 724} 725 726ATF_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 736ATF_TC(log_inf_pos); 737ATF_TC_HEAD(log_inf_pos, tc) 738{ 739 atf_tc_set_md_var(tc, "descr", "Test log(+Inf) == +Inf"); 740} 741 742ATF_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 751ATF_TC(log_one_pos); 752ATF_TC_HEAD(log_one_pos, tc) 753{ 754 atf_tc_set_md_var(tc, "descr", "Test log(1.0) == +0.0"); 755} 756 757ATF_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 769ATF_TC(log_zero_neg); 770ATF_TC_HEAD(log_zero_neg, tc) 771{ 772 atf_tc_set_md_var(tc, "descr", "Test log(-0.0) == -HUGE_VAL"); 773} 774 775ATF_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 784ATF_TC(log_zero_pos); 785ATF_TC_HEAD(log_zero_pos, tc) 786{ 787 atf_tc_set_md_var(tc, "descr", "Test log(+0.0) == -HUGE_VAL"); 788} 789 790ATF_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 */ 802ATF_TC(logf_base); 803ATF_TC_HEAD(logf_base, tc) 804{ 805 atf_tc_set_md_var(tc, "descr", "Test logf(e) == 1"); 806} 807 808ATF_TC_BODY(logf_base, tc) 809{ 810 const float eps = 1.0e-7; 811 812 if (fabsf(logf(M_E) - 1.0) > eps) 813 atf_tc_fail_nonfatal("logf(e) != 1"); 814} 815 816ATF_TC(logf_nan); 817ATF_TC_HEAD(logf_nan, tc) 818{ 819 atf_tc_set_md_var(tc, "descr", "Test logf(NaN) == NaN"); 820} 821 822ATF_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 832ATF_TC(logf_inf_neg); 833ATF_TC_HEAD(logf_inf_neg, tc) 834{ 835 atf_tc_set_md_var(tc, "descr", "Test logf(-Inf) == NaN"); 836} 837 838ATF_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 848ATF_TC(logf_inf_pos); 849ATF_TC_HEAD(logf_inf_pos, tc) 850{ 851 atf_tc_set_md_var(tc, "descr", "Test logf(+Inf) == +Inf"); 852} 853 854ATF_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 867ATF_TC(logf_one_pos); 868ATF_TC_HEAD(logf_one_pos, tc) 869{ 870 atf_tc_set_md_var(tc, "descr", "Test logf(1.0) == +0.0"); 871} 872 873ATF_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 885ATF_TC(logf_zero_neg); 886ATF_TC_HEAD(logf_zero_neg, tc) 887{ 888 atf_tc_set_md_var(tc, "descr", "Test logf(-0.0) == -HUGE_VALF"); 889} 890 891ATF_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 900ATF_TC(logf_zero_pos); 901ATF_TC_HEAD(logf_zero_pos, tc) 902{ 903 atf_tc_set_md_var(tc, "descr", "Test logf(+0.0) == -HUGE_VALF"); 904} 905 906ATF_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 915ATF_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