1276478Sngie/* $NetBSD: t_log.c,v 1.12 2014/11/04 00:20:19 justin Exp $ */ 2272343Sngie 3272343Sngie/*- 4272343Sngie * Copyright (c) 2011 The NetBSD Foundation, Inc. 5272343Sngie * All rights reserved. 6272343Sngie * 7272343Sngie * This code is derived from software contributed to The NetBSD Foundation 8272343Sngie * by Jukka Ruohonen. 9272343Sngie * 10272343Sngie * Redistribution and use in source and binary forms, with or without 11272343Sngie * modification, are permitted provided that the following conditions 12272343Sngie * are met: 13272343Sngie * 1. Redistributions of source code must retain the above copyright 14272343Sngie * notice, this list of conditions and the following disclaimer. 15272343Sngie * 2. Redistributions in binary form must reproduce the above copyright 16272343Sngie * notice, this list of conditions and the following disclaimer in the 17272343Sngie * documentation and/or other materials provided with the distribution. 18272343Sngie * 19272343Sngie * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20272343Sngie * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21272343Sngie * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22272343Sngie * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23272343Sngie * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24272343Sngie * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25272343Sngie * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26272343Sngie * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27272343Sngie * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28272343Sngie * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29272343Sngie * POSSIBILITY OF SUCH DAMAGE. 30272343Sngie */ 31272343Sngie#include <sys/cdefs.h> 32276478Sngie__RCSID("$NetBSD: t_log.c,v 1.12 2014/11/04 00:20:19 justin Exp $"); 33272343Sngie 34272343Sngie#include <atf-c.h> 35272343Sngie 36272343Sngie#include <math.h> 37272343Sngie#include <stdio.h> 38272343Sngie#include <string.h> 39272343Sngie 40272343Sngie/* 41272343Sngie * log10(3) 42272343Sngie */ 43272343SngieATF_TC(log10_base); 44272343SngieATF_TC_HEAD(log10_base, tc) 45272343Sngie{ 46272343Sngie atf_tc_set_md_var(tc, "descr", "Test log10(10) == 1"); 47272343Sngie} 48272343Sngie 49272343SngieATF_TC_BODY(log10_base, tc) 50272343Sngie{ 51272343Sngie ATF_CHECK(log10(10.0) == 1.0); 52272343Sngie} 53272343Sngie 54272343SngieATF_TC(log10_nan); 55272343SngieATF_TC_HEAD(log10_nan, tc) 56272343Sngie{ 57272343Sngie atf_tc_set_md_var(tc, "descr", "Test log10(NaN) == NaN"); 58272343Sngie} 59272343Sngie 60272343SngieATF_TC_BODY(log10_nan, tc) 61272343Sngie{ 62272343Sngie const double x = 0.0L / 0.0L; 63272343Sngie 64272343Sngie ATF_CHECK(isnan(x) != 0); 65272343Sngie ATF_CHECK(isnan(log10(x)) != 0); 66272343Sngie} 67272343Sngie 68272343SngieATF_TC(log10_inf_neg); 69272343SngieATF_TC_HEAD(log10_inf_neg, tc) 70272343Sngie{ 71272343Sngie atf_tc_set_md_var(tc, "descr", "Test log10(-Inf) == NaN"); 72272343Sngie} 73272343Sngie 74272343SngieATF_TC_BODY(log10_inf_neg, tc) 75272343Sngie{ 76272343Sngie const double x = -1.0L / 0.0L; 77272343Sngie const double y = log10(x); 78272343Sngie 79272343Sngie ATF_CHECK(isnan(y) != 0); 80272343Sngie} 81272343Sngie 82272343SngieATF_TC(log10_inf_pos); 83272343SngieATF_TC_HEAD(log10_inf_pos, tc) 84272343Sngie{ 85272343Sngie atf_tc_set_md_var(tc, "descr", "Test log10(+Inf) == +Inf"); 86272343Sngie} 87272343Sngie 88272343SngieATF_TC_BODY(log10_inf_pos, tc) 89272343Sngie{ 90272343Sngie const double x = 1.0L / 0.0L; 91272343Sngie 92272343Sngie ATF_CHECK(log10(x) == x); 93272343Sngie} 94272343Sngie 95272343SngieATF_TC(log10_one_pos); 96272343SngieATF_TC_HEAD(log10_one_pos, tc) 97272343Sngie{ 98272343Sngie atf_tc_set_md_var(tc, "descr", "Test log10(1.0) == +0.0"); 99272343Sngie} 100272343Sngie 101272343SngieATF_TC_BODY(log10_one_pos, tc) 102272343Sngie{ 103272343Sngie const double x = log10(1.0); 104272343Sngie const double y = 0.0L; 105272343Sngie 106272343Sngie ATF_CHECK(x == y); 107272343Sngie ATF_CHECK(signbit(x) == 0); 108272343Sngie ATF_CHECK(signbit(y) == 0); 109272343Sngie} 110272343Sngie 111272343SngieATF_TC(log10_zero_neg); 112272343SngieATF_TC_HEAD(log10_zero_neg, tc) 113272343Sngie{ 114272343Sngie atf_tc_set_md_var(tc, "descr", "Test log10(-0.0) == -HUGE_VAL"); 115272343Sngie} 116272343Sngie 117272343SngieATF_TC_BODY(log10_zero_neg, tc) 118272343Sngie{ 119272343Sngie const double x = -0.0L; 120272343Sngie 121272343Sngie ATF_CHECK(log10(x) == -HUGE_VAL); 122272343Sngie} 123272343Sngie 124272343SngieATF_TC(log10_zero_pos); 125272343SngieATF_TC_HEAD(log10_zero_pos, tc) 126272343Sngie{ 127272343Sngie atf_tc_set_md_var(tc, "descr", "Test log10(+0.0) == -HUGE_VAL"); 128272343Sngie} 129272343Sngie 130272343SngieATF_TC_BODY(log10_zero_pos, tc) 131272343Sngie{ 132272343Sngie const double x = 0.0L; 133272343Sngie 134272343Sngie ATF_CHECK(log10(x) == -HUGE_VAL); 135272343Sngie} 136272343Sngie 137272343Sngie/* 138272343Sngie * log10f(3) 139272343Sngie */ 140272343SngieATF_TC(log10f_base); 141272343SngieATF_TC_HEAD(log10f_base, tc) 142272343Sngie{ 143272343Sngie atf_tc_set_md_var(tc, "descr", "Test log10f(10) == 1"); 144272343Sngie} 145272343Sngie 146272343SngieATF_TC_BODY(log10f_base, tc) 147272343Sngie{ 148272343Sngie ATF_CHECK(log10f(10.0) == 1.0); 149272343Sngie} 150272343Sngie 151272343SngieATF_TC(log10f_nan); 152272343SngieATF_TC_HEAD(log10f_nan, tc) 153272343Sngie{ 154272343Sngie atf_tc_set_md_var(tc, "descr", "Test log10f(NaN) == NaN"); 155272343Sngie} 156272343Sngie 157272343SngieATF_TC_BODY(log10f_nan, tc) 158272343Sngie{ 159272343Sngie const float x = 0.0L / 0.0L; 160272343Sngie 161272343Sngie ATF_CHECK(isnan(x) != 0); 162272343Sngie ATF_CHECK(isnan(log10f(x)) != 0); 163272343Sngie} 164272343Sngie 165272343SngieATF_TC(log10f_inf_neg); 166272343SngieATF_TC_HEAD(log10f_inf_neg, tc) 167272343Sngie{ 168272343Sngie atf_tc_set_md_var(tc, "descr", "Test log10f(-Inf) == NaN"); 169272343Sngie} 170272343Sngie 171272343SngieATF_TC_BODY(log10f_inf_neg, tc) 172272343Sngie{ 173272343Sngie const float x = -1.0L / 0.0L; 174272343Sngie const float y = log10f(x); 175272343Sngie 176272343Sngie ATF_CHECK(isnan(y) != 0); 177272343Sngie} 178272343Sngie 179272343SngieATF_TC(log10f_inf_pos); 180272343SngieATF_TC_HEAD(log10f_inf_pos, tc) 181272343Sngie{ 182272343Sngie atf_tc_set_md_var(tc, "descr", "Test log10f(+Inf) == +Inf"); 183272343Sngie} 184272343Sngie 185272343SngieATF_TC_BODY(log10f_inf_pos, tc) 186272343Sngie{ 187272343Sngie const float x = 1.0L / 0.0L; 188272343Sngie 189272343Sngie#if defined(__alpha__) 190272343Sngie atf_tc_expect_fail("PR port-alpha/46301"); 191272343Sngie#endif 192272343Sngie 193272343Sngie ATF_CHECK(log10f(x) == x); 194272343Sngie} 195272343Sngie 196272343SngieATF_TC(log10f_one_pos); 197272343SngieATF_TC_HEAD(log10f_one_pos, tc) 198272343Sngie{ 199272343Sngie atf_tc_set_md_var(tc, "descr", "Test log10f(1.0) == +0.0"); 200272343Sngie} 201272343Sngie 202272343SngieATF_TC_BODY(log10f_one_pos, tc) 203272343Sngie{ 204272343Sngie const float x = log10f(1.0); 205272343Sngie const float y = 0.0L; 206272343Sngie 207272343Sngie ATF_CHECK(x == y); 208272343Sngie ATF_CHECK(signbit(x) == 0); 209272343Sngie ATF_CHECK(signbit(y) == 0); 210272343Sngie} 211272343Sngie 212272343SngieATF_TC(log10f_zero_neg); 213272343SngieATF_TC_HEAD(log10f_zero_neg, tc) 214272343Sngie{ 215272343Sngie atf_tc_set_md_var(tc, "descr", "Test log10f(-0.0) == -HUGE_VALF"); 216272343Sngie} 217272343Sngie 218272343SngieATF_TC_BODY(log10f_zero_neg, tc) 219272343Sngie{ 220272343Sngie const float x = -0.0L; 221272343Sngie 222272343Sngie ATF_CHECK(log10f(x) == -HUGE_VALF); 223272343Sngie} 224272343Sngie 225272343SngieATF_TC(log10f_zero_pos); 226272343SngieATF_TC_HEAD(log10f_zero_pos, tc) 227272343Sngie{ 228272343Sngie atf_tc_set_md_var(tc, "descr", "Test log10f(+0.0) == -HUGE_VALF"); 229272343Sngie} 230272343Sngie 231272343SngieATF_TC_BODY(log10f_zero_pos, tc) 232272343Sngie{ 233272343Sngie const float x = 0.0L; 234272343Sngie 235272343Sngie ATF_CHECK(log10f(x) == -HUGE_VALF); 236272343Sngie} 237272343Sngie 238272343Sngie/* 239272343Sngie * log1p(3) 240272343Sngie */ 241272343SngieATF_TC(log1p_nan); 242272343SngieATF_TC_HEAD(log1p_nan, tc) 243272343Sngie{ 244272343Sngie atf_tc_set_md_var(tc, "descr", "Test log1p(NaN) == NaN"); 245272343Sngie} 246272343Sngie 247272343SngieATF_TC_BODY(log1p_nan, tc) 248272343Sngie{ 249272343Sngie const double x = 0.0L / 0.0L; 250272343Sngie 251272343Sngie ATF_CHECK(isnan(x) != 0); 252272343Sngie ATF_CHECK(isnan(log1p(x)) != 0); 253272343Sngie} 254272343Sngie 255272343SngieATF_TC(log1p_inf_neg); 256272343SngieATF_TC_HEAD(log1p_inf_neg, tc) 257272343Sngie{ 258272343Sngie atf_tc_set_md_var(tc, "descr", "Test log1p(-Inf) == NaN"); 259272343Sngie} 260272343Sngie 261272343SngieATF_TC_BODY(log1p_inf_neg, tc) 262272343Sngie{ 263272343Sngie const double x = -1.0L / 0.0L; 264272343Sngie const double y = log1p(x); 265272343Sngie 266272343Sngie if (isnan(y) == 0) { 267272343Sngie atf_tc_expect_fail("PR lib/45362"); 268272343Sngie atf_tc_fail("log1p(-Inf) != NaN"); 269272343Sngie } 270272343Sngie} 271272343Sngie 272272343SngieATF_TC(log1p_inf_pos); 273272343SngieATF_TC_HEAD(log1p_inf_pos, tc) 274272343Sngie{ 275272343Sngie atf_tc_set_md_var(tc, "descr", "Test log1p(+Inf) == +Inf"); 276272343Sngie} 277272343Sngie 278272343SngieATF_TC_BODY(log1p_inf_pos, tc) 279272343Sngie{ 280272343Sngie const double x = 1.0L / 0.0L; 281272343Sngie 282272343Sngie ATF_CHECK(log1p(x) == x); 283272343Sngie} 284272343Sngie 285272343SngieATF_TC(log1p_one_neg); 286272343SngieATF_TC_HEAD(log1p_one_neg, tc) 287272343Sngie{ 288272343Sngie atf_tc_set_md_var(tc, "descr", "Test log1p(-1.0) == -HUGE_VAL"); 289272343Sngie} 290272343Sngie 291272343SngieATF_TC_BODY(log1p_one_neg, tc) 292272343Sngie{ 293272343Sngie const double x = log1p(-1.0); 294272343Sngie 295272343Sngie if (x != -HUGE_VAL) { 296272343Sngie atf_tc_expect_fail("PR lib/45362"); 297272343Sngie atf_tc_fail("log1p(-1.0) != -HUGE_VAL"); 298272343Sngie } 299272343Sngie} 300272343Sngie 301272343SngieATF_TC(log1p_zero_neg); 302272343SngieATF_TC_HEAD(log1p_zero_neg, tc) 303272343Sngie{ 304272343Sngie atf_tc_set_md_var(tc, "descr", "Test log1p(-0.0) == -0.0"); 305272343Sngie} 306272343Sngie 307272343SngieATF_TC_BODY(log1p_zero_neg, tc) 308272343Sngie{ 309272343Sngie const double x = -0.0L; 310272343Sngie 311272343Sngie ATF_CHECK(log1p(x) == x); 312272343Sngie} 313272343Sngie 314272343SngieATF_TC(log1p_zero_pos); 315272343SngieATF_TC_HEAD(log1p_zero_pos, tc) 316272343Sngie{ 317272343Sngie atf_tc_set_md_var(tc, "descr", "Test log1p(+0.0) == +0.0"); 318272343Sngie} 319272343Sngie 320272343SngieATF_TC_BODY(log1p_zero_pos, tc) 321272343Sngie{ 322272343Sngie const double x = 0.0L; 323272343Sngie 324272343Sngie ATF_CHECK(log1p(x) == x); 325272343Sngie} 326272343Sngie 327272343Sngie/* 328272343Sngie * log1pf(3) 329272343Sngie */ 330272343SngieATF_TC(log1pf_nan); 331272343SngieATF_TC_HEAD(log1pf_nan, tc) 332272343Sngie{ 333272343Sngie atf_tc_set_md_var(tc, "descr", "Test log1pf(NaN) == NaN"); 334272343Sngie} 335272343Sngie 336272343SngieATF_TC_BODY(log1pf_nan, tc) 337272343Sngie{ 338272343Sngie const float x = 0.0L / 0.0L; 339272343Sngie 340272343Sngie ATF_CHECK(isnan(x) != 0); 341272343Sngie ATF_CHECK(isnan(log1pf(x)) != 0); 342272343Sngie} 343272343Sngie 344272343SngieATF_TC(log1pf_inf_neg); 345272343SngieATF_TC_HEAD(log1pf_inf_neg, tc) 346272343Sngie{ 347272343Sngie atf_tc_set_md_var(tc, "descr", "Test log1pf(-Inf) == NaN"); 348272343Sngie} 349272343Sngie 350272343SngieATF_TC_BODY(log1pf_inf_neg, tc) 351272343Sngie{ 352272343Sngie const float x = -1.0L / 0.0L; 353272343Sngie const float y = log1pf(x); 354272343Sngie 355272343Sngie if (isnan(y) == 0) { 356272343Sngie atf_tc_expect_fail("PR lib/45362"); 357272343Sngie atf_tc_fail("log1pf(-Inf) != NaN"); 358272343Sngie } 359272343Sngie} 360272343Sngie 361272343SngieATF_TC(log1pf_inf_pos); 362272343SngieATF_TC_HEAD(log1pf_inf_pos, tc) 363272343Sngie{ 364272343Sngie atf_tc_set_md_var(tc, "descr", "Test log1pf(+Inf) == +Inf"); 365272343Sngie} 366272343Sngie 367272343SngieATF_TC_BODY(log1pf_inf_pos, tc) 368272343Sngie{ 369272343Sngie const float x = 1.0L / 0.0L; 370272343Sngie 371272343Sngie ATF_CHECK(log1pf(x) == x); 372272343Sngie} 373272343Sngie 374272343SngieATF_TC(log1pf_one_neg); 375272343SngieATF_TC_HEAD(log1pf_one_neg, tc) 376272343Sngie{ 377272343Sngie atf_tc_set_md_var(tc, "descr", "Test log1pf(-1.0) == -HUGE_VALF"); 378272343Sngie} 379272343Sngie 380272343SngieATF_TC_BODY(log1pf_one_neg, tc) 381272343Sngie{ 382272343Sngie const float x = log1pf(-1.0); 383272343Sngie 384272343Sngie if (x != -HUGE_VALF) { 385272343Sngie atf_tc_expect_fail("PR lib/45362"); 386272343Sngie atf_tc_fail("log1pf(-1.0) != -HUGE_VALF"); 387272343Sngie } 388272343Sngie} 389272343Sngie 390272343SngieATF_TC(log1pf_zero_neg); 391272343SngieATF_TC_HEAD(log1pf_zero_neg, tc) 392272343Sngie{ 393272343Sngie atf_tc_set_md_var(tc, "descr", "Test log1pf(-0.0) == -0.0"); 394272343Sngie} 395272343Sngie 396272343SngieATF_TC_BODY(log1pf_zero_neg, tc) 397272343Sngie{ 398272343Sngie const float x = -0.0L; 399272343Sngie 400272343Sngie ATF_CHECK(log1pf(x) == x); 401272343Sngie} 402272343Sngie 403272343SngieATF_TC(log1pf_zero_pos); 404272343SngieATF_TC_HEAD(log1pf_zero_pos, tc) 405272343Sngie{ 406272343Sngie atf_tc_set_md_var(tc, "descr", "Test log1pf(+0.0) == +0.0"); 407272343Sngie} 408272343Sngie 409272343SngieATF_TC_BODY(log1pf_zero_pos, tc) 410272343Sngie{ 411272343Sngie const float x = 0.0L; 412272343Sngie 413272343Sngie ATF_CHECK(log1pf(x) == x); 414272343Sngie} 415272343Sngie 416272343Sngie/* 417272343Sngie * log2(3) 418272343Sngie */ 419272343SngieATF_TC(log2_base); 420272343SngieATF_TC_HEAD(log2_base, tc) 421272343Sngie{ 422272343Sngie atf_tc_set_md_var(tc, "descr", "Test log2(2) == 1"); 423272343Sngie} 424272343Sngie 425272343SngieATF_TC_BODY(log2_base, tc) 426272343Sngie{ 427272343Sngie ATF_CHECK(log2(2.0) == 1.0); 428272343Sngie} 429272343Sngie 430272343SngieATF_TC(log2_nan); 431272343SngieATF_TC_HEAD(log2_nan, tc) 432272343Sngie{ 433272343Sngie atf_tc_set_md_var(tc, "descr", "Test log2(NaN) == NaN"); 434272343Sngie} 435272343Sngie 436272343SngieATF_TC_BODY(log2_nan, tc) 437272343Sngie{ 438272343Sngie const double x = 0.0L / 0.0L; 439272343Sngie 440272343Sngie ATF_CHECK(isnan(x) != 0); 441272343Sngie ATF_CHECK(isnan(log2(x)) != 0); 442272343Sngie} 443272343Sngie 444272343SngieATF_TC(log2_inf_neg); 445272343SngieATF_TC_HEAD(log2_inf_neg, tc) 446272343Sngie{ 447272343Sngie atf_tc_set_md_var(tc, "descr", "Test log2(-Inf) == NaN"); 448272343Sngie} 449272343Sngie 450272343SngieATF_TC_BODY(log2_inf_neg, tc) 451272343Sngie{ 452272343Sngie const double x = -1.0L / 0.0L; 453272343Sngie const double y = log2(x); 454272343Sngie 455272343Sngie ATF_CHECK(isnan(y) != 0); 456272343Sngie} 457272343Sngie 458272343SngieATF_TC(log2_inf_pos); 459272343SngieATF_TC_HEAD(log2_inf_pos, tc) 460272343Sngie{ 461272343Sngie atf_tc_set_md_var(tc, "descr", "Test log2(+Inf) == +Inf"); 462272343Sngie} 463272343Sngie 464272343SngieATF_TC_BODY(log2_inf_pos, tc) 465272343Sngie{ 466272343Sngie const double x = 1.0L / 0.0L; 467272343Sngie 468272343Sngie ATF_CHECK(log2(x) == x); 469272343Sngie} 470272343Sngie 471272343SngieATF_TC(log2_one_pos); 472272343SngieATF_TC_HEAD(log2_one_pos, tc) 473272343Sngie{ 474272343Sngie atf_tc_set_md_var(tc, "descr", "Test log2(1.0) == +0.0"); 475272343Sngie} 476272343Sngie 477272343SngieATF_TC_BODY(log2_one_pos, tc) 478272343Sngie{ 479272343Sngie const double x = log2(1.0); 480272343Sngie const double y = 0.0L; 481272343Sngie 482272343Sngie ATF_CHECK(x == y); 483272343Sngie ATF_CHECK(signbit(x) == 0); 484272343Sngie ATF_CHECK(signbit(y) == 0); 485272343Sngie} 486272343Sngie 487272343SngieATF_TC(log2_zero_neg); 488272343SngieATF_TC_HEAD(log2_zero_neg, tc) 489272343Sngie{ 490272343Sngie atf_tc_set_md_var(tc, "descr", "Test log2(-0.0) == -HUGE_VAL"); 491272343Sngie} 492272343Sngie 493272343SngieATF_TC_BODY(log2_zero_neg, tc) 494272343Sngie{ 495272343Sngie const double x = -0.0L; 496272343Sngie 497272343Sngie ATF_CHECK(log2(x) == -HUGE_VAL); 498272343Sngie} 499272343Sngie 500272343SngieATF_TC(log2_zero_pos); 501272343SngieATF_TC_HEAD(log2_zero_pos, tc) 502272343Sngie{ 503272343Sngie atf_tc_set_md_var(tc, "descr", "Test log2(+0.0) == -HUGE_VAL"); 504272343Sngie} 505272343Sngie 506272343SngieATF_TC_BODY(log2_zero_pos, tc) 507272343Sngie{ 508272343Sngie const double x = 0.0L; 509272343Sngie 510272343Sngie ATF_CHECK(log2(x) == -HUGE_VAL); 511272343Sngie} 512272343Sngie 513272343Sngie/* 514272343Sngie * log2f(3) 515272343Sngie */ 516272343SngieATF_TC(log2f_base); 517272343SngieATF_TC_HEAD(log2f_base, tc) 518272343Sngie{ 519272343Sngie atf_tc_set_md_var(tc, "descr", "Test log2f(2) == 1"); 520272343Sngie} 521272343Sngie 522272343SngieATF_TC_BODY(log2f_base, tc) 523272343Sngie{ 524272343Sngie ATF_CHECK(log2f(2.0) == 1.0); 525272343Sngie} 526272343Sngie 527272343SngieATF_TC(log2f_nan); 528272343SngieATF_TC_HEAD(log2f_nan, tc) 529272343Sngie{ 530272343Sngie atf_tc_set_md_var(tc, "descr", "Test log2f(NaN) == NaN"); 531272343Sngie} 532272343Sngie 533272343SngieATF_TC_BODY(log2f_nan, tc) 534272343Sngie{ 535272343Sngie const float x = 0.0L / 0.0L; 536272343Sngie 537272343Sngie ATF_CHECK(isnan(x) != 0); 538272343Sngie ATF_CHECK(isnan(log2f(x)) != 0); 539272343Sngie} 540272343Sngie 541272343SngieATF_TC(log2f_inf_neg); 542272343SngieATF_TC_HEAD(log2f_inf_neg, tc) 543272343Sngie{ 544272343Sngie atf_tc_set_md_var(tc, "descr", "Test log2f(-Inf) == NaN"); 545272343Sngie} 546272343Sngie 547272343SngieATF_TC_BODY(log2f_inf_neg, tc) 548272343Sngie{ 549272343Sngie const float x = -1.0L / 0.0L; 550272343Sngie const float y = log2f(x); 551272343Sngie 552272343Sngie ATF_CHECK(isnan(y) != 0); 553272343Sngie} 554272343Sngie 555272343SngieATF_TC(log2f_inf_pos); 556272343SngieATF_TC_HEAD(log2f_inf_pos, tc) 557272343Sngie{ 558272343Sngie atf_tc_set_md_var(tc, "descr", "Test log2f(+Inf) == +Inf"); 559272343Sngie} 560272343Sngie 561272343SngieATF_TC_BODY(log2f_inf_pos, tc) 562272343Sngie{ 563272343Sngie const float x = 1.0L / 0.0L; 564272343Sngie 565272343Sngie#if defined(__alpha__) 566272343Sngie atf_tc_expect_fail("PR port-alpha/46301"); 567272343Sngie#endif 568272343Sngie 569272343Sngie ATF_CHECK(log2f(x) == x); 570272343Sngie} 571272343Sngie 572272343SngieATF_TC(log2f_one_pos); 573272343SngieATF_TC_HEAD(log2f_one_pos, tc) 574272343Sngie{ 575272343Sngie atf_tc_set_md_var(tc, "descr", "Test log2f(1.0) == +0.0"); 576272343Sngie} 577272343Sngie 578272343SngieATF_TC_BODY(log2f_one_pos, tc) 579272343Sngie{ 580272343Sngie const float x = log2f(1.0); 581272343Sngie const float y = 0.0L; 582272343Sngie 583272343Sngie ATF_CHECK(x == y); 584272343Sngie ATF_CHECK(signbit(x) == 0); 585272343Sngie ATF_CHECK(signbit(y) == 0); 586272343Sngie} 587272343Sngie 588272343SngieATF_TC(log2f_zero_neg); 589272343SngieATF_TC_HEAD(log2f_zero_neg, tc) 590272343Sngie{ 591272343Sngie atf_tc_set_md_var(tc, "descr", "Test log2f(-0.0) == -HUGE_VALF"); 592272343Sngie} 593272343Sngie 594272343SngieATF_TC_BODY(log2f_zero_neg, tc) 595272343Sngie{ 596272343Sngie const float x = -0.0L; 597272343Sngie 598272343Sngie ATF_CHECK(log2f(x) == -HUGE_VALF); 599272343Sngie} 600272343Sngie 601272343SngieATF_TC(log2f_zero_pos); 602272343SngieATF_TC_HEAD(log2f_zero_pos, tc) 603272343Sngie{ 604272343Sngie atf_tc_set_md_var(tc, "descr", "Test log2f(+0.0) == -HUGE_VALF"); 605272343Sngie} 606272343Sngie 607272343SngieATF_TC_BODY(log2f_zero_pos, tc) 608272343Sngie{ 609272343Sngie const float x = 0.0L; 610272343Sngie 611272343Sngie ATF_CHECK(log2f(x) == -HUGE_VALF); 612272343Sngie} 613272343Sngie 614272343Sngie/* 615272343Sngie * log(3) 616272343Sngie */ 617272343SngieATF_TC(log_base); 618272343SngieATF_TC_HEAD(log_base, tc) 619272343Sngie{ 620272343Sngie atf_tc_set_md_var(tc, "descr", "Test log(e) == 1"); 621272343Sngie} 622272343Sngie 623272343SngieATF_TC_BODY(log_base, tc) 624272343Sngie{ 625272343Sngie const double eps = 1.0e-38; 626272343Sngie 627272343Sngie if (fabs(log(M_E) - 1.0) > eps) 628272343Sngie atf_tc_fail_nonfatal("log(e) != 1"); 629272343Sngie} 630272343Sngie 631272343SngieATF_TC(log_nan); 632272343SngieATF_TC_HEAD(log_nan, tc) 633272343Sngie{ 634272343Sngie atf_tc_set_md_var(tc, "descr", "Test log(NaN) == NaN"); 635272343Sngie} 636272343Sngie 637272343SngieATF_TC_BODY(log_nan, tc) 638272343Sngie{ 639272343Sngie const double x = 0.0L / 0.0L; 640272343Sngie 641272343Sngie ATF_CHECK(isnan(x) != 0); 642272343Sngie ATF_CHECK(isnan(log(x)) != 0); 643272343Sngie} 644272343Sngie 645272343SngieATF_TC(log_inf_neg); 646272343SngieATF_TC_HEAD(log_inf_neg, tc) 647272343Sngie{ 648272343Sngie atf_tc_set_md_var(tc, "descr", "Test log(-Inf) == NaN"); 649272343Sngie} 650272343Sngie 651272343SngieATF_TC_BODY(log_inf_neg, tc) 652272343Sngie{ 653272343Sngie const double x = -1.0L / 0.0L; 654272343Sngie const double y = log(x); 655272343Sngie 656272343Sngie ATF_CHECK(isnan(y) != 0); 657272343Sngie} 658272343Sngie 659272343SngieATF_TC(log_inf_pos); 660272343SngieATF_TC_HEAD(log_inf_pos, tc) 661272343Sngie{ 662272343Sngie atf_tc_set_md_var(tc, "descr", "Test log(+Inf) == +Inf"); 663272343Sngie} 664272343Sngie 665272343SngieATF_TC_BODY(log_inf_pos, tc) 666272343Sngie{ 667272343Sngie const double x = 1.0L / 0.0L; 668272343Sngie 669272343Sngie ATF_CHECK(log(x) == x); 670272343Sngie} 671272343Sngie 672272343SngieATF_TC(log_one_pos); 673272343SngieATF_TC_HEAD(log_one_pos, tc) 674272343Sngie{ 675272343Sngie atf_tc_set_md_var(tc, "descr", "Test log(1.0) == +0.0"); 676272343Sngie} 677272343Sngie 678272343SngieATF_TC_BODY(log_one_pos, tc) 679272343Sngie{ 680272343Sngie const double x = log(1.0); 681272343Sngie const double y = 0.0L; 682272343Sngie 683272343Sngie ATF_CHECK(x == y); 684272343Sngie ATF_CHECK(signbit(x) == 0); 685272343Sngie ATF_CHECK(signbit(y) == 0); 686272343Sngie} 687272343Sngie 688272343SngieATF_TC(log_zero_neg); 689272343SngieATF_TC_HEAD(log_zero_neg, tc) 690272343Sngie{ 691272343Sngie atf_tc_set_md_var(tc, "descr", "Test log(-0.0) == -HUGE_VAL"); 692272343Sngie} 693272343Sngie 694272343SngieATF_TC_BODY(log_zero_neg, tc) 695272343Sngie{ 696272343Sngie const double x = -0.0L; 697272343Sngie 698272343Sngie ATF_CHECK(log(x) == -HUGE_VAL); 699272343Sngie} 700272343Sngie 701272343SngieATF_TC(log_zero_pos); 702272343SngieATF_TC_HEAD(log_zero_pos, tc) 703272343Sngie{ 704272343Sngie atf_tc_set_md_var(tc, "descr", "Test log(+0.0) == -HUGE_VAL"); 705272343Sngie} 706272343Sngie 707272343SngieATF_TC_BODY(log_zero_pos, tc) 708272343Sngie{ 709272343Sngie const double x = 0.0L; 710272343Sngie 711272343Sngie ATF_CHECK(log(x) == -HUGE_VAL); 712272343Sngie} 713272343Sngie 714272343Sngie/* 715272343Sngie * logf(3) 716272343Sngie */ 717272343SngieATF_TC(logf_base); 718272343SngieATF_TC_HEAD(logf_base, tc) 719272343Sngie{ 720272343Sngie atf_tc_set_md_var(tc, "descr", "Test logf(e) == 1"); 721272343Sngie} 722272343Sngie 723272343SngieATF_TC_BODY(logf_base, tc) 724272343Sngie{ 725272343Sngie const float eps = 1.0e-7; 726272343Sngie 727272343Sngie if (fabsf(logf(M_E) - 1.0f) > eps) 728272343Sngie atf_tc_fail_nonfatal("logf(e) != 1"); 729272343Sngie} 730272343Sngie 731272343SngieATF_TC(logf_nan); 732272343SngieATF_TC_HEAD(logf_nan, tc) 733272343Sngie{ 734272343Sngie atf_tc_set_md_var(tc, "descr", "Test logf(NaN) == NaN"); 735272343Sngie} 736272343Sngie 737272343SngieATF_TC_BODY(logf_nan, tc) 738272343Sngie{ 739272343Sngie const float x = 0.0L / 0.0L; 740272343Sngie 741272343Sngie ATF_CHECK(isnan(x) != 0); 742272343Sngie ATF_CHECK(isnan(logf(x)) != 0); 743272343Sngie} 744272343Sngie 745272343SngieATF_TC(logf_inf_neg); 746272343SngieATF_TC_HEAD(logf_inf_neg, tc) 747272343Sngie{ 748272343Sngie atf_tc_set_md_var(tc, "descr", "Test logf(-Inf) == NaN"); 749272343Sngie} 750272343Sngie 751272343SngieATF_TC_BODY(logf_inf_neg, tc) 752272343Sngie{ 753272343Sngie const float x = -1.0L / 0.0L; 754272343Sngie const float y = logf(x); 755272343Sngie 756272343Sngie ATF_CHECK(isnan(y) != 0); 757272343Sngie} 758272343Sngie 759272343SngieATF_TC(logf_inf_pos); 760272343SngieATF_TC_HEAD(logf_inf_pos, tc) 761272343Sngie{ 762272343Sngie atf_tc_set_md_var(tc, "descr", "Test logf(+Inf) == +Inf"); 763272343Sngie} 764272343Sngie 765272343SngieATF_TC_BODY(logf_inf_pos, tc) 766272343Sngie{ 767272343Sngie const float x = 1.0L / 0.0L; 768272343Sngie 769272343Sngie#if defined(__alpha__) 770272343Sngie atf_tc_expect_fail("PR port-alpha/46301"); 771272343Sngie#endif 772272343Sngie 773272343Sngie ATF_CHECK(logf(x) == x); 774272343Sngie} 775272343Sngie 776272343SngieATF_TC(logf_one_pos); 777272343SngieATF_TC_HEAD(logf_one_pos, tc) 778272343Sngie{ 779272343Sngie atf_tc_set_md_var(tc, "descr", "Test logf(1.0) == +0.0"); 780272343Sngie} 781272343Sngie 782272343SngieATF_TC_BODY(logf_one_pos, tc) 783272343Sngie{ 784272343Sngie const float x = logf(1.0); 785272343Sngie const float y = 0.0L; 786272343Sngie 787272343Sngie ATF_CHECK(x == y); 788272343Sngie ATF_CHECK(signbit(x) == 0); 789272343Sngie ATF_CHECK(signbit(y) == 0); 790272343Sngie} 791272343Sngie 792272343SngieATF_TC(logf_zero_neg); 793272343SngieATF_TC_HEAD(logf_zero_neg, tc) 794272343Sngie{ 795272343Sngie atf_tc_set_md_var(tc, "descr", "Test logf(-0.0) == -HUGE_VALF"); 796272343Sngie} 797272343Sngie 798272343SngieATF_TC_BODY(logf_zero_neg, tc) 799272343Sngie{ 800272343Sngie const float x = -0.0L; 801272343Sngie 802272343Sngie ATF_CHECK(logf(x) == -HUGE_VALF); 803272343Sngie} 804272343Sngie 805272343SngieATF_TC(logf_zero_pos); 806272343SngieATF_TC_HEAD(logf_zero_pos, tc) 807272343Sngie{ 808272343Sngie atf_tc_set_md_var(tc, "descr", "Test logf(+0.0) == -HUGE_VALF"); 809272343Sngie} 810272343Sngie 811272343SngieATF_TC_BODY(logf_zero_pos, tc) 812272343Sngie{ 813272343Sngie const float x = 0.0L; 814272343Sngie 815272343Sngie ATF_CHECK(logf(x) == -HUGE_VALF); 816272343Sngie} 817272343Sngie 818272343SngieATF_TP_ADD_TCS(tp) 819272343Sngie{ 820272343Sngie 821272343Sngie ATF_TP_ADD_TC(tp, log10_base); 822272343Sngie ATF_TP_ADD_TC(tp, log10_nan); 823272343Sngie ATF_TP_ADD_TC(tp, log10_inf_neg); 824272343Sngie ATF_TP_ADD_TC(tp, log10_inf_pos); 825272343Sngie ATF_TP_ADD_TC(tp, log10_one_pos); 826272343Sngie ATF_TP_ADD_TC(tp, log10_zero_neg); 827272343Sngie ATF_TP_ADD_TC(tp, log10_zero_pos); 828272343Sngie 829272343Sngie ATF_TP_ADD_TC(tp, log10f_base); 830272343Sngie ATF_TP_ADD_TC(tp, log10f_nan); 831272343Sngie ATF_TP_ADD_TC(tp, log10f_inf_neg); 832272343Sngie ATF_TP_ADD_TC(tp, log10f_inf_pos); 833272343Sngie ATF_TP_ADD_TC(tp, log10f_one_pos); 834272343Sngie ATF_TP_ADD_TC(tp, log10f_zero_neg); 835272343Sngie ATF_TP_ADD_TC(tp, log10f_zero_pos); 836272343Sngie 837272343Sngie ATF_TP_ADD_TC(tp, log1p_nan); 838272343Sngie ATF_TP_ADD_TC(tp, log1p_inf_neg); 839272343Sngie ATF_TP_ADD_TC(tp, log1p_inf_pos); 840272343Sngie ATF_TP_ADD_TC(tp, log1p_one_neg); 841272343Sngie ATF_TP_ADD_TC(tp, log1p_zero_neg); 842272343Sngie ATF_TP_ADD_TC(tp, log1p_zero_pos); 843272343Sngie 844272343Sngie ATF_TP_ADD_TC(tp, log1pf_nan); 845272343Sngie ATF_TP_ADD_TC(tp, log1pf_inf_neg); 846272343Sngie ATF_TP_ADD_TC(tp, log1pf_inf_pos); 847272343Sngie ATF_TP_ADD_TC(tp, log1pf_one_neg); 848272343Sngie ATF_TP_ADD_TC(tp, log1pf_zero_neg); 849272343Sngie ATF_TP_ADD_TC(tp, log1pf_zero_pos); 850272343Sngie 851272343Sngie ATF_TP_ADD_TC(tp, log2_base); 852272343Sngie ATF_TP_ADD_TC(tp, log2_nan); 853272343Sngie ATF_TP_ADD_TC(tp, log2_inf_neg); 854272343Sngie ATF_TP_ADD_TC(tp, log2_inf_pos); 855272343Sngie ATF_TP_ADD_TC(tp, log2_one_pos); 856272343Sngie ATF_TP_ADD_TC(tp, log2_zero_neg); 857272343Sngie ATF_TP_ADD_TC(tp, log2_zero_pos); 858272343Sngie 859272343Sngie ATF_TP_ADD_TC(tp, log2f_base); 860272343Sngie ATF_TP_ADD_TC(tp, log2f_nan); 861272343Sngie ATF_TP_ADD_TC(tp, log2f_inf_neg); 862272343Sngie ATF_TP_ADD_TC(tp, log2f_inf_pos); 863272343Sngie ATF_TP_ADD_TC(tp, log2f_one_pos); 864272343Sngie ATF_TP_ADD_TC(tp, log2f_zero_neg); 865272343Sngie ATF_TP_ADD_TC(tp, log2f_zero_pos); 866272343Sngie 867272343Sngie ATF_TP_ADD_TC(tp, log_base); 868272343Sngie ATF_TP_ADD_TC(tp, log_nan); 869272343Sngie ATF_TP_ADD_TC(tp, log_inf_neg); 870272343Sngie ATF_TP_ADD_TC(tp, log_inf_pos); 871272343Sngie ATF_TP_ADD_TC(tp, log_one_pos); 872272343Sngie ATF_TP_ADD_TC(tp, log_zero_neg); 873272343Sngie ATF_TP_ADD_TC(tp, log_zero_pos); 874272343Sngie 875272343Sngie ATF_TP_ADD_TC(tp, logf_base); 876272343Sngie ATF_TP_ADD_TC(tp, logf_nan); 877272343Sngie ATF_TP_ADD_TC(tp, logf_inf_neg); 878272343Sngie ATF_TP_ADD_TC(tp, logf_inf_pos); 879272343Sngie ATF_TP_ADD_TC(tp, logf_one_pos); 880272343Sngie ATF_TP_ADD_TC(tp, logf_zero_neg); 881272343Sngie ATF_TP_ADD_TC(tp, logf_zero_pos); 882272343Sngie 883272343Sngie return atf_no_error(); 884272343Sngie} 885