1/* $NetBSD: t_log.c,v 1.5 2011/09/18 04:49:11 jruoho 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.5 2011/09/18 04:49:11 jruoho Exp $"); 33 34#include <atf-c.h> 35#include <stdio.h> 36#include <math.h> 37 38/* 39 * log10(3) 40 */ 41ATF_TC(log10_base); 42ATF_TC_HEAD(log10_base, tc) 43{ 44 atf_tc_set_md_var(tc, "descr", "Test log10(10) == 1"); 45} 46 47ATF_TC_BODY(log10_base, tc) 48{ 49 ATF_CHECK(log10(10.0) == 1.0); 50} 51 52ATF_TC(log10_nan); 53ATF_TC_HEAD(log10_nan, tc) 54{ 55 atf_tc_set_md_var(tc, "descr", "Test log10(NaN) == NaN"); 56} 57 58ATF_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 68ATF_TC(log10_inf_neg); 69ATF_TC_HEAD(log10_inf_neg, tc) 70{ 71 atf_tc_set_md_var(tc, "descr", "Test log10(-Inf) == NaN"); 72} 73 74ATF_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 84ATF_TC(log10_inf_pos); 85ATF_TC_HEAD(log10_inf_pos, tc) 86{ 87 atf_tc_set_md_var(tc, "descr", "Test log10(+Inf) == +Inf"); 88} 89 90ATF_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 99ATF_TC(log10_one_pos); 100ATF_TC_HEAD(log10_one_pos, tc) 101{ 102 atf_tc_set_md_var(tc, "descr", "Test log10(1.0) == +0.0"); 103} 104 105ATF_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 117ATF_TC(log10_zero_neg); 118ATF_TC_HEAD(log10_zero_neg, tc) 119{ 120 atf_tc_set_md_var(tc, "descr", "Test log10(-0.0) == -HUGE_VAL"); 121} 122 123ATF_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 132ATF_TC(log10_zero_pos); 133ATF_TC_HEAD(log10_zero_pos, tc) 134{ 135 atf_tc_set_md_var(tc, "descr", "Test log10(+0.0) == -HUGE_VAL"); 136} 137 138ATF_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 */ 150ATF_TC(log10f_base); 151ATF_TC_HEAD(log10f_base, tc) 152{ 153 atf_tc_set_md_var(tc, "descr", "Test log10f(10) == 1"); 154} 155 156ATF_TC_BODY(log10f_base, tc) 157{ 158 ATF_CHECK(log10f(10.0) == 1.0); 159} 160 161ATF_TC(log10f_nan); 162ATF_TC_HEAD(log10f_nan, tc) 163{ 164 atf_tc_set_md_var(tc, "descr", "Test log10f(NaN) == NaN"); 165} 166 167ATF_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 177ATF_TC(log10f_inf_neg); 178ATF_TC_HEAD(log10f_inf_neg, tc) 179{ 180 atf_tc_set_md_var(tc, "descr", "Test log10f(-Inf) == NaN"); 181} 182 183ATF_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 193ATF_TC(log10f_inf_pos); 194ATF_TC_HEAD(log10f_inf_pos, tc) 195{ 196 atf_tc_set_md_var(tc, "descr", "Test log10f(+Inf) == +Inf"); 197} 198 199ATF_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 208ATF_TC(log10f_one_pos); 209ATF_TC_HEAD(log10f_one_pos, tc) 210{ 211 atf_tc_set_md_var(tc, "descr", "Test log10f(1.0) == +0.0"); 212} 213 214ATF_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 226ATF_TC(log10f_zero_neg); 227ATF_TC_HEAD(log10f_zero_neg, tc) 228{ 229 atf_tc_set_md_var(tc, "descr", "Test log10f(-0.0) == -HUGE_VALF"); 230} 231 232ATF_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 241ATF_TC(log10f_zero_pos); 242ATF_TC_HEAD(log10f_zero_pos, tc) 243{ 244 atf_tc_set_md_var(tc, "descr", "Test log10f(+0.0) == -HUGE_VALF"); 245} 246 247ATF_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 */ 259ATF_TC(log1p_nan); 260ATF_TC_HEAD(log1p_nan, tc) 261{ 262 atf_tc_set_md_var(tc, "descr", "Test log1p(NaN) == NaN"); 263} 264 265ATF_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 275ATF_TC(log1p_inf_neg); 276ATF_TC_HEAD(log1p_inf_neg, tc) 277{ 278 atf_tc_set_md_var(tc, "descr", "Test log1p(-Inf) == NaN"); 279} 280 281ATF_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 294ATF_TC(log1p_inf_pos); 295ATF_TC_HEAD(log1p_inf_pos, tc) 296{ 297 atf_tc_set_md_var(tc, "descr", "Test log1p(+Inf) == +Inf"); 298} 299 300ATF_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 309ATF_TC(log1p_one_neg); 310ATF_TC_HEAD(log1p_one_neg, tc) 311{ 312 atf_tc_set_md_var(tc, "descr", "Test log1p(-1.0) == -HUGE_VAL"); 313} 314 315ATF_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 327ATF_TC(log1p_zero_neg); 328ATF_TC_HEAD(log1p_zero_neg, tc) 329{ 330 atf_tc_set_md_var(tc, "descr", "Test log1p(-0.0) == -0.0"); 331} 332 333ATF_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 342ATF_TC(log1p_zero_pos); 343ATF_TC_HEAD(log1p_zero_pos, tc) 344{ 345 atf_tc_set_md_var(tc, "descr", "Test log1p(+0.0) == +0.0"); 346} 347 348ATF_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 */ 360ATF_TC(log1pf_nan); 361ATF_TC_HEAD(log1pf_nan, tc) 362{ 363 atf_tc_set_md_var(tc, "descr", "Test log1pf(NaN) == NaN"); 364} 365 366ATF_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 376ATF_TC(log1pf_inf_neg); 377ATF_TC_HEAD(log1pf_inf_neg, tc) 378{ 379 atf_tc_set_md_var(tc, "descr", "Test log1pf(-Inf) == NaN"); 380} 381 382ATF_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 395ATF_TC(log1pf_inf_pos); 396ATF_TC_HEAD(log1pf_inf_pos, tc) 397{ 398 atf_tc_set_md_var(tc, "descr", "Test log1pf(+Inf) == +Inf"); 399} 400 401ATF_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 410ATF_TC(log1pf_one_neg); 411ATF_TC_HEAD(log1pf_one_neg, tc) 412{ 413 atf_tc_set_md_var(tc, "descr", "Test log1pf(-1.0) == -HUGE_VALF"); 414} 415 416ATF_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 428ATF_TC(log1pf_zero_neg); 429ATF_TC_HEAD(log1pf_zero_neg, tc) 430{ 431 atf_tc_set_md_var(tc, "descr", "Test log1pf(-0.0) == -0.0"); 432} 433 434ATF_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 443ATF_TC(log1pf_zero_pos); 444ATF_TC_HEAD(log1pf_zero_pos, tc) 445{ 446 atf_tc_set_md_var(tc, "descr", "Test log1pf(+0.0) == +0.0"); 447} 448 449ATF_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 */ 461ATF_TC(log2_base); 462ATF_TC_HEAD(log2_base, tc) 463{ 464 atf_tc_set_md_var(tc, "descr", "Test log2(2) == 1"); 465} 466 467ATF_TC_BODY(log2_base, tc) 468{ 469 ATF_CHECK(log2(2.0) == 1.0); 470} 471 472ATF_TC(log2_nan); 473ATF_TC_HEAD(log2_nan, tc) 474{ 475 atf_tc_set_md_var(tc, "descr", "Test log2(NaN) == NaN"); 476} 477 478ATF_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 488ATF_TC(log2_inf_neg); 489ATF_TC_HEAD(log2_inf_neg, tc) 490{ 491 atf_tc_set_md_var(tc, "descr", "Test log2(-Inf) == NaN"); 492} 493 494ATF_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 504ATF_TC(log2_inf_pos); 505ATF_TC_HEAD(log2_inf_pos, tc) 506{ 507 atf_tc_set_md_var(tc, "descr", "Test log2(+Inf) == +Inf"); 508} 509 510ATF_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 519ATF_TC(log2_one_pos); 520ATF_TC_HEAD(log2_one_pos, tc) 521{ 522 atf_tc_set_md_var(tc, "descr", "Test log2(1.0) == +0.0"); 523} 524 525ATF_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 537ATF_TC(log2_zero_neg); 538ATF_TC_HEAD(log2_zero_neg, tc) 539{ 540 atf_tc_set_md_var(tc, "descr", "Test log2(-0.0) == -HUGE_VAL"); 541} 542 543ATF_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 552ATF_TC(log2_zero_pos); 553ATF_TC_HEAD(log2_zero_pos, tc) 554{ 555 atf_tc_set_md_var(tc, "descr", "Test log2(+0.0) == -HUGE_VAL"); 556} 557 558ATF_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 */ 570ATF_TC(log2f_base); 571ATF_TC_HEAD(log2f_base, tc) 572{ 573 atf_tc_set_md_var(tc, "descr", "Test log2f(2) == 1"); 574} 575 576ATF_TC_BODY(log2f_base, tc) 577{ 578 ATF_CHECK(log2f(2.0) == 1.0); 579} 580 581ATF_TC(log2f_nan); 582ATF_TC_HEAD(log2f_nan, tc) 583{ 584 atf_tc_set_md_var(tc, "descr", "Test log2f(NaN) == NaN"); 585} 586 587ATF_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 597ATF_TC(log2f_inf_neg); 598ATF_TC_HEAD(log2f_inf_neg, tc) 599{ 600 atf_tc_set_md_var(tc, "descr", "Test log2f(-Inf) == NaN"); 601} 602 603ATF_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 613ATF_TC(log2f_inf_pos); 614ATF_TC_HEAD(log2f_inf_pos, tc) 615{ 616 atf_tc_set_md_var(tc, "descr", "Test log2f(+Inf) == +Inf"); 617} 618 619ATF_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 628ATF_TC(log2f_one_pos); 629ATF_TC_HEAD(log2f_one_pos, tc) 630{ 631 atf_tc_set_md_var(tc, "descr", "Test log2f(1.0) == +0.0"); 632} 633 634ATF_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 646ATF_TC(log2f_zero_neg); 647ATF_TC_HEAD(log2f_zero_neg, tc) 648{ 649 atf_tc_set_md_var(tc, "descr", "Test log2f(-0.0) == -HUGE_VALF"); 650} 651 652ATF_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 661ATF_TC(log2f_zero_pos); 662ATF_TC_HEAD(log2f_zero_pos, tc) 663{ 664 atf_tc_set_md_var(tc, "descr", "Test log2f(+0.0) == -HUGE_VALF"); 665} 666 667ATF_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 */ 679ATF_TC(log_base); 680ATF_TC_HEAD(log_base, tc) 681{ 682 atf_tc_set_md_var(tc, "descr", "Test log(e) == 1"); 683} 684 685ATF_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 693ATF_TC(log_nan); 694ATF_TC_HEAD(log_nan, tc) 695{ 696 atf_tc_set_md_var(tc, "descr", "Test log(NaN) == NaN"); 697} 698 699ATF_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 709ATF_TC(log_inf_neg); 710ATF_TC_HEAD(log_inf_neg, tc) 711{ 712 atf_tc_set_md_var(tc, "descr", "Test log(-Inf) == NaN"); 713} 714 715ATF_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 725ATF_TC(log_inf_pos); 726ATF_TC_HEAD(log_inf_pos, tc) 727{ 728 atf_tc_set_md_var(tc, "descr", "Test log(+Inf) == +Inf"); 729} 730 731ATF_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 740ATF_TC(log_one_pos); 741ATF_TC_HEAD(log_one_pos, tc) 742{ 743 atf_tc_set_md_var(tc, "descr", "Test log(1.0) == +0.0"); 744} 745 746ATF_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 758ATF_TC(log_zero_neg); 759ATF_TC_HEAD(log_zero_neg, tc) 760{ 761 atf_tc_set_md_var(tc, "descr", "Test log(-0.0) == -HUGE_VAL"); 762} 763 764ATF_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 773ATF_TC(log_zero_pos); 774ATF_TC_HEAD(log_zero_pos, tc) 775{ 776 atf_tc_set_md_var(tc, "descr", "Test log(+0.0) == -HUGE_VAL"); 777} 778 779ATF_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 */ 791ATF_TC(logf_base); 792ATF_TC_HEAD(logf_base, tc) 793{ 794 atf_tc_set_md_var(tc, "descr", "Test logf(e) == 1"); 795} 796 797ATF_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 805ATF_TC(logf_nan); 806ATF_TC_HEAD(logf_nan, tc) 807{ 808 atf_tc_set_md_var(tc, "descr", "Test logf(NaN) == NaN"); 809} 810 811ATF_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 821ATF_TC(logf_inf_neg); 822ATF_TC_HEAD(logf_inf_neg, tc) 823{ 824 atf_tc_set_md_var(tc, "descr", "Test logf(-Inf) == NaN"); 825} 826 827ATF_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 837ATF_TC(logf_inf_pos); 838ATF_TC_HEAD(logf_inf_pos, tc) 839{ 840 atf_tc_set_md_var(tc, "descr", "Test logf(+Inf) == +Inf"); 841} 842 843ATF_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 852ATF_TC(logf_one_pos); 853ATF_TC_HEAD(logf_one_pos, tc) 854{ 855 atf_tc_set_md_var(tc, "descr", "Test logf(1.0) == +0.0"); 856} 857 858ATF_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 870ATF_TC(logf_zero_neg); 871ATF_TC_HEAD(logf_zero_neg, tc) 872{ 873 atf_tc_set_md_var(tc, "descr", "Test logf(-0.0) == -HUGE_VALF"); 874} 875 876ATF_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 885ATF_TC(logf_zero_pos); 886ATF_TC_HEAD(logf_zero_pos, tc) 887{ 888 atf_tc_set_md_var(tc, "descr", "Test logf(+0.0) == -HUGE_VALF"); 889} 890 891ATF_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 900ATF_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