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