math_test.cpp revision 4d77c1151c40010d137e4a2fa8629bff4bea72b0
1/* 2 * Copyright (C) 2013 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#define _DECLARE_C99_LDBL_MATH 1 18 19// This include (and the associated definition of __test_capture_signbit) 20// must be placed before any files that include <cmath> (gtest.h in this case). 21// 22// <math.h> is required to define generic macros signbit, isfinite and 23// several other such functions. 24// 25// <cmath> is required to undef declarations of these macros in the global 26// namespace and make equivalent functions available in namespace std. Our 27// stlport implementation does this only for signbit, isfinite, isinf and 28// isnan. 29// 30// NOTE: We don't write our test using std::signbit because we want to be 31// sure that we're testing the bionic version of signbit. The C++ libraries 32// are free to reimplement signbit or delegate to compiler builtins if they 33// please. 34#include <math.h> 35 36namespace { 37template<typename T> inline int test_capture_signbit(const T in) { 38 return signbit(in); 39} 40template<typename T> inline int test_capture_isfinite(const T in) { 41 return isfinite(in); 42} 43template<typename T> inline int test_capture_isnan(const T in) { 44 return isnan(in); 45} 46template<typename T> inline int test_capture_isinf(const T in) { 47 return isinf(in); 48} 49} 50 51#include <gtest/gtest.h> 52 53#include <fenv.h> 54#include <limits.h> 55#include <stdint.h> 56 57float float_subnormal() { 58 union { 59 float f; 60 uint32_t i; 61 } u; 62 u.i = 0x007fffff; 63 return u.f; 64} 65 66double double_subnormal() { 67 union { 68 double d; 69 uint64_t i; 70 } u; 71 u.i = 0x000fffffffffffffLL; 72 return u.d; 73} 74 75long double ldouble_subnormal() { 76 union { 77 long double e; 78 unsigned char c[sizeof(long double)]; 79 } u; 80 81 // Subnormals must have a zero exponent and non zero significand. 82 // On all supported representation the 17 bit (counting from either sides) 83 // is part of the significand so it should be enough to set that. 84 // It also applies for the case sizeof(double) = sizeof(long double) 85 for (unsigned int i = 0; i < sizeof(long double); i++) { 86 u.c[i] = 0x00; 87 } 88 u.c[sizeof(long double) - 3] = 0x80; 89 u.c[2] = 0x80; 90 91 return u.e; 92} 93 94TEST(math, fpclassify) { 95 ASSERT_EQ(FP_INFINITE, fpclassify(INFINITY)); 96 ASSERT_EQ(FP_INFINITE, fpclassify(HUGE_VALF)); 97 ASSERT_EQ(FP_INFINITE, fpclassify(HUGE_VAL)); 98 ASSERT_EQ(FP_INFINITE, fpclassify(HUGE_VALL)); 99 100 ASSERT_EQ(FP_NAN, fpclassify(nanf(""))); 101 ASSERT_EQ(FP_NAN, fpclassify(nan(""))); 102 ASSERT_EQ(FP_NAN, fpclassify(nanl(""))); 103 104 ASSERT_EQ(FP_NORMAL, fpclassify(1.0f)); 105 ASSERT_EQ(FP_NORMAL, fpclassify(1.0)); 106 ASSERT_EQ(FP_NORMAL, fpclassify(1.0l)); 107 108 ASSERT_EQ(FP_SUBNORMAL, fpclassify(float_subnormal())); 109 ASSERT_EQ(FP_SUBNORMAL, fpclassify(double_subnormal())); 110 ASSERT_EQ(FP_SUBNORMAL, fpclassify(ldouble_subnormal())); 111 112 ASSERT_EQ(FP_ZERO, fpclassify(0.0f)); 113 ASSERT_EQ(FP_ZERO, fpclassify(0.0)); 114 ASSERT_EQ(FP_ZERO, fpclassify(0.0l)); 115} 116 117TEST(math, isfinite) { 118 ASSERT_TRUE(test_capture_isfinite(123.0f)); 119 ASSERT_TRUE(test_capture_isfinite(123.0)); 120 ASSERT_TRUE(test_capture_isfinite(123.0l)); 121 ASSERT_FALSE(test_capture_isfinite(HUGE_VALF)); 122 ASSERT_FALSE(test_capture_isfinite(HUGE_VAL)); 123 ASSERT_FALSE(test_capture_isfinite(HUGE_VALL)); 124} 125 126TEST(math, isinf) { 127 ASSERT_FALSE(test_capture_isinf(123.0f)); 128 ASSERT_FALSE(test_capture_isinf(123.0)); 129 ASSERT_FALSE(test_capture_isinf(123.0l)); 130 ASSERT_TRUE(test_capture_isinf(HUGE_VALF)); 131 ASSERT_TRUE(test_capture_isinf(HUGE_VAL)); 132 ASSERT_TRUE(test_capture_isinf(HUGE_VALL)); 133} 134 135TEST(math, isnan) { 136 ASSERT_FALSE(test_capture_isnan(123.0f)); 137 ASSERT_FALSE(test_capture_isnan(123.0)); 138 ASSERT_FALSE(test_capture_isnan(123.0l)); 139 ASSERT_TRUE(test_capture_isnan(nanf(""))); 140 ASSERT_TRUE(test_capture_isnan(nan(""))); 141 ASSERT_TRUE(test_capture_isnan(nanl(""))); 142} 143 144TEST(math, isnormal) { 145 ASSERT_TRUE(isnormal(123.0f)); 146 ASSERT_TRUE(isnormal(123.0)); 147 ASSERT_TRUE(isnormal(123.0l)); 148 ASSERT_FALSE(isnormal(float_subnormal())); 149 ASSERT_FALSE(isnormal(double_subnormal())); 150 ASSERT_FALSE(isnormal(ldouble_subnormal())); 151} 152 153// TODO: isgreater, isgreaterequals, isless, islessequal, islessgreater, isunordered 154TEST(math, signbit) { 155 ASSERT_EQ(0, test_capture_signbit(0.0f)); 156 ASSERT_EQ(0, test_capture_signbit(0.0)); 157 ASSERT_EQ(0, test_capture_signbit(0.0l)); 158 159 ASSERT_EQ(0, test_capture_signbit(1.0f)); 160 ASSERT_EQ(0, test_capture_signbit(1.0)); 161 ASSERT_EQ(0, test_capture_signbit(1.0l)); 162 163 ASSERT_NE(0, test_capture_signbit(-1.0f)); 164 ASSERT_NE(0, test_capture_signbit(-1.0)); 165 ASSERT_NE(0, test_capture_signbit(-1.0l)); 166} 167 168TEST(math, __fpclassifyd) { 169#if defined(__BIONIC__) 170 ASSERT_EQ(FP_INFINITE, __fpclassifyd(HUGE_VAL)); 171 ASSERT_EQ(FP_NAN, __fpclassifyd(nan(""))); 172 ASSERT_EQ(FP_NORMAL, __fpclassifyd(1.0)); 173 ASSERT_EQ(FP_SUBNORMAL, __fpclassifyd(double_subnormal())); 174 ASSERT_EQ(FP_ZERO, __fpclassifyd(0.0)); 175#else // __BIONIC__ 176 GTEST_LOG_(INFO) << "This test does nothing.\n"; 177#endif // __BIONIC__ 178} 179 180TEST(math, __fpclassifyf) { 181#if defined(__BIONIC__) 182 ASSERT_EQ(FP_INFINITE, __fpclassifyf(HUGE_VALF)); 183 ASSERT_EQ(FP_NAN, __fpclassifyf(nanf(""))); 184 ASSERT_EQ(FP_NORMAL, __fpclassifyf(1.0f)); 185 ASSERT_EQ(FP_SUBNORMAL, __fpclassifyf(float_subnormal())); 186 ASSERT_EQ(FP_ZERO, __fpclassifyf(0.0f)); 187#else // __BIONIC__ 188 GTEST_LOG_(INFO) << "This test does nothing.\n"; 189#endif // __BIONIC__ 190} 191 192TEST(math, __fpclassifyl) { 193#if defined(__BIONIC__) 194 EXPECT_EQ(FP_INFINITE, __fpclassifyl(HUGE_VALL)); 195 EXPECT_EQ(FP_NAN, __fpclassifyl(nanl(""))); 196 EXPECT_EQ(FP_NORMAL, __fpclassifyl(1.0l)); 197 EXPECT_EQ(FP_SUBNORMAL, __fpclassifyl(ldouble_subnormal())); 198 EXPECT_EQ(FP_ZERO, __fpclassifyl(0.0l)); 199#else // __BIONIC__ 200 GTEST_LOG_(INFO) << "This test does nothing.\n"; 201#endif // __BIONIC__ 202} 203 204TEST(math, finitef) { 205 ASSERT_TRUE(finitef(123.0f)); 206 ASSERT_FALSE(finitef(HUGE_VALF)); 207} 208 209TEST(math, __isfinite) { 210#if defined(__BIONIC__) 211 ASSERT_TRUE(__isfinite(123.0)); 212 ASSERT_FALSE(__isfinite(HUGE_VAL)); 213#else // __BIONIC__ 214 GTEST_LOG_(INFO) << "This test does nothing.\n"; 215#endif // __BIONIC__ 216} 217 218TEST(math, __isfinitef) { 219#if defined(__BIONIC__) 220 ASSERT_TRUE(__isfinitef(123.0f)); 221 ASSERT_FALSE(__isfinitef(HUGE_VALF)); 222#else // __BIONIC__ 223 GTEST_LOG_(INFO) << "This test does nothing.\n"; 224#endif // __BIONIC__ 225} 226 227TEST(math, __isfinitel) { 228#if defined(__BIONIC__) 229 ASSERT_TRUE(__isfinitel(123.0l)); 230 ASSERT_FALSE(__isfinitel(HUGE_VALL)); 231#else // __BIONIC__ 232 GTEST_LOG_(INFO) << "This test does nothing.\n"; 233#endif // __BIONIC__ 234} 235 236TEST(math, finite) { 237 ASSERT_TRUE(finite(123.0)); 238 ASSERT_FALSE(finite(HUGE_VAL)); 239} 240 241TEST(math, __isinff) { 242 ASSERT_FALSE(__isinff(123.0f)); 243 ASSERT_TRUE(__isinff(HUGE_VALF)); 244} 245 246TEST(math, __isinfl) { 247 ASSERT_FALSE(__isinfl(123.0l)); 248 ASSERT_TRUE(__isinfl(HUGE_VALL)); 249} 250 251TEST(math, __isnanf) { 252 ASSERT_FALSE(__isnanf(123.0f)); 253 ASSERT_TRUE(__isnanf(nanf(""))); 254} 255 256TEST(math, __isnanl) { 257 ASSERT_FALSE(__isnanl(123.0l)); 258 ASSERT_TRUE(__isnanl(nanl(""))); 259} 260 261TEST(math, isnanf) { 262 ASSERT_FALSE(isnanf(123.0f)); 263 ASSERT_TRUE(isnanf(nanf(""))); 264} 265 266TEST(math, __isnormal) { 267#if defined(__BIONIC__) 268 ASSERT_TRUE(__isnormal(123.0)); 269 ASSERT_FALSE(__isnormal(double_subnormal())); 270#else // __BIONIC__ 271 GTEST_LOG_(INFO) << "This test does nothing.\n"; 272#endif // __BIONIC__ 273} 274 275TEST(math, __isnormalf) { 276#if defined(__BIONIC__) 277 ASSERT_TRUE(__isnormalf(123.0f)); 278 ASSERT_FALSE(__isnormalf(float_subnormal())); 279#else // __BIONIC__ 280 GTEST_LOG_(INFO) << "This test does nothing.\n"; 281#endif // __BIONIC__ 282} 283 284TEST(math, __isnormall) { 285#if defined(__BIONIC__) 286 ASSERT_TRUE(__isnormall(123.0l)); 287 ASSERT_FALSE(__isnormall(ldouble_subnormal())); 288#else // __BIONIC__ 289 GTEST_LOG_(INFO) << "This test does nothing.\n"; 290#endif // __BIONIC__ 291} 292 293TEST(math, __signbit) { 294 ASSERT_EQ(0, __signbit(0.0)); 295 ASSERT_EQ(0, __signbit(1.0)); 296 ASSERT_NE(0, __signbit(-1.0)); 297} 298 299TEST(math, __signbitf) { 300 ASSERT_EQ(0, __signbitf(0.0f)); 301 ASSERT_EQ(0, __signbitf(1.0f)); 302 ASSERT_NE(0, __signbitf(-1.0f)); 303} 304 305TEST(math, __signbitl) { 306 ASSERT_EQ(0l, __signbitl(0.0l)); 307 ASSERT_EQ(0l, __signbitl(1.0l)); 308 ASSERT_NE(0l, __signbitl(-1.0l)); 309} 310 311TEST(math, acos) { 312 ASSERT_DOUBLE_EQ(M_PI/2.0, acos(0.0)); 313} 314 315TEST(math, acosf) { 316 ASSERT_FLOAT_EQ(static_cast<float>(M_PI)/2.0f, acosf(0.0f)); 317} 318 319TEST(math, acosl) { 320 ASSERT_DOUBLE_EQ(M_PI/2.0l, acosl(0.0l)); 321} 322 323TEST(math, asin) { 324 ASSERT_DOUBLE_EQ(0.0, asin(0.0)); 325} 326 327TEST(math, asinf) { 328 ASSERT_FLOAT_EQ(0.0f, asinf(0.0f)); 329} 330 331TEST(math, asinl) { 332 ASSERT_DOUBLE_EQ(0.0l, asinl(0.0l)); 333} 334 335TEST(math, atan) { 336 ASSERT_DOUBLE_EQ(0.0, atan(0.0)); 337} 338 339TEST(math, atanf) { 340 ASSERT_FLOAT_EQ(0.0f, atanf(0.0f)); 341} 342 343TEST(math, atanl) { 344 ASSERT_DOUBLE_EQ(0.0l, atanl(0.0l)); 345} 346 347TEST(math, atan2) { 348 ASSERT_DOUBLE_EQ(0.0, atan2(0.0, 0.0)); 349} 350 351TEST(math, atan2f) { 352 ASSERT_FLOAT_EQ(0.0f, atan2f(0.0f, 0.0f)); 353} 354 355TEST(math, atan2l) { 356 ASSERT_DOUBLE_EQ(0.0l, atan2l(0.0l, 0.0l)); 357} 358 359TEST(math, cos) { 360 ASSERT_DOUBLE_EQ(1.0, cos(0.0)); 361} 362 363TEST(math, cosf) { 364 ASSERT_FLOAT_EQ(1.0f, cosf(0.0f)); 365} 366 367TEST(math, cosl) { 368 ASSERT_DOUBLE_EQ(1.0l, cosl(0.0l)); 369} 370 371TEST(math, sin) { 372 ASSERT_FLOAT_EQ(0.0, sin(0.0)); 373} 374 375TEST(math, sinf) { 376 ASSERT_FLOAT_EQ(0.0f, sinf(0.0f)); 377} 378 379TEST(math, sinl) { 380 ASSERT_DOUBLE_EQ(0.0l, sinl(0.0l)); 381} 382 383TEST(math, tan) { 384 ASSERT_DOUBLE_EQ(0.0, tan(0.0)); 385} 386 387TEST(math, tanf) { 388 ASSERT_FLOAT_EQ(0.0f, tanf(0.0f)); 389} 390 391TEST(math, tanl) { 392 ASSERT_DOUBLE_EQ(0.0l, tanl(0.0l)); 393} 394 395TEST(math, acosh) { 396 ASSERT_DOUBLE_EQ(0.0, acosh(1.0)); 397} 398 399TEST(math, acoshf) { 400 ASSERT_FLOAT_EQ(0.0f, acoshf(1.0f)); 401} 402 403TEST(math, acoshl) { 404 ASSERT_DOUBLE_EQ(0.0l, acoshl(1.0l)); 405} 406 407TEST(math, asinh) { 408 ASSERT_DOUBLE_EQ(0.0, asinh(0.0)); 409} 410 411TEST(math, asinhf) { 412 ASSERT_FLOAT_EQ(0.0f, asinhf(0.0f)); 413} 414 415TEST(math, asinhl) { 416 ASSERT_DOUBLE_EQ(0.0l, asinhl(0.0l)); 417} 418 419TEST(math, atanh) { 420 ASSERT_DOUBLE_EQ(0.0, atanh(0.0)); 421} 422 423TEST(math, atanhf) { 424 ASSERT_FLOAT_EQ(0.0f, atanhf(0.0f)); 425} 426 427TEST(math, atanhl) { 428 ASSERT_DOUBLE_EQ(0.0l, atanhl(0.0l)); 429} 430 431TEST(math, cosh) { 432 ASSERT_DOUBLE_EQ(1.0, cosh(0.0)); 433} 434 435TEST(math, coshf) { 436 ASSERT_FLOAT_EQ(1.0f, coshf(0.0f)); 437} 438 439TEST(math, coshl) { 440 ASSERT_DOUBLE_EQ(1.0l, coshl(0.0l)); 441} 442 443TEST(math, sinh) { 444 ASSERT_DOUBLE_EQ(0.0, sinh(0.0)); 445} 446 447TEST(math, sinhf) { 448 ASSERT_FLOAT_EQ(0.0f, sinhf(0.0f)); 449} 450 451TEST(math, sinhl) { 452 ASSERT_DOUBLE_EQ(0.0l, sinhl(0.0l)); 453} 454 455TEST(math, tanh) { 456 ASSERT_DOUBLE_EQ(0.0, tanh(0.0)); 457} 458 459TEST(math, tanhf) { 460 ASSERT_FLOAT_EQ(0.0f, tanhf(0.0f)); 461} 462 463TEST(math, tanhl) { 464 ASSERT_DOUBLE_EQ(0.0l, tanhl(0.0l)); 465} 466 467TEST(math, log) { 468 ASSERT_DOUBLE_EQ(1.0, log(M_E)); 469} 470 471TEST(math, logf) { 472 ASSERT_FLOAT_EQ(1.0f, logf(static_cast<float>(M_E))); 473} 474 475TEST(math, logl) { 476 ASSERT_DOUBLE_EQ(1.0l, logl(M_E)); 477} 478 479TEST(math, log2) { 480 ASSERT_DOUBLE_EQ(12.0, log2(4096.0)); 481} 482 483TEST(math, log2f) { 484 ASSERT_FLOAT_EQ(12.0f, log2f(4096.0f)); 485} 486 487TEST(math, log2l) { 488 ASSERT_DOUBLE_EQ(12.0l, log2l(4096.0l)); 489} 490 491TEST(math, log10) { 492 ASSERT_DOUBLE_EQ(3.0, log10(1000.0)); 493} 494 495TEST(math, log10f) { 496 ASSERT_FLOAT_EQ(3.0f, log10f(1000.0f)); 497} 498 499TEST(math, log10l) { 500 ASSERT_DOUBLE_EQ(3.0l, log10l(1000.0l)); 501} 502 503TEST(math, cbrt) { 504 ASSERT_DOUBLE_EQ(3.0, cbrt(27.0)); 505} 506 507TEST(math, cbrtf) { 508 ASSERT_FLOAT_EQ(3.0f, cbrtf(27.0f)); 509} 510 511TEST(math, cbrtl) { 512 ASSERT_DOUBLE_EQ(3.0l, cbrtl(27.0l)); 513} 514 515TEST(math, sqrt) { 516 ASSERT_DOUBLE_EQ(2.0, sqrt(4.0)); 517} 518 519TEST(math, sqrtf) { 520 ASSERT_FLOAT_EQ(2.0f, sqrtf(4.0f)); 521} 522 523TEST(math, sqrtl) { 524 ASSERT_DOUBLE_EQ(2.0l, sqrtl(4.0l)); 525} 526 527TEST(math, exp) { 528 ASSERT_DOUBLE_EQ(1.0, exp(0.0)); 529 ASSERT_DOUBLE_EQ(M_E, exp(1.0)); 530} 531 532TEST(math, expf) { 533 ASSERT_FLOAT_EQ(1.0f, expf(0.0f)); 534 ASSERT_FLOAT_EQ(static_cast<float>(M_E), expf(1.0f)); 535} 536 537TEST(math, expl) { 538 ASSERT_DOUBLE_EQ(1.0l, expl(0.0l)); 539 ASSERT_DOUBLE_EQ(M_E, expl(1.0l)); 540} 541 542TEST(math, exp2) { 543 ASSERT_DOUBLE_EQ(8.0, exp2(3.0)); 544} 545 546TEST(math, exp2f) { 547 ASSERT_FLOAT_EQ(8.0f, exp2f(3.0f)); 548} 549 550TEST(math, exp2l) { 551 ASSERT_DOUBLE_EQ(8.0l, exp2l(3.0l)); 552} 553 554TEST(math, expm1) { 555 ASSERT_DOUBLE_EQ(M_E - 1.0, expm1(1.0)); 556} 557 558TEST(math, expm1f) { 559 ASSERT_FLOAT_EQ(static_cast<float>(M_E) - 1.0f, expm1f(1.0f)); 560} 561 562TEST(math, expm1l) { 563 ASSERT_DOUBLE_EQ(M_E - 1.0l, expm1l(1.0l)); 564} 565 566TEST(math, pow) { 567 ASSERT_TRUE(isnan(pow(nan(""), 3.0))); 568 ASSERT_DOUBLE_EQ(1.0, (pow(1.0, nan("")))); 569 ASSERT_TRUE(isnan(pow(2.0, nan("")))); 570 ASSERT_DOUBLE_EQ(8.0, pow(2.0, 3.0)); 571} 572 573TEST(math, powf) { 574 ASSERT_TRUE(isnanf(powf(nanf(""), 3.0f))); 575 ASSERT_FLOAT_EQ(1.0f, (powf(1.0f, nanf("")))); 576 ASSERT_TRUE(isnanf(powf(2.0f, nanf("")))); 577 ASSERT_FLOAT_EQ(8.0f, powf(2.0f, 3.0f)); 578} 579 580TEST(math, powl) { 581 ASSERT_TRUE(__isnanl(powl(nanl(""), 3.0l))); 582 ASSERT_DOUBLE_EQ(1.0l, (powl(1.0l, nanl("")))); 583 ASSERT_TRUE(__isnanl(powl(2.0l, nanl("")))); 584 ASSERT_DOUBLE_EQ(8.0l, powl(2.0l, 3.0l)); 585} 586 587TEST(math, ceil) { 588 ASSERT_DOUBLE_EQ(1.0, ceil(0.9)); 589} 590 591TEST(math, ceilf) { 592 ASSERT_FLOAT_EQ(1.0f, ceilf(0.9f)); 593} 594 595TEST(math, ceill) { 596 ASSERT_DOUBLE_EQ(1.0, ceill(0.9l)); 597} 598 599TEST(math, floor) { 600 ASSERT_DOUBLE_EQ(1.0, floor(1.1)); 601} 602 603TEST(math, floorf) { 604 ASSERT_FLOAT_EQ(1.0f, floorf(1.1f)); 605} 606 607TEST(math, floorl) { 608 ASSERT_DOUBLE_EQ(1.0l, floorl(1.1l)); 609} 610 611TEST(math, fabs) { 612 ASSERT_DOUBLE_EQ(1.0, fabs(-1.0)); 613} 614 615TEST(math, fabsf) { 616 ASSERT_FLOAT_EQ(1.0f, fabsf(-1.0f)); 617} 618 619TEST(math, fabsl) { 620 ASSERT_DOUBLE_EQ(1.0l, fabsl(-1.0l)); 621} 622 623TEST(math, ldexp) { 624 ASSERT_DOUBLE_EQ(16.0, ldexp(2.0, 3.0)); 625} 626 627TEST(math, ldexpf) { 628 ASSERT_FLOAT_EQ(16.0f, ldexpf(2.0f, 3.0f)); 629} 630 631TEST(math, ldexpl) { 632 ASSERT_DOUBLE_EQ(16.0l, ldexpl(2.0l, 3.0)); 633} 634 635TEST(math, fmod) { 636 ASSERT_DOUBLE_EQ(2.0, fmod(12.0, 10.0)); 637} 638 639TEST(math, fmodf) { 640 ASSERT_FLOAT_EQ(2.0f, fmodf(12.0f, 10.0f)); 641} 642 643TEST(math, fmodl) { 644 ASSERT_DOUBLE_EQ(2.0l, fmodl(12.0l, 10.0l)); 645} 646 647TEST(math, remainder) { 648 ASSERT_DOUBLE_EQ(2.0, remainder(12.0, 10.0)); 649} 650 651TEST(math, remainderf) { 652 ASSERT_FLOAT_EQ(2.0f, remainderf(12.0f, 10.0f)); 653} 654 655TEST(math, remainderl) { 656 ASSERT_DOUBLE_EQ(2.0l, remainderl(12.0l, 10.0l)); 657} 658 659TEST(math, drem) { 660 ASSERT_DOUBLE_EQ(2.0, drem(12.0, 10.0)); 661} 662 663TEST(math, dremf) { 664 ASSERT_FLOAT_EQ(2.0f, dremf(12.0f, 10.0f)); 665} 666 667TEST(math, fmax) { 668 ASSERT_DOUBLE_EQ(12.0, fmax(12.0, 10.0)); 669 ASSERT_DOUBLE_EQ(12.0, fmax(12.0, nan(""))); 670 ASSERT_DOUBLE_EQ(12.0, fmax(nan(""), 12.0)); 671} 672 673TEST(math, fmaxf) { 674 ASSERT_FLOAT_EQ(12.0f, fmaxf(12.0f, 10.0f)); 675 ASSERT_FLOAT_EQ(12.0f, fmaxf(12.0f, nanf(""))); 676 ASSERT_FLOAT_EQ(12.0f, fmaxf(nanf(""), 12.0f)); 677} 678 679TEST(math, fmaxl) { 680 ASSERT_DOUBLE_EQ(12.0l, fmaxl(12.0l, 10.0l)); 681 ASSERT_DOUBLE_EQ(12.0l, fmaxl(12.0l, nanl(""))); 682 ASSERT_DOUBLE_EQ(12.0l, fmaxl(nanl(""), 12.0l)); 683} 684 685TEST(math, fmin) { 686 ASSERT_DOUBLE_EQ(10.0, fmin(12.0, 10.0)); 687 ASSERT_DOUBLE_EQ(12.0, fmin(12.0, nan(""))); 688 ASSERT_DOUBLE_EQ(12.0, fmin(nan(""), 12.0)); 689} 690 691TEST(math, fminf) { 692 ASSERT_FLOAT_EQ(10.0f, fminf(12.0f, 10.0f)); 693 ASSERT_FLOAT_EQ(12.0f, fminf(12.0f, nanf(""))); 694 ASSERT_FLOAT_EQ(12.0f, fminf(nanf(""), 12.0f)); 695} 696 697TEST(math, fminl) { 698 ASSERT_DOUBLE_EQ(10.0l, fminl(12.0l, 10.0l)); 699 ASSERT_DOUBLE_EQ(12.0l, fminl(12.0l, nanl(""))); 700 ASSERT_DOUBLE_EQ(12.0l, fminl(nanl(""), 12.0l)); 701} 702 703TEST(math, fma) { 704 ASSERT_DOUBLE_EQ(10.0, fma(2.0, 3.0, 4.0)); 705} 706 707TEST(math, fmaf) { 708 ASSERT_FLOAT_EQ(10.0f, fmaf(2.0f, 3.0f, 4.0f)); 709} 710 711TEST(math, fmal) { 712 ASSERT_DOUBLE_EQ(10.0l, fmal(2.0l, 3.0l, 4.0l)); 713} 714 715TEST(math, hypot) { 716 ASSERT_DOUBLE_EQ(5.0, hypot(3.0, 4.0)); 717} 718 719TEST(math, hypotf) { 720 ASSERT_FLOAT_EQ(5.0f, hypotf(3.0f, 4.0f)); 721} 722 723TEST(math, hypotl) { 724 ASSERT_DOUBLE_EQ(5.0l, hypotl(3.0l, 4.0l)); 725} 726 727TEST(math, erf) { 728 ASSERT_DOUBLE_EQ(0.84270079294971489, erf(1.0)); 729} 730 731TEST(math, erff) { 732 ASSERT_FLOAT_EQ(0.84270078f, erff(1.0f)); 733} 734 735TEST(math, erfl) { 736 ASSERT_DOUBLE_EQ(0.84270079294971489l, erfl(1.0l)); 737} 738 739TEST(math, erfc) { 740 ASSERT_DOUBLE_EQ(0.15729920705028513, erfc(1.0)); 741} 742 743TEST(math, erfcf) { 744 ASSERT_FLOAT_EQ(0.15729921f, erfcf(1.0f)); 745} 746 747TEST(math, erfcl) { 748 ASSERT_DOUBLE_EQ(0.15729920705028513l, erfcl(1.0l)); 749} 750 751TEST(math, lrint) { 752 fesetround(FE_UPWARD); // lrint/lrintf/lrintl obey the rounding mode. 753 ASSERT_EQ(1235, lrint(1234.01)); 754 ASSERT_EQ(1235, lrintf(1234.01f)); 755 ASSERT_EQ(1235, lrintl(1234.01l)); 756 fesetround(FE_TOWARDZERO); // lrint/lrintf/lrintl obey the rounding mode. 757 ASSERT_EQ(1234, lrint(1234.01)); 758 ASSERT_EQ(1234, lrintf(1234.01f)); 759 ASSERT_EQ(1234, lrintl(1234.01l)); 760 761 fesetround(FE_UPWARD); // llrint/llrintf/llrintl obey the rounding mode. 762 ASSERT_EQ(1235L, llrint(1234.01)); 763 ASSERT_EQ(1235L, llrintf(1234.01f)); 764 ASSERT_EQ(1235L, llrintl(1234.01l)); 765 fesetround(FE_TOWARDZERO); // llrint/llrintf/llrintl obey the rounding mode. 766 ASSERT_EQ(1234L, llrint(1234.01)); 767 ASSERT_EQ(1234L, llrintf(1234.01f)); 768 ASSERT_EQ(1234L, llrintl(1234.01l)); 769} 770 771TEST(math, rint) { 772 fesetround(FE_UPWARD); // rint/rintf/rintl obey the rounding mode. 773 feclearexcept(FE_ALL_EXCEPT); // rint/rintf/rintl do set the FE_INEXACT flag. 774 ASSERT_EQ(1234.0, rint(1234.0)); 775 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 776 ASSERT_EQ(1235.0, rint(1234.01)); 777 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) != 0); 778 779 feclearexcept(FE_ALL_EXCEPT); // rint/rintf/rintl do set the FE_INEXACT flag. 780 ASSERT_EQ(1234.0f, rintf(1234.0f)); 781 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 782 ASSERT_EQ(1235.0f, rintf(1234.01f)); 783 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) != 0); 784 785 feclearexcept(FE_ALL_EXCEPT); // rint/rintf/rintl do set the FE_INEXACT flag. 786 ASSERT_EQ(1234.0, rintl(1234.0l)); 787 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 788 ASSERT_EQ(1235.0, rintl(1234.01l)); 789 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) != 0); 790 791 fesetround(FE_TOWARDZERO); // rint/rintf obey the rounding mode. 792 ASSERT_EQ(1234.0, rint(1234.01)); 793 ASSERT_EQ(1234.0f, rintf(1234.01f)); 794 ASSERT_EQ(1234.0, rintl(1234.01l)); 795} 796 797TEST(math, nearbyint) { 798 fesetround(FE_UPWARD); // nearbyint/nearbyintf/nearbyintl obey the rounding mode. 799 feclearexcept(FE_ALL_EXCEPT); // nearbyint/nearbyintf/nearbyintl don't set the FE_INEXACT flag. 800 ASSERT_EQ(1234.0, nearbyint(1234.0)); 801 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 802 ASSERT_EQ(1235.0, nearbyint(1234.01)); 803 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 804 805 feclearexcept(FE_ALL_EXCEPT); 806 ASSERT_EQ(1234.0f, nearbyintf(1234.0f)); 807 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 808 ASSERT_EQ(1235.0f, nearbyintf(1234.01f)); 809 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 810 811 feclearexcept(FE_ALL_EXCEPT); // nearbyint/nearbyintf/nearbyintl don't set the FE_INEXACT flag. 812 ASSERT_EQ(1234.0, nearbyintl(1234.0l)); 813 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 814 ASSERT_EQ(1235.0, nearbyintl(1234.01l)); 815 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 816 817 fesetround(FE_TOWARDZERO); // nearbyint/nearbyintf/nearbyintl obey the rounding mode. 818 ASSERT_EQ(1234.0, nearbyint(1234.01)); 819 ASSERT_EQ(1234.0f, nearbyintf(1234.01f)); 820 ASSERT_EQ(1234.0, nearbyintl(1234.01l)); 821} 822 823TEST(math, lround) { 824 fesetround(FE_UPWARD); // lround ignores the rounding mode. 825 ASSERT_EQ(1234, lround(1234.01)); 826 ASSERT_EQ(1234, lroundf(1234.01f)); 827 ASSERT_EQ(1234, lroundl(1234.01l)); 828} 829 830TEST(math, llround) { 831 fesetround(FE_UPWARD); // llround ignores the rounding mode. 832 ASSERT_EQ(1234L, llround(1234.01)); 833 ASSERT_EQ(1234L, llroundf(1234.01f)); 834 ASSERT_EQ(1234L, llroundl(1234.01l)); 835} 836 837TEST(math, ilogb) { 838 ASSERT_EQ(FP_ILOGB0, ilogb(0.0)); 839 ASSERT_EQ(FP_ILOGBNAN, ilogb(nan(""))); 840 ASSERT_EQ(INT_MAX, ilogb(HUGE_VAL)); 841 ASSERT_EQ(0, ilogb(1.0)); 842 ASSERT_EQ(3, ilogb(10.0)); 843} 844 845TEST(math, ilogbf) { 846 ASSERT_EQ(FP_ILOGB0, ilogbf(0.0f)); 847 ASSERT_EQ(FP_ILOGBNAN, ilogbf(nanf(""))); 848 ASSERT_EQ(INT_MAX, ilogbf(HUGE_VALF)); 849 ASSERT_EQ(0, ilogbf(1.0f)); 850 ASSERT_EQ(3, ilogbf(10.0f)); 851} 852 853TEST(math, ilogbl) { 854 ASSERT_EQ(FP_ILOGB0, ilogbl(0.0l)); 855 ASSERT_EQ(FP_ILOGBNAN, ilogbl(nanl(""))); 856 ASSERT_EQ(INT_MAX, ilogbl(HUGE_VALL)); 857 ASSERT_EQ(0l, ilogbl(1.0l)); 858 ASSERT_EQ(3l, ilogbl(10.0l)); 859} 860 861TEST(math, logb) { 862 ASSERT_EQ(-HUGE_VAL, logb(0.0)); 863 ASSERT_TRUE(isnan(logb(nan("")))); 864 ASSERT_TRUE(isinf(logb(HUGE_VAL))); 865 ASSERT_EQ(0.0, logb(1.0)); 866 ASSERT_EQ(3.0, logb(10.0)); 867} 868 869TEST(math, logbf) { 870 ASSERT_EQ(-HUGE_VALF, logbf(0.0f)); 871 ASSERT_TRUE(isnanf(logbf(nanf("")))); 872 ASSERT_TRUE(__isinff(logbf(HUGE_VALF))); 873 ASSERT_EQ(0.0f, logbf(1.0f)); 874 ASSERT_EQ(3.0f, logbf(10.0f)); 875} 876 877TEST(math, logbl) { 878 ASSERT_EQ(-HUGE_VAL, logbl(0.0l)); 879 ASSERT_TRUE(isnan(logbl(nanl("")))); 880 ASSERT_TRUE(isinf(logbl(HUGE_VALL))); 881 ASSERT_EQ(0.0l, logbl(1.0l)); 882 ASSERT_EQ(3.0l, logbl(10.0l)); 883} 884 885TEST(math, log1p) { 886 ASSERT_EQ(-HUGE_VAL, log1p(-1.0)); 887 ASSERT_TRUE(isnan(log1p(nan("")))); 888 ASSERT_TRUE(isinf(log1p(HUGE_VAL))); 889 ASSERT_DOUBLE_EQ(1.0, log1p(M_E - 1.0)); 890} 891 892TEST(math, log1pf) { 893 ASSERT_EQ(-HUGE_VALF, log1pf(-1.0f)); 894 ASSERT_TRUE(isnanf(log1pf(nanf("")))); 895 ASSERT_TRUE(__isinff(log1pf(HUGE_VALF))); 896 ASSERT_FLOAT_EQ(1.0f, log1pf(static_cast<float>(M_E) - 1.0f)); 897} 898 899TEST(math, log1pl) { 900 ASSERT_EQ(-HUGE_VALL, log1pl(-1.0l)); 901 ASSERT_TRUE(isnan(log1pl(nanl("")))); 902 ASSERT_TRUE(isinf(log1pl(HUGE_VALL))); 903 ASSERT_DOUBLE_EQ(1.0l, log1pl(M_E - 1.0l)); 904} 905 906TEST(math, fdim) { 907 ASSERT_DOUBLE_EQ(0.0, fdim(1.0, 1.0)); 908 ASSERT_DOUBLE_EQ(1.0, fdim(2.0, 1.0)); 909 ASSERT_DOUBLE_EQ(0.0, fdim(1.0, 2.0)); 910} 911 912TEST(math, fdimf) { 913 ASSERT_FLOAT_EQ(0.0f, fdimf(1.0f, 1.0f)); 914 ASSERT_FLOAT_EQ(1.0f, fdimf(2.0f, 1.0f)); 915 ASSERT_FLOAT_EQ(0.0f, fdimf(1.0f, 2.0f)); 916} 917 918TEST(math, fdiml) { 919 ASSERT_DOUBLE_EQ(0.0l, fdiml(1.0l, 1.0l)); 920 ASSERT_DOUBLE_EQ(1.0l, fdiml(2.0l, 1.0l)); 921 ASSERT_DOUBLE_EQ(0.0l, fdiml(1.0l, 2.0l)); 922} 923 924TEST(math, round) { 925 fesetround(FE_TOWARDZERO); // round ignores the rounding mode and always rounds away from zero. 926 ASSERT_DOUBLE_EQ(1.0, round(0.5)); 927 ASSERT_DOUBLE_EQ(-1.0, round(-0.5)); 928 ASSERT_DOUBLE_EQ(0.0, round(0.0)); 929 ASSERT_DOUBLE_EQ(-0.0, round(-0.0)); 930 ASSERT_TRUE(isnan(round(nan("")))); 931 ASSERT_DOUBLE_EQ(HUGE_VAL, round(HUGE_VAL)); 932} 933 934TEST(math, roundf) { 935 fesetround(FE_TOWARDZERO); // roundf ignores the rounding mode and always rounds away from zero. 936 ASSERT_FLOAT_EQ(1.0f, roundf(0.5f)); 937 ASSERT_FLOAT_EQ(-1.0f, roundf(-0.5f)); 938 ASSERT_FLOAT_EQ(0.0f, roundf(0.0f)); 939 ASSERT_FLOAT_EQ(-0.0f, roundf(-0.0f)); 940 ASSERT_TRUE(isnanf(roundf(nanf("")))); 941 ASSERT_FLOAT_EQ(HUGE_VALF, roundf(HUGE_VALF)); 942} 943 944TEST(math, roundl) { 945 fesetround(FE_TOWARDZERO); // roundl ignores the rounding mode and always rounds away from zero. 946 ASSERT_DOUBLE_EQ(1.0l, roundl(0.5l)); 947 ASSERT_DOUBLE_EQ(-1.0l, roundl(-0.5l)); 948 ASSERT_DOUBLE_EQ(0.0l, roundl(0.0l)); 949 ASSERT_DOUBLE_EQ(-0.0l, roundl(-0.0l)); 950 ASSERT_TRUE(isnan(roundl(nanl("")))); 951 ASSERT_DOUBLE_EQ(HUGE_VALL, roundl(HUGE_VALL)); 952} 953 954TEST(math, trunc) { 955 fesetround(FE_UPWARD); // trunc ignores the rounding mode and always rounds toward zero. 956 ASSERT_DOUBLE_EQ(1.0, trunc(1.5)); 957 ASSERT_DOUBLE_EQ(-1.0, trunc(-1.5)); 958 ASSERT_DOUBLE_EQ(0.0, trunc(0.0)); 959 ASSERT_DOUBLE_EQ(-0.0, trunc(-0.0)); 960 ASSERT_TRUE(isnan(trunc(nan("")))); 961 ASSERT_DOUBLE_EQ(HUGE_VAL, trunc(HUGE_VAL)); 962} 963 964TEST(math, truncf) { 965 fesetround(FE_UPWARD); // truncf ignores the rounding mode and always rounds toward zero. 966 ASSERT_FLOAT_EQ(1.0f, truncf(1.5f)); 967 ASSERT_FLOAT_EQ(-1.0f, truncf(-1.5f)); 968 ASSERT_FLOAT_EQ(0.0f, truncf(0.0f)); 969 ASSERT_FLOAT_EQ(-0.0f, truncf(-0.0f)); 970 ASSERT_TRUE(isnan(truncf(nanf("")))); 971 ASSERT_FLOAT_EQ(HUGE_VALF, truncf(HUGE_VALF)); 972} 973 974TEST(math, truncl) { 975 fesetround(FE_UPWARD); // truncl ignores the rounding mode and always rounds toward zero. 976 ASSERT_DOUBLE_EQ(1.0l, truncl(1.5l)); 977 ASSERT_DOUBLE_EQ(-1.0l, truncl(-1.5l)); 978 ASSERT_DOUBLE_EQ(0.0l, truncl(0.0l)); 979 ASSERT_DOUBLE_EQ(-0.0l, truncl(-0.0l)); 980 ASSERT_TRUE(isnan(truncl(nan("")))); 981 ASSERT_DOUBLE_EQ(HUGE_VALL, truncl(HUGE_VALL)); 982} 983 984TEST(math, nextafter) { 985 ASSERT_DOUBLE_EQ(0.0, nextafter(0.0, 0.0)); 986 ASSERT_DOUBLE_EQ(4.9406564584124654e-324, nextafter(0.0, 1.0)); 987 ASSERT_DOUBLE_EQ(0.0, nextafter(0.0, -1.0)); 988} 989 990TEST(math, nextafterf) { 991 ASSERT_FLOAT_EQ(0.0f, nextafterf(0.0f, 0.0f)); 992 ASSERT_FLOAT_EQ(1.4012985e-45f, nextafterf(0.0f, 1.0f)); 993 ASSERT_FLOAT_EQ(0.0f, nextafterf(0.0f, -1.0f)); 994} 995 996TEST(math, nextafterl) { 997 ASSERT_DOUBLE_EQ(0.0l, nextafterl(0.0l, 0.0l)); 998 // Use a runtime value to accomodate the case when 999 // sizeof(double) == sizeof(long double) 1000 long double smallest_positive = ldexpl(1.0l, LDBL_MIN_EXP - LDBL_MANT_DIG); 1001 ASSERT_DOUBLE_EQ(smallest_positive, nextafterl(0.0l, 1.0l)); 1002 ASSERT_DOUBLE_EQ(0.0l, nextafterl(0.0l, -1.0l)); 1003} 1004 1005// TODO: nexttoward 1006// TODO: nexttowardf 1007// TODO: nexttowardl 1008 1009TEST(math, copysign) { 1010 ASSERT_DOUBLE_EQ(0.0, copysign(0.0, 1.0)); 1011 ASSERT_DOUBLE_EQ(-0.0, copysign(0.0, -1.0)); 1012 ASSERT_DOUBLE_EQ(2.0, copysign(2.0, 1.0)); 1013 ASSERT_DOUBLE_EQ(-2.0, copysign(2.0, -1.0)); 1014} 1015 1016TEST(math, copysignf) { 1017 ASSERT_FLOAT_EQ(0.0f, copysignf(0.0f, 1.0f)); 1018 ASSERT_FLOAT_EQ(-0.0f, copysignf(0.0f, -1.0f)); 1019 ASSERT_FLOAT_EQ(2.0f, copysignf(2.0f, 1.0f)); 1020 ASSERT_FLOAT_EQ(-2.0f, copysignf(2.0f, -1.0f)); 1021} 1022 1023TEST(math, copysignl) { 1024 ASSERT_DOUBLE_EQ(0.0l, copysignl(0.0l, 1.0l)); 1025 ASSERT_DOUBLE_EQ(-0.0l, copysignl(0.0l, -1.0l)); 1026 ASSERT_DOUBLE_EQ(2.0l, copysignl(2.0l, 1.0l)); 1027 ASSERT_DOUBLE_EQ(-2.0l, copysignl(2.0l, -1.0l)); 1028} 1029 1030TEST(math, significand) { 1031 ASSERT_DOUBLE_EQ(0.0, significand(0.0)); 1032 ASSERT_DOUBLE_EQ(1.2, significand(1.2)); 1033 ASSERT_DOUBLE_EQ(1.5375, significand(12.3)); 1034} 1035 1036TEST(math, significandf) { 1037 ASSERT_FLOAT_EQ(0.0f, significandf(0.0f)); 1038 ASSERT_FLOAT_EQ(1.2f, significandf(1.2f)); 1039 ASSERT_FLOAT_EQ(1.5375f, significandf(12.3f)); 1040} 1041 1042extern "C" long double significandl(long double); // BSD's <math.h> doesn't declare this. 1043 1044TEST(math, significandl) { 1045 ASSERT_DOUBLE_EQ(0.0l, significandl(0.0l)); 1046 ASSERT_DOUBLE_EQ(1.2l, significandl(1.2l)); 1047 ASSERT_DOUBLE_EQ(1.5375l, significandl(12.3l)); 1048} 1049 1050TEST(math, scalb) { 1051 ASSERT_DOUBLE_EQ(12.0, scalb(3.0, 2.0)); 1052} 1053 1054TEST(math, scalbf) { 1055 ASSERT_FLOAT_EQ(12.0f, scalbf(3.0f, 2.0f)); 1056} 1057 1058TEST(math, scalbln) { 1059 ASSERT_DOUBLE_EQ(12.0, scalbln(3.0, 2L)); 1060} 1061 1062TEST(math, scalblnf) { 1063 ASSERT_FLOAT_EQ(12.0f, scalblnf(3.0f, 2L)); 1064} 1065 1066TEST(math, scalblnl) { 1067 ASSERT_DOUBLE_EQ(12.0l, scalblnl(3.0l, 2L)); 1068} 1069 1070TEST(math, scalbn) { 1071 ASSERT_DOUBLE_EQ(12.0, scalbn(3.0, 2)); 1072} 1073 1074TEST(math, scalbnf) { 1075 ASSERT_FLOAT_EQ(12.0f, scalbnf(3.0f, 2)); 1076} 1077 1078TEST(math, scalbnl) { 1079 ASSERT_DOUBLE_EQ(12.0l, scalbnl(3.0l, 2)); 1080} 1081 1082TEST(math, gamma) { 1083 ASSERT_DOUBLE_EQ(log(24.0), gamma(5.0)); 1084} 1085 1086TEST(math, gammaf) { 1087 ASSERT_FLOAT_EQ(logf(24.0f), gammaf(5.0f)); 1088} 1089 1090TEST(math, gamma_r) { 1091#if defined(__BIONIC__) 1092 int sign; 1093 ASSERT_DOUBLE_EQ(log(24.0), gamma_r(5.0, &sign)); 1094 ASSERT_EQ(1, sign); 1095#else // __BIONIC__ 1096 GTEST_LOG_(INFO) << "This test does nothing.\n"; 1097#endif // __BIONIC__ 1098} 1099 1100TEST(math, gammaf_r) { 1101#if defined(__BIONIC__) 1102 int sign; 1103 ASSERT_FLOAT_EQ(logf(24.0f), gammaf_r(5.0f, &sign)); 1104 ASSERT_EQ(1, sign); 1105#else // __BIONIC__ 1106 GTEST_LOG_(INFO) << "This test does nothing.\n"; 1107#endif // __BIONIC__ 1108} 1109 1110TEST(math, lgamma) { 1111 ASSERT_DOUBLE_EQ(log(24.0), lgamma(5.0)); 1112} 1113 1114TEST(math, lgammaf) { 1115 ASSERT_FLOAT_EQ(logf(24.0f), lgammaf(5.0f)); 1116} 1117 1118TEST(math, lgammal) { 1119 ASSERT_DOUBLE_EQ(logl(24.0l), lgammal(5.0l)); 1120} 1121 1122TEST(math, lgamma_r) { 1123 int sign; 1124 ASSERT_DOUBLE_EQ(log(24.0), lgamma_r(5.0, &sign)); 1125 ASSERT_EQ(1, sign); 1126} 1127 1128TEST(math, lgammaf_r) { 1129 int sign; 1130 ASSERT_FLOAT_EQ(logf(24.0f), lgammaf_r(5.0f, &sign)); 1131 ASSERT_EQ(1, sign); 1132} 1133 1134TEST(math, tgamma) { 1135 ASSERT_DOUBLE_EQ(24.0, tgamma(5.0)); 1136} 1137 1138TEST(math, tgammaf) { 1139 ASSERT_FLOAT_EQ(24.0f, tgammaf(5.0f)); 1140} 1141 1142TEST(math, tgammal) { 1143 ASSERT_DOUBLE_EQ(24.0l, tgammal(5.0l)); 1144} 1145 1146TEST(math, j0) { 1147 ASSERT_DOUBLE_EQ(1.0, j0(0.0)); 1148 ASSERT_DOUBLE_EQ(0.76519768655796661, j0(1.0)); 1149} 1150 1151TEST(math, j0f) { 1152 ASSERT_FLOAT_EQ(1.0f, j0f(0.0f)); 1153 ASSERT_FLOAT_EQ(0.76519769f, j0f(1.0f)); 1154} 1155 1156TEST(math, j1) { 1157 ASSERT_DOUBLE_EQ(0.0, j1(0.0)); 1158 ASSERT_DOUBLE_EQ(0.44005058574493355, j1(1.0)); 1159} 1160 1161TEST(math, j1f) { 1162 ASSERT_FLOAT_EQ(0.0f, j1f(0.0f)); 1163 ASSERT_FLOAT_EQ(0.44005057f, j1f(1.0f)); 1164} 1165 1166TEST(math, jn) { 1167 ASSERT_DOUBLE_EQ(0.0, jn(4, 0.0)); 1168 ASSERT_DOUBLE_EQ(0.0024766389641099553, jn(4, 1.0)); 1169} 1170 1171TEST(math, jnf) { 1172 ASSERT_FLOAT_EQ(0.0f, jnf(4, 0.0f)); 1173 ASSERT_FLOAT_EQ(0.0024766389f, jnf(4, 1.0f)); 1174} 1175 1176TEST(math, y0) { 1177 ASSERT_DOUBLE_EQ(-HUGE_VAL, y0(0.0)); 1178 ASSERT_DOUBLE_EQ(0.08825696421567697, y0(1.0)); 1179} 1180 1181TEST(math, y0f) { 1182 ASSERT_FLOAT_EQ(-HUGE_VALF, y0f(0.0f)); 1183 ASSERT_FLOAT_EQ(0.088256963f, y0f(1.0f)); 1184} 1185 1186TEST(math, y1) { 1187 ASSERT_DOUBLE_EQ(-HUGE_VAL, y1(0.0)); 1188 ASSERT_DOUBLE_EQ(-0.78121282130028868, y1(1.0)); 1189} 1190 1191TEST(math, y1f) { 1192 ASSERT_FLOAT_EQ(-HUGE_VALF, y1f(0.0f)); 1193 ASSERT_FLOAT_EQ(-0.78121281f, y1f(1.0f)); 1194} 1195 1196TEST(math, yn) { 1197 ASSERT_DOUBLE_EQ(-HUGE_VAL, yn(4, 0.0)); 1198 ASSERT_DOUBLE_EQ(-33.278423028972114, yn(4, 1.0)); 1199} 1200 1201TEST(math, ynf) { 1202 ASSERT_FLOAT_EQ(-HUGE_VALF, ynf(4, 0.0f)); 1203 ASSERT_FLOAT_EQ(-33.278423f, ynf(4, 1.0f)); 1204} 1205 1206TEST(math, frexp) { 1207 int exp; 1208 double dr = frexp(1024.0, &exp); 1209 ASSERT_DOUBLE_EQ(1024.0, scalbn(dr, exp)); 1210} 1211 1212TEST(math, frexpf) { 1213 int exp; 1214 float fr = frexpf(1024.0f, &exp); 1215 ASSERT_FLOAT_EQ(1024.0f, scalbnf(fr, exp)); 1216} 1217 1218TEST(math, frexpl) { 1219 int exp; 1220 long double ldr = frexpl(1024.0l, &exp); 1221 ASSERT_DOUBLE_EQ(1024.0l, scalbnl(ldr, exp)); 1222} 1223 1224TEST(math, modf) { 1225 double di; 1226 double df = modf(123.456, &di); 1227 ASSERT_DOUBLE_EQ(123.0, di); 1228 ASSERT_DOUBLE_EQ(0.45600000000000307, df); 1229} 1230 1231TEST(math, modff) { 1232 float fi; 1233 float ff = modff(123.456f, &fi); 1234 ASSERT_FLOAT_EQ(123.0f, fi); 1235 ASSERT_FLOAT_EQ(0.45600128f, ff); 1236} 1237 1238TEST(math, modfl) { 1239 long double ldi; 1240 long double ldf = modfl(123.456l, &ldi); 1241 ASSERT_DOUBLE_EQ(123.0l, ldi); 1242 ASSERT_DOUBLE_EQ(0.45600000000000002l, ldf); 1243} 1244 1245TEST(math, remquo) { 1246 int q; 1247 double d = remquo(13.0, 4.0, &q); 1248 ASSERT_EQ(3, q); 1249 ASSERT_DOUBLE_EQ(1.0, d); 1250} 1251 1252TEST(math, remquof) { 1253 int q; 1254 float f = remquof(13.0f, 4.0f, &q); 1255 ASSERT_EQ(3, q); 1256 ASSERT_FLOAT_EQ(1.0, f); 1257} 1258 1259TEST(math, remquol) { 1260 int q; 1261 long double ld = remquol(13.0l, 4.0l, &q); 1262 ASSERT_DOUBLE_EQ(3l, q); 1263 ASSERT_DOUBLE_EQ(1.0l, ld); 1264} 1265 1266// https://code.google.com/p/android/issues/detail?id=6697 1267TEST(math, frexpf_public_bug_6697) { 1268 int exp; 1269 float fr = frexpf(14.1f, &exp); 1270 ASSERT_FLOAT_EQ(14.1f, scalbnf(fr, exp)); 1271} 1272