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 _GNU_SOURCE 1 18 #include <math.h> 19 20 // This include (and the associated definition of __test_capture_signbit) 21 // must be placed before any files that include <cmath> (gtest.h in this case). 22 // 23 // <math.h> is required to define generic macros signbit, isfinite and 24 // several other such functions. 25 // 26 // <cmath> is required to undef declarations of these macros in the global 27 // namespace and make equivalent functions available in namespace std. Our 28 // stlport implementation does this only for signbit, isfinite, isinf and 29 // isnan. 30 // 31 // NOTE: We don't write our test using std::signbit because we want to be 32 // sure that we're testing the bionic version of signbit. The C++ libraries 33 // are free to reimplement signbit or delegate to compiler builtins if they 34 // please. 35 36 namespace { 37 template<typename T> inline int test_capture_signbit(const T in) { 38 return signbit(in); 39 } 40 template<typename T> inline int test_capture_isfinite(const T in) { 41 return isfinite(in); 42 } 43 template<typename T> inline int test_capture_isnan(const T in) { 44 return isnan(in); 45 } 46 template<typename T> inline int test_capture_isinf(const T in) { 47 return isinf(in); 48 } 49 } 50 51 #include "math_data_test.h" 52 53 #include <gtest/gtest.h> 54 55 #include <fenv.h> 56 #include <float.h> 57 #include <limits.h> 58 #include <stdint.h> 59 60 #include <android-base/scopeguard.h> 61 62 float float_subnormal() { 63 union { 64 float f; 65 uint32_t i; 66 } u; 67 u.i = 0x007fffff; 68 return u.f; 69 } 70 71 double double_subnormal() { 72 union { 73 double d; 74 uint64_t i; 75 } u; 76 u.i = 0x000fffffffffffffLL; 77 return u.d; 78 } 79 80 long double ldouble_subnormal() { 81 union { 82 long double e; 83 unsigned char c[sizeof(long double)]; 84 } u; 85 86 // Subnormals must have a zero exponent and non zero significand. 87 // On all supported representation the 17 bit (counting from either sides) 88 // is part of the significand so it should be enough to set that. 89 // It also applies for the case sizeof(double) = sizeof(long double) 90 for (unsigned int i = 0; i < sizeof(long double); i++) { 91 u.c[i] = 0x00; 92 } 93 u.c[sizeof(long double) - 3] = 0x80; 94 u.c[2] = 0x80; 95 96 return u.e; 97 } 98 99 TEST(math, fpclassify) { 100 ASSERT_EQ(FP_INFINITE, fpclassify(INFINITY)); 101 ASSERT_EQ(FP_INFINITE, fpclassify(HUGE_VALF)); 102 ASSERT_EQ(FP_INFINITE, fpclassify(HUGE_VAL)); 103 ASSERT_EQ(FP_INFINITE, fpclassify(HUGE_VALL)); 104 105 ASSERT_EQ(FP_NAN, fpclassify(nanf(""))); 106 ASSERT_EQ(FP_NAN, fpclassify(nan(""))); 107 ASSERT_EQ(FP_NAN, fpclassify(nanl(""))); 108 109 ASSERT_EQ(FP_NORMAL, fpclassify(1.0f)); 110 ASSERT_EQ(FP_NORMAL, fpclassify(1.0)); 111 ASSERT_EQ(FP_NORMAL, fpclassify(1.0L)); 112 113 ASSERT_EQ(FP_SUBNORMAL, fpclassify(float_subnormal())); 114 ASSERT_EQ(FP_SUBNORMAL, fpclassify(double_subnormal())); 115 ASSERT_EQ(FP_SUBNORMAL, fpclassify(ldouble_subnormal())); 116 117 ASSERT_EQ(FP_ZERO, fpclassify(0.0f)); 118 ASSERT_EQ(FP_ZERO, fpclassify(0.0)); 119 ASSERT_EQ(FP_ZERO, fpclassify(0.0L)); 120 } 121 122 TEST(math, isfinite) { 123 ASSERT_TRUE(test_capture_isfinite(123.0f)); 124 ASSERT_TRUE(test_capture_isfinite(123.0)); 125 ASSERT_TRUE(test_capture_isfinite(123.0L)); 126 ASSERT_FALSE(test_capture_isfinite(HUGE_VALF)); 127 ASSERT_FALSE(test_capture_isfinite(HUGE_VAL)); 128 ASSERT_FALSE(test_capture_isfinite(HUGE_VALL)); 129 } 130 131 TEST(math, isinf) { 132 ASSERT_FALSE(test_capture_isinf(123.0f)); 133 ASSERT_FALSE(test_capture_isinf(123.0)); 134 ASSERT_FALSE(test_capture_isinf(123.0L)); 135 ASSERT_TRUE(test_capture_isinf(HUGE_VALF)); 136 ASSERT_TRUE(test_capture_isinf(HUGE_VAL)); 137 ASSERT_TRUE(test_capture_isinf(HUGE_VALL)); 138 } 139 140 TEST(math, isnan) { 141 ASSERT_FALSE(test_capture_isnan(123.0f)); 142 ASSERT_FALSE(test_capture_isnan(123.0)); 143 ASSERT_FALSE(test_capture_isnan(123.0L)); 144 ASSERT_TRUE(test_capture_isnan(nanf(""))); 145 ASSERT_TRUE(test_capture_isnan(nan(""))); 146 ASSERT_TRUE(test_capture_isnan(nanl(""))); 147 } 148 149 TEST(math, isnormal) { 150 ASSERT_TRUE(isnormal(123.0f)); 151 ASSERT_TRUE(isnormal(123.0)); 152 ASSERT_TRUE(isnormal(123.0L)); 153 ASSERT_FALSE(isnormal(float_subnormal())); 154 ASSERT_FALSE(isnormal(double_subnormal())); 155 ASSERT_FALSE(isnormal(ldouble_subnormal())); 156 } 157 158 // TODO: isgreater, isgreaterequals, isless, islessequal, islessgreater, isunordered 159 TEST(math, signbit) { 160 ASSERT_EQ(0, test_capture_signbit(0.0f)); 161 ASSERT_EQ(0, test_capture_signbit(0.0)); 162 ASSERT_EQ(0, test_capture_signbit(0.0L)); 163 164 ASSERT_EQ(0, test_capture_signbit(1.0f)); 165 ASSERT_EQ(0, test_capture_signbit(1.0)); 166 ASSERT_EQ(0, test_capture_signbit(1.0L)); 167 168 ASSERT_NE(0, test_capture_signbit(-1.0f)); 169 ASSERT_NE(0, test_capture_signbit(-1.0)); 170 ASSERT_NE(0, test_capture_signbit(-1.0L)); 171 } 172 173 TEST(math, __fpclassifyd) { 174 #if defined(__GLIBC__) 175 #define __fpclassifyd __fpclassify 176 #endif 177 ASSERT_EQ(FP_INFINITE, __fpclassifyd(HUGE_VAL)); 178 ASSERT_EQ(FP_NAN, __fpclassifyd(nan(""))); 179 ASSERT_EQ(FP_NORMAL, __fpclassifyd(1.0)); 180 ASSERT_EQ(FP_SUBNORMAL, __fpclassifyd(double_subnormal())); 181 ASSERT_EQ(FP_ZERO, __fpclassifyd(0.0)); 182 } 183 184 TEST(math, __fpclassifyf) { 185 ASSERT_EQ(FP_INFINITE, __fpclassifyf(HUGE_VALF)); 186 ASSERT_EQ(FP_NAN, __fpclassifyf(nanf(""))); 187 ASSERT_EQ(FP_NORMAL, __fpclassifyf(1.0f)); 188 ASSERT_EQ(FP_SUBNORMAL, __fpclassifyf(float_subnormal())); 189 ASSERT_EQ(FP_ZERO, __fpclassifyf(0.0f)); 190 } 191 192 TEST(math, __fpclassifyl) { 193 EXPECT_EQ(FP_INFINITE, __fpclassifyl(HUGE_VALL)); 194 EXPECT_EQ(FP_NAN, __fpclassifyl(nanl(""))); 195 EXPECT_EQ(FP_NORMAL, __fpclassifyl(1.0L)); 196 EXPECT_EQ(FP_SUBNORMAL, __fpclassifyl(ldouble_subnormal())); 197 EXPECT_EQ(FP_ZERO, __fpclassifyl(0.0L)); 198 } 199 200 TEST(math, finitef) { 201 ASSERT_TRUE(finitef(123.0f)); 202 ASSERT_FALSE(finitef(HUGE_VALF)); 203 } 204 205 TEST(math, __isfinite) { 206 #if defined(__GLIBC__) 207 #define __isfinite __finite 208 #endif 209 ASSERT_TRUE(__isfinite(123.0)); 210 ASSERT_FALSE(__isfinite(HUGE_VAL)); 211 } 212 213 TEST(math, __isfinitef) { 214 #if defined(__GLIBC__) 215 #define __isfinitef __finitef 216 #endif 217 ASSERT_TRUE(__isfinitef(123.0f)); 218 ASSERT_FALSE(__isfinitef(HUGE_VALF)); 219 } 220 221 TEST(math, __isfinitel) { 222 #if defined(__GLIBC__) 223 #define __isfinitel __finitel 224 #endif 225 ASSERT_TRUE(__isfinitel(123.0L)); 226 ASSERT_FALSE(__isfinitel(HUGE_VALL)); 227 } 228 229 TEST(math, finite) { 230 ASSERT_TRUE(finite(123.0)); 231 ASSERT_FALSE(finite(HUGE_VAL)); 232 } 233 234 TEST(math, isinf_function) { 235 // The isinf macro deals with all three types; the isinf function is for doubles. 236 ASSERT_FALSE((isinf)(123.0)); 237 ASSERT_TRUE((isinf)(HUGE_VAL)); 238 } 239 240 TEST(math, __isinff) { 241 ASSERT_FALSE(__isinff(123.0f)); 242 ASSERT_TRUE(__isinff(HUGE_VALF)); 243 } 244 245 TEST(math, __isinfl) { 246 ASSERT_FALSE(__isinfl(123.0L)); 247 ASSERT_TRUE(__isinfl(HUGE_VALL)); 248 } 249 250 TEST(math, isnan_function) { 251 // The isnan macro deals with all three types; the isnan function is for doubles. 252 ASSERT_FALSE((isnan)(123.0)); 253 ASSERT_TRUE((isnan)(nan(""))); 254 } 255 256 TEST(math, __isnanf) { 257 ASSERT_FALSE(__isnanf(123.0f)); 258 ASSERT_TRUE(__isnanf(nanf(""))); 259 } 260 261 TEST(math, __isnanl) { 262 ASSERT_FALSE(__isnanl(123.0L)); 263 ASSERT_TRUE(__isnanl(nanl(""))); 264 } 265 266 TEST(math, isnanf) { 267 ASSERT_FALSE(isnanf(123.0f)); 268 ASSERT_TRUE(isnanf(nanf(""))); 269 } 270 271 TEST(math, __isnormal) { 272 #if defined(__BIONIC__) 273 ASSERT_TRUE(__isnormal(123.0)); 274 ASSERT_FALSE(__isnormal(double_subnormal())); 275 #else // __BIONIC__ 276 GTEST_LOG_(INFO) << "glibc doesn't have __isnormal.\n"; 277 #endif // __BIONIC__ 278 } 279 280 TEST(math, __isnormalf) { 281 #if defined(__BIONIC__) 282 ASSERT_TRUE(__isnormalf(123.0f)); 283 ASSERT_FALSE(__isnormalf(float_subnormal())); 284 #else // __BIONIC__ 285 GTEST_LOG_(INFO) << "glibc doesn't have __isnormalf.\n"; 286 #endif // __BIONIC__ 287 } 288 289 TEST(math, __isnormall) { 290 #if defined(__BIONIC__) 291 ASSERT_TRUE(__isnormall(123.0L)); 292 ASSERT_FALSE(__isnormall(ldouble_subnormal())); 293 #else // __BIONIC__ 294 GTEST_LOG_(INFO) << "glibc doesn't have __isnormall.\n"; 295 #endif // __BIONIC__ 296 } 297 298 TEST(math, __signbit) { 299 ASSERT_EQ(0, __signbit(0.0)); 300 ASSERT_EQ(0, __signbit(1.0)); 301 ASSERT_NE(0, __signbit(-1.0)); 302 } 303 304 TEST(math, __signbitf) { 305 ASSERT_EQ(0, __signbitf(0.0f)); 306 ASSERT_EQ(0, __signbitf(1.0f)); 307 ASSERT_NE(0, __signbitf(-1.0f)); 308 } 309 310 TEST(math, __signbitl) { 311 ASSERT_EQ(0L, __signbitl(0.0L)); 312 ASSERT_EQ(0L, __signbitl(1.0L)); 313 ASSERT_NE(0L, __signbitl(-1.0L)); 314 } 315 316 TEST(math, acos) { 317 ASSERT_DOUBLE_EQ(M_PI/2.0, acos(0.0)); 318 } 319 320 TEST(math, acosf) { 321 ASSERT_FLOAT_EQ(static_cast<float>(M_PI)/2.0f, acosf(0.0f)); 322 } 323 324 TEST(math, acosl) { 325 ASSERT_DOUBLE_EQ(M_PI/2.0L, acosl(0.0L)); 326 } 327 328 TEST(math, asin) { 329 ASSERT_DOUBLE_EQ(0.0, asin(0.0)); 330 } 331 332 TEST(math, asinf) { 333 ASSERT_FLOAT_EQ(0.0f, asinf(0.0f)); 334 } 335 336 TEST(math, asinl) { 337 ASSERT_DOUBLE_EQ(0.0L, asinl(0.0L)); 338 } 339 340 TEST(math, atan) { 341 ASSERT_DOUBLE_EQ(0.0, atan(0.0)); 342 } 343 344 TEST(math, atanf) { 345 ASSERT_FLOAT_EQ(0.0f, atanf(0.0f)); 346 } 347 348 TEST(math, atanl) { 349 ASSERT_DOUBLE_EQ(0.0L, atanl(0.0L)); 350 } 351 352 TEST(math, atan2) { 353 ASSERT_DOUBLE_EQ(0.0, atan2(0.0, 0.0)); 354 } 355 356 TEST(math, atan2f) { 357 ASSERT_FLOAT_EQ(0.0f, atan2f(0.0f, 0.0f)); 358 } 359 360 TEST(math, atan2l) { 361 ASSERT_DOUBLE_EQ(0.0L, atan2l(0.0L, 0.0L)); 362 } 363 364 TEST(math, cos) { 365 ASSERT_DOUBLE_EQ(1.0, cos(0.0)); 366 } 367 368 TEST(math, cosf) { 369 ASSERT_FLOAT_EQ(1.0f, cosf(0.0f)); 370 } 371 372 TEST(math, cosl) { 373 ASSERT_DOUBLE_EQ(1.0L, cosl(0.0L)); 374 } 375 376 TEST(math, sin) { 377 ASSERT_DOUBLE_EQ(0.0, sin(0.0)); 378 } 379 380 TEST(math, sinf) { 381 ASSERT_FLOAT_EQ(0.0f, sinf(0.0f)); 382 } 383 384 TEST(math, sinl) { 385 ASSERT_DOUBLE_EQ(0.0L, sinl(0.0L)); 386 } 387 388 TEST(math, sincos) { 389 double s, c; 390 sincos(0.0, &s, &c); 391 ASSERT_DOUBLE_EQ(0.0, s); 392 ASSERT_DOUBLE_EQ(1.0, c); 393 } 394 395 TEST(math, sincosf) { 396 float s, c; 397 sincosf(0.0f, &s, &c); 398 ASSERT_FLOAT_EQ(0.0f, s); 399 ASSERT_FLOAT_EQ(1.0f, c); 400 } 401 402 TEST(math, sincosl) { 403 long double s, c; 404 sincosl(0.0L, &s, &c); 405 ASSERT_DOUBLE_EQ(0.0L, s); 406 ASSERT_DOUBLE_EQ(1.0L, c); 407 } 408 409 TEST(math, tan) { 410 ASSERT_DOUBLE_EQ(0.0, tan(0.0)); 411 } 412 413 TEST(math, tanf) { 414 ASSERT_FLOAT_EQ(0.0f, tanf(0.0f)); 415 } 416 417 TEST(math, tanl) { 418 ASSERT_DOUBLE_EQ(0.0L, tanl(0.0L)); 419 } 420 421 TEST(math, acosh) { 422 ASSERT_DOUBLE_EQ(0.0, acosh(1.0)); 423 } 424 425 TEST(math, acoshf) { 426 ASSERT_FLOAT_EQ(0.0f, acoshf(1.0f)); 427 } 428 429 TEST(math, acoshl) { 430 ASSERT_DOUBLE_EQ(0.0L, acoshl(1.0L)); 431 } 432 433 TEST(math, asinh) { 434 ASSERT_DOUBLE_EQ(0.0, asinh(0.0)); 435 } 436 437 TEST(math, asinhf) { 438 ASSERT_FLOAT_EQ(0.0f, asinhf(0.0f)); 439 } 440 441 TEST(math, asinhl) { 442 ASSERT_DOUBLE_EQ(0.0L, asinhl(0.0L)); 443 } 444 445 TEST(math, atanh) { 446 ASSERT_DOUBLE_EQ(0.0, atanh(0.0)); 447 } 448 449 TEST(math, atanhf) { 450 ASSERT_FLOAT_EQ(0.0f, atanhf(0.0f)); 451 } 452 453 TEST(math, atanhl) { 454 ASSERT_DOUBLE_EQ(0.0L, atanhl(0.0L)); 455 } 456 457 TEST(math, cosh) { 458 ASSERT_DOUBLE_EQ(1.0, cosh(0.0)); 459 } 460 461 TEST(math, coshf) { 462 ASSERT_FLOAT_EQ(1.0f, coshf(0.0f)); 463 } 464 465 TEST(math, coshl) { 466 ASSERT_DOUBLE_EQ(1.0L, coshl(0.0L)); 467 } 468 469 TEST(math, sinh) { 470 ASSERT_DOUBLE_EQ(0.0, sinh(0.0)); 471 } 472 473 TEST(math, sinhf) { 474 ASSERT_FLOAT_EQ(0.0f, sinhf(0.0f)); 475 } 476 477 TEST(math, sinhl) { 478 ASSERT_DOUBLE_EQ(0.0L, sinhl(0.0L)); 479 } 480 481 TEST(math, tanh) { 482 ASSERT_DOUBLE_EQ(0.0, tanh(0.0)); 483 } 484 485 TEST(math, tanhf) { 486 ASSERT_FLOAT_EQ(0.0f, tanhf(0.0f)); 487 } 488 489 TEST(math, tanhl) { 490 ASSERT_DOUBLE_EQ(0.0L, tanhl(0.0L)); 491 } 492 493 TEST(math, log) { 494 ASSERT_DOUBLE_EQ(1.0, log(M_E)); 495 } 496 497 TEST(math, logf) { 498 ASSERT_FLOAT_EQ(1.0f, logf(static_cast<float>(M_E))); 499 } 500 501 TEST(math, logl) { 502 ASSERT_DOUBLE_EQ(1.0L, logl(M_E)); 503 } 504 505 TEST(math, log2) { 506 ASSERT_DOUBLE_EQ(12.0, log2(4096.0)); 507 } 508 509 TEST(math, log2f) { 510 ASSERT_FLOAT_EQ(12.0f, log2f(4096.0f)); 511 } 512 513 TEST(math, log2l) { 514 ASSERT_DOUBLE_EQ(12.0L, log2l(4096.0L)); 515 } 516 517 TEST(math, log10) { 518 ASSERT_DOUBLE_EQ(3.0, log10(1000.0)); 519 } 520 521 TEST(math, log10f) { 522 ASSERT_FLOAT_EQ(3.0f, log10f(1000.0f)); 523 } 524 525 TEST(math, log10l) { 526 ASSERT_DOUBLE_EQ(3.0L, log10l(1000.0L)); 527 } 528 529 TEST(math, cbrt) { 530 ASSERT_DOUBLE_EQ(3.0, cbrt(27.0)); 531 } 532 533 TEST(math, cbrtf) { 534 ASSERT_FLOAT_EQ(3.0f, cbrtf(27.0f)); 535 } 536 537 TEST(math, cbrtl) { 538 ASSERT_DOUBLE_EQ(3.0L, cbrtl(27.0L)); 539 } 540 541 TEST(math, sqrt) { 542 ASSERT_DOUBLE_EQ(2.0, sqrt(4.0)); 543 } 544 545 TEST(math, sqrtf) { 546 ASSERT_FLOAT_EQ(2.0f, sqrtf(4.0f)); 547 } 548 549 TEST(math, sqrtl) { 550 ASSERT_DOUBLE_EQ(2.0L, sqrtl(4.0L)); 551 } 552 553 TEST(math, exp) { 554 ASSERT_DOUBLE_EQ(1.0, exp(0.0)); 555 ASSERT_DOUBLE_EQ(M_E, exp(1.0)); 556 } 557 558 TEST(math, expf) { 559 ASSERT_FLOAT_EQ(1.0f, expf(0.0f)); 560 ASSERT_FLOAT_EQ(static_cast<float>(M_E), expf(1.0f)); 561 } 562 563 TEST(math, expl) { 564 ASSERT_DOUBLE_EQ(1.0L, expl(0.0L)); 565 ASSERT_DOUBLE_EQ(M_E, expl(1.0L)); 566 } 567 568 TEST(math, exp2) { 569 ASSERT_DOUBLE_EQ(8.0, exp2(3.0)); 570 } 571 572 TEST(math, exp2f) { 573 ASSERT_FLOAT_EQ(8.0f, exp2f(3.0f)); 574 } 575 576 TEST(math, exp2l) { 577 ASSERT_DOUBLE_EQ(8.0L, exp2l(3.0L)); 578 } 579 580 TEST(math, expm1) { 581 ASSERT_DOUBLE_EQ(M_E - 1.0, expm1(1.0)); 582 } 583 584 TEST(math, expm1f) { 585 ASSERT_FLOAT_EQ(static_cast<float>(M_E) - 1.0f, expm1f(1.0f)); 586 } 587 588 TEST(math, expm1l) { 589 ASSERT_DOUBLE_EQ(M_E - 1.0L, expm1l(1.0L)); 590 } 591 592 TEST(math, pow) { 593 ASSERT_TRUE(isnan(pow(nan(""), 3.0))); 594 ASSERT_DOUBLE_EQ(1.0, (pow(1.0, nan("")))); 595 ASSERT_TRUE(isnan(pow(2.0, nan("")))); 596 ASSERT_DOUBLE_EQ(8.0, pow(2.0, 3.0)); 597 } 598 599 TEST(math, powf) { 600 ASSERT_TRUE(isnanf(powf(nanf(""), 3.0f))); 601 ASSERT_FLOAT_EQ(1.0f, (powf(1.0f, nanf("")))); 602 ASSERT_TRUE(isnanf(powf(2.0f, nanf("")))); 603 ASSERT_FLOAT_EQ(8.0f, powf(2.0f, 3.0f)); 604 } 605 606 TEST(math, powl) { 607 ASSERT_TRUE(__isnanl(powl(nanl(""), 3.0L))); 608 ASSERT_DOUBLE_EQ(1.0L, (powl(1.0L, nanl("")))); 609 ASSERT_TRUE(__isnanl(powl(2.0L, nanl("")))); 610 ASSERT_DOUBLE_EQ(8.0L, powl(2.0L, 3.0L)); 611 } 612 613 TEST(math, ceil) { 614 ASSERT_DOUBLE_EQ(1.0, ceil(0.9)); 615 } 616 617 TEST(math, ceilf) { 618 ASSERT_FLOAT_EQ(1.0f, ceilf(0.9f)); 619 } 620 621 TEST(math, ceill) { 622 ASSERT_DOUBLE_EQ(1.0L, ceill(0.9L)); 623 } 624 625 TEST(math, floor) { 626 ASSERT_DOUBLE_EQ(1.0, floor(1.1)); 627 } 628 629 TEST(math, floorf) { 630 ASSERT_FLOAT_EQ(1.0f, floorf(1.1f)); 631 } 632 633 TEST(math, floorl) { 634 ASSERT_DOUBLE_EQ(1.0L, floorl(1.1L)); 635 } 636 637 TEST(math, fabs) { 638 ASSERT_DOUBLE_EQ(1.0, fabs(-1.0)); 639 } 640 641 TEST(math, fabsf) { 642 ASSERT_FLOAT_EQ(1.0f, fabsf(-1.0f)); 643 } 644 645 TEST(math, fabsl) { 646 ASSERT_DOUBLE_EQ(1.0L, fabsl(-1.0L)); 647 } 648 649 TEST(math, ldexp) { 650 ASSERT_DOUBLE_EQ(16.0, ldexp(2.0, 3.0)); 651 } 652 653 TEST(math, ldexpf) { 654 ASSERT_FLOAT_EQ(16.0f, ldexpf(2.0f, 3.0f)); 655 } 656 657 TEST(math, ldexpl) { 658 ASSERT_DOUBLE_EQ(16.0L, ldexpl(2.0L, 3.0)); 659 } 660 661 TEST(math, fmod) { 662 ASSERT_DOUBLE_EQ(2.0, fmod(12.0, 10.0)); 663 } 664 665 TEST(math, fmodf) { 666 ASSERT_FLOAT_EQ(2.0f, fmodf(12.0f, 10.0f)); 667 } 668 669 TEST(math, fmodl) { 670 ASSERT_DOUBLE_EQ(2.0L, fmodl(12.0L, 10.0L)); 671 } 672 673 TEST(math, remainder) { 674 ASSERT_DOUBLE_EQ(2.0, remainder(12.0, 10.0)); 675 } 676 677 TEST(math, remainderf) { 678 ASSERT_FLOAT_EQ(2.0f, remainderf(12.0f, 10.0f)); 679 } 680 681 TEST(math, remainderl) { 682 ASSERT_DOUBLE_EQ(2.0L, remainderl(12.0L, 10.0L)); 683 } 684 685 TEST(math, drem) { 686 ASSERT_DOUBLE_EQ(2.0, drem(12.0, 10.0)); 687 } 688 689 TEST(math, dremf) { 690 ASSERT_FLOAT_EQ(2.0f, dremf(12.0f, 10.0f)); 691 } 692 693 TEST(math, fmax) { 694 ASSERT_DOUBLE_EQ(12.0, fmax(12.0, 10.0)); 695 ASSERT_DOUBLE_EQ(12.0, fmax(12.0, nan(""))); 696 ASSERT_DOUBLE_EQ(12.0, fmax(nan(""), 12.0)); 697 } 698 699 TEST(math, fmaxf) { 700 ASSERT_FLOAT_EQ(12.0f, fmaxf(12.0f, 10.0f)); 701 ASSERT_FLOAT_EQ(12.0f, fmaxf(12.0f, nanf(""))); 702 ASSERT_FLOAT_EQ(12.0f, fmaxf(nanf(""), 12.0f)); 703 } 704 705 TEST(math, fmaxl) { 706 ASSERT_DOUBLE_EQ(12.0L, fmaxl(12.0L, 10.0L)); 707 ASSERT_DOUBLE_EQ(12.0L, fmaxl(12.0L, nanl(""))); 708 ASSERT_DOUBLE_EQ(12.0L, fmaxl(nanl(""), 12.0L)); 709 } 710 711 TEST(math, fmin) { 712 ASSERT_DOUBLE_EQ(10.0, fmin(12.0, 10.0)); 713 ASSERT_DOUBLE_EQ(12.0, fmin(12.0, nan(""))); 714 ASSERT_DOUBLE_EQ(12.0, fmin(nan(""), 12.0)); 715 } 716 717 TEST(math, fminf) { 718 ASSERT_FLOAT_EQ(10.0f, fminf(12.0f, 10.0f)); 719 ASSERT_FLOAT_EQ(12.0f, fminf(12.0f, nanf(""))); 720 ASSERT_FLOAT_EQ(12.0f, fminf(nanf(""), 12.0f)); 721 } 722 723 TEST(math, fminl) { 724 ASSERT_DOUBLE_EQ(10.0L, fminl(12.0L, 10.0L)); 725 ASSERT_DOUBLE_EQ(12.0L, fminl(12.0L, nanl(""))); 726 ASSERT_DOUBLE_EQ(12.0L, fminl(nanl(""), 12.0L)); 727 } 728 729 TEST(math, fma) { 730 ASSERT_DOUBLE_EQ(10.0, fma(2.0, 3.0, 4.0)); 731 } 732 733 TEST(math, fmaf) { 734 ASSERT_FLOAT_EQ(10.0f, fmaf(2.0f, 3.0f, 4.0f)); 735 } 736 737 TEST(math, fmal) { 738 ASSERT_DOUBLE_EQ(10.0L, fmal(2.0L, 3.0L, 4.0L)); 739 } 740 741 TEST(math, hypot) { 742 ASSERT_DOUBLE_EQ(5.0, hypot(3.0, 4.0)); 743 } 744 745 TEST(math, hypotf) { 746 ASSERT_FLOAT_EQ(5.0f, hypotf(3.0f, 4.0f)); 747 } 748 749 TEST(math, hypotl) { 750 ASSERT_DOUBLE_EQ(5.0L, hypotl(3.0L, 4.0L)); 751 } 752 753 TEST(math, erf) { 754 ASSERT_DOUBLE_EQ(0.84270079294971489, erf(1.0)); 755 } 756 757 TEST(math, erff) { 758 ASSERT_FLOAT_EQ(0.84270078f, erff(1.0f)); 759 } 760 761 TEST(math, erfl) { 762 ASSERT_DOUBLE_EQ(0.84270079294971489L, erfl(1.0L)); 763 } 764 765 TEST(math, erfc) { 766 ASSERT_DOUBLE_EQ(0.15729920705028513, erfc(1.0)); 767 } 768 769 TEST(math, erfcf) { 770 ASSERT_FLOAT_EQ(0.15729921f, erfcf(1.0f)); 771 } 772 773 TEST(math, erfcl) { 774 ASSERT_DOUBLE_EQ(0.15729920705028513l, erfcl(1.0L)); 775 } 776 777 TEST(math, lrint) { 778 auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); 779 780 fesetround(FE_UPWARD); // lrint/lrintf/lrintl obey the rounding mode. 781 ASSERT_EQ(1235, lrint(1234.01)); 782 ASSERT_EQ(1235, lrintf(1234.01f)); 783 ASSERT_EQ(1235, lrintl(1234.01L)); 784 fesetround(FE_TOWARDZERO); // lrint/lrintf/lrintl obey the rounding mode. 785 ASSERT_EQ(1234, lrint(1234.01)); 786 ASSERT_EQ(1234, lrintf(1234.01f)); 787 ASSERT_EQ(1234, lrintl(1234.01L)); 788 789 fesetround(FE_UPWARD); // llrint/llrintf/llrintl obey the rounding mode. 790 ASSERT_EQ(1235L, llrint(1234.01)); 791 ASSERT_EQ(1235L, llrintf(1234.01f)); 792 ASSERT_EQ(1235L, llrintl(1234.01L)); 793 fesetround(FE_TOWARDZERO); // llrint/llrintf/llrintl obey the rounding mode. 794 ASSERT_EQ(1234L, llrint(1234.01)); 795 ASSERT_EQ(1234L, llrintf(1234.01f)); 796 ASSERT_EQ(1234L, llrintl(1234.01L)); 797 } 798 799 TEST(math, rint) { 800 auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); 801 802 fesetround(FE_UPWARD); // rint/rintf/rintl obey the rounding mode. 803 feclearexcept(FE_ALL_EXCEPT); // rint/rintf/rintl do set the FE_INEXACT flag. 804 ASSERT_EQ(1234.0, rint(1234.0)); 805 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 806 ASSERT_EQ(1235.0, rint(1234.01)); 807 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) != 0); 808 809 feclearexcept(FE_ALL_EXCEPT); // rint/rintf/rintl do set the FE_INEXACT flag. 810 ASSERT_EQ(1234.0f, rintf(1234.0f)); 811 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 812 ASSERT_EQ(1235.0f, rintf(1234.01f)); 813 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) != 0); 814 815 feclearexcept(FE_ALL_EXCEPT); // rint/rintf/rintl do set the FE_INEXACT flag. 816 ASSERT_EQ(1234.0, rintl(1234.0L)); 817 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 818 ASSERT_EQ(1235.0, rintl(1234.01L)); 819 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) != 0); 820 821 fesetround(FE_TOWARDZERO); // rint/rintf obey the rounding mode. 822 ASSERT_EQ(1234.0, rint(1234.01)); 823 ASSERT_EQ(1234.0f, rintf(1234.01f)); 824 ASSERT_EQ(1234.0, rintl(1234.01L)); 825 } 826 827 TEST(math, nearbyint) { 828 auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); 829 fesetround(FE_UPWARD); // nearbyint/nearbyintf/nearbyintl obey the rounding mode. 830 feclearexcept(FE_ALL_EXCEPT); // nearbyint/nearbyintf/nearbyintl don't set the FE_INEXACT flag. 831 ASSERT_EQ(1234.0, nearbyint(1234.0)); 832 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 833 ASSERT_EQ(1235.0, nearbyint(1234.01)); 834 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 835 836 feclearexcept(FE_ALL_EXCEPT); 837 ASSERT_EQ(1234.0f, nearbyintf(1234.0f)); 838 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 839 ASSERT_EQ(1235.0f, nearbyintf(1234.01f)); 840 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 841 842 feclearexcept(FE_ALL_EXCEPT); // nearbyint/nearbyintf/nearbyintl don't set the FE_INEXACT flag. 843 ASSERT_EQ(1234.0, nearbyintl(1234.0L)); 844 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 845 ASSERT_EQ(1235.0, nearbyintl(1234.01L)); 846 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 847 848 fesetround(FE_TOWARDZERO); // nearbyint/nearbyintf/nearbyintl obey the rounding mode. 849 ASSERT_EQ(1234.0, nearbyint(1234.01)); 850 ASSERT_EQ(1234.0f, nearbyintf(1234.01f)); 851 ASSERT_EQ(1234.0, nearbyintl(1234.01L)); 852 } 853 854 TEST(math, lround) { 855 auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); 856 fesetround(FE_UPWARD); // lround ignores the rounding mode. 857 ASSERT_EQ(1234, lround(1234.01)); 858 ASSERT_EQ(1234, lroundf(1234.01f)); 859 ASSERT_EQ(1234, lroundl(1234.01L)); 860 } 861 862 TEST(math, llround) { 863 auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); 864 fesetround(FE_UPWARD); // llround ignores the rounding mode. 865 ASSERT_EQ(1234L, llround(1234.01)); 866 ASSERT_EQ(1234L, llroundf(1234.01f)); 867 ASSERT_EQ(1234L, llroundl(1234.01L)); 868 } 869 870 TEST(math, ilogb) { 871 ASSERT_EQ(FP_ILOGB0, ilogb(0.0)); 872 ASSERT_EQ(FP_ILOGBNAN, ilogb(nan(""))); 873 ASSERT_EQ(INT_MAX, ilogb(HUGE_VAL)); 874 ASSERT_EQ(0, ilogb(1.0)); 875 ASSERT_EQ(3, ilogb(10.0)); 876 } 877 878 TEST(math, ilogbf) { 879 ASSERT_EQ(FP_ILOGB0, ilogbf(0.0f)); 880 ASSERT_EQ(FP_ILOGBNAN, ilogbf(nanf(""))); 881 ASSERT_EQ(INT_MAX, ilogbf(HUGE_VALF)); 882 ASSERT_EQ(0, ilogbf(1.0f)); 883 ASSERT_EQ(3, ilogbf(10.0f)); 884 } 885 886 TEST(math, ilogbl) { 887 ASSERT_EQ(FP_ILOGB0, ilogbl(0.0L)); 888 ASSERT_EQ(FP_ILOGBNAN, ilogbl(nanl(""))); 889 ASSERT_EQ(INT_MAX, ilogbl(HUGE_VALL)); 890 ASSERT_EQ(0L, ilogbl(1.0L)); 891 ASSERT_EQ(3L, ilogbl(10.0L)); 892 } 893 894 TEST(math, logb) { 895 ASSERT_EQ(-HUGE_VAL, logb(0.0)); 896 ASSERT_TRUE(isnan(logb(nan("")))); 897 ASSERT_TRUE(isinf(logb(HUGE_VAL))); 898 ASSERT_EQ(0.0, logb(1.0)); 899 ASSERT_EQ(3.0, logb(10.0)); 900 } 901 902 TEST(math, logbf) { 903 ASSERT_EQ(-HUGE_VALF, logbf(0.0f)); 904 ASSERT_TRUE(isnanf(logbf(nanf("")))); 905 ASSERT_TRUE(__isinff(logbf(HUGE_VALF))); 906 ASSERT_EQ(0.0f, logbf(1.0f)); 907 ASSERT_EQ(3.0f, logbf(10.0f)); 908 } 909 910 TEST(math, logbl) { 911 ASSERT_EQ(-HUGE_VAL, logbl(0.0L)); 912 ASSERT_TRUE(isnan(logbl(nanl("")))); 913 ASSERT_TRUE(isinf(logbl(HUGE_VALL))); 914 ASSERT_EQ(0.0L, logbl(1.0L)); 915 ASSERT_EQ(3.0L, logbl(10.0L)); 916 } 917 918 TEST(math, log1p) { 919 ASSERT_EQ(-HUGE_VAL, log1p(-1.0)); 920 ASSERT_TRUE(isnan(log1p(nan("")))); 921 ASSERT_TRUE(isinf(log1p(HUGE_VAL))); 922 ASSERT_DOUBLE_EQ(1.0, log1p(M_E - 1.0)); 923 } 924 925 TEST(math, log1pf) { 926 ASSERT_EQ(-HUGE_VALF, log1pf(-1.0f)); 927 ASSERT_TRUE(isnanf(log1pf(nanf("")))); 928 ASSERT_TRUE(__isinff(log1pf(HUGE_VALF))); 929 ASSERT_FLOAT_EQ(1.0f, log1pf(static_cast<float>(M_E) - 1.0f)); 930 } 931 932 TEST(math, log1pl) { 933 ASSERT_EQ(-HUGE_VALL, log1pl(-1.0L)); 934 ASSERT_TRUE(isnan(log1pl(nanl("")))); 935 ASSERT_TRUE(isinf(log1pl(HUGE_VALL))); 936 ASSERT_DOUBLE_EQ(1.0L, log1pl(M_E - 1.0L)); 937 } 938 939 TEST(math, fdim) { 940 ASSERT_DOUBLE_EQ(0.0, fdim(1.0, 1.0)); 941 ASSERT_DOUBLE_EQ(1.0, fdim(2.0, 1.0)); 942 ASSERT_DOUBLE_EQ(0.0, fdim(1.0, 2.0)); 943 } 944 945 TEST(math, fdimf) { 946 ASSERT_FLOAT_EQ(0.0f, fdimf(1.0f, 1.0f)); 947 ASSERT_FLOAT_EQ(1.0f, fdimf(2.0f, 1.0f)); 948 ASSERT_FLOAT_EQ(0.0f, fdimf(1.0f, 2.0f)); 949 } 950 951 TEST(math, fdiml) { 952 ASSERT_DOUBLE_EQ(0.0L, fdiml(1.0L, 1.0L)); 953 ASSERT_DOUBLE_EQ(1.0L, fdiml(2.0L, 1.0L)); 954 ASSERT_DOUBLE_EQ(0.0L, fdiml(1.0L, 2.0L)); 955 } 956 957 TEST(math, round) { 958 auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); 959 fesetround(FE_TOWARDZERO); // round ignores the rounding mode and always rounds away from zero. 960 ASSERT_DOUBLE_EQ(1.0, round(0.5)); 961 ASSERT_DOUBLE_EQ(-1.0, round(-0.5)); 962 ASSERT_DOUBLE_EQ(0.0, round(0.0)); 963 ASSERT_DOUBLE_EQ(-0.0, round(-0.0)); 964 ASSERT_TRUE(isnan(round(nan("")))); 965 ASSERT_DOUBLE_EQ(HUGE_VAL, round(HUGE_VAL)); 966 } 967 968 TEST(math, roundf) { 969 auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); 970 fesetround(FE_TOWARDZERO); // roundf ignores the rounding mode and always rounds away from zero. 971 ASSERT_FLOAT_EQ(1.0f, roundf(0.5f)); 972 ASSERT_FLOAT_EQ(-1.0f, roundf(-0.5f)); 973 ASSERT_FLOAT_EQ(0.0f, roundf(0.0f)); 974 ASSERT_FLOAT_EQ(-0.0f, roundf(-0.0f)); 975 ASSERT_TRUE(isnanf(roundf(nanf("")))); 976 ASSERT_FLOAT_EQ(HUGE_VALF, roundf(HUGE_VALF)); 977 } 978 979 TEST(math, roundl) { 980 auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); 981 fesetround(FE_TOWARDZERO); // roundl ignores the rounding mode and always rounds away from zero. 982 ASSERT_DOUBLE_EQ(1.0L, roundl(0.5L)); 983 ASSERT_DOUBLE_EQ(-1.0L, roundl(-0.5L)); 984 ASSERT_DOUBLE_EQ(0.0L, roundl(0.0L)); 985 ASSERT_DOUBLE_EQ(-0.0L, roundl(-0.0L)); 986 ASSERT_TRUE(isnan(roundl(nanl("")))); 987 ASSERT_DOUBLE_EQ(HUGE_VALL, roundl(HUGE_VALL)); 988 } 989 990 TEST(math, trunc) { 991 auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); 992 fesetround(FE_UPWARD); // trunc ignores the rounding mode and always rounds toward zero. 993 ASSERT_DOUBLE_EQ(1.0, trunc(1.5)); 994 ASSERT_DOUBLE_EQ(-1.0, trunc(-1.5)); 995 ASSERT_DOUBLE_EQ(0.0, trunc(0.0)); 996 ASSERT_DOUBLE_EQ(-0.0, trunc(-0.0)); 997 ASSERT_TRUE(isnan(trunc(nan("")))); 998 ASSERT_DOUBLE_EQ(HUGE_VAL, trunc(HUGE_VAL)); 999 } 1000 1001 TEST(math, truncf) { 1002 auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); 1003 fesetround(FE_UPWARD); // truncf ignores the rounding mode and always rounds toward zero. 1004 ASSERT_FLOAT_EQ(1.0f, truncf(1.5f)); 1005 ASSERT_FLOAT_EQ(-1.0f, truncf(-1.5f)); 1006 ASSERT_FLOAT_EQ(0.0f, truncf(0.0f)); 1007 ASSERT_FLOAT_EQ(-0.0f, truncf(-0.0f)); 1008 ASSERT_TRUE(isnan(truncf(nanf("")))); 1009 ASSERT_FLOAT_EQ(HUGE_VALF, truncf(HUGE_VALF)); 1010 } 1011 1012 TEST(math, truncl) { 1013 auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); 1014 fesetround(FE_UPWARD); // truncl ignores the rounding mode and always rounds toward zero. 1015 ASSERT_DOUBLE_EQ(1.0L, truncl(1.5L)); 1016 ASSERT_DOUBLE_EQ(-1.0L, truncl(-1.5L)); 1017 ASSERT_DOUBLE_EQ(0.0L, truncl(0.0L)); 1018 ASSERT_DOUBLE_EQ(-0.0L, truncl(-0.0L)); 1019 ASSERT_TRUE(isnan(truncl(nan("")))); 1020 ASSERT_DOUBLE_EQ(HUGE_VALL, truncl(HUGE_VALL)); 1021 } 1022 1023 TEST(math, nextafter) { 1024 ASSERT_DOUBLE_EQ(0.0, nextafter(0.0, 0.0)); 1025 ASSERT_DOUBLE_EQ(4.9406564584124654e-324, nextafter(0.0, 1.0)); 1026 ASSERT_DOUBLE_EQ(-4.9406564584124654e-324, nextafter(0.0, -1.0)); 1027 } 1028 1029 TEST(math, nextafterf) { 1030 ASSERT_FLOAT_EQ(0.0f, nextafterf(0.0f, 0.0f)); 1031 ASSERT_FLOAT_EQ(1.4012985e-45f, nextafterf(0.0f, 1.0f)); 1032 ASSERT_FLOAT_EQ(-1.4012985e-45f, nextafterf(0.0f, -1.0f)); 1033 } 1034 1035 TEST(math, nextafterl) { 1036 ASSERT_DOUBLE_EQ(0.0L, nextafterl(0.0L, 0.0L)); 1037 // Use a runtime value to accomodate the case when 1038 // sizeof(double) == sizeof(long double) 1039 long double smallest_positive = ldexpl(1.0L, LDBL_MIN_EXP - LDBL_MANT_DIG); 1040 ASSERT_DOUBLE_EQ(smallest_positive, nextafterl(0.0L, 1.0L)); 1041 ASSERT_DOUBLE_EQ(-smallest_positive, nextafterl(0.0L, -1.0L)); 1042 } 1043 1044 TEST(math, nexttoward) { 1045 ASSERT_DOUBLE_EQ(0.0, nexttoward(0.0, 0.0L)); 1046 ASSERT_DOUBLE_EQ(4.9406564584124654e-324, nexttoward(0.0, 1.0L)); 1047 ASSERT_DOUBLE_EQ(-4.9406564584124654e-324, nexttoward(0.0, -1.0L)); 1048 } 1049 1050 TEST(math, nexttowardf) { 1051 ASSERT_FLOAT_EQ(0.0f, nexttowardf(0.0f, 0.0L)); 1052 ASSERT_FLOAT_EQ(1.4012985e-45f, nexttowardf(0.0f, 1.0L)); 1053 ASSERT_FLOAT_EQ(-1.4012985e-45f, nexttowardf(0.0f, -1.0L)); 1054 } 1055 1056 TEST(math, nexttowardl) { 1057 ASSERT_DOUBLE_EQ(0.0L, nexttowardl(0.0L, 0.0L)); 1058 // Use a runtime value to accomodate the case when 1059 // sizeof(double) == sizeof(long double) 1060 long double smallest_positive = ldexpl(1.0L, LDBL_MIN_EXP - LDBL_MANT_DIG); 1061 ASSERT_DOUBLE_EQ(smallest_positive, nexttowardl(0.0L, 1.0L)); 1062 ASSERT_DOUBLE_EQ(-smallest_positive, nexttowardl(0.0L, -1.0L)); 1063 } 1064 1065 TEST(math, copysign) { 1066 ASSERT_DOUBLE_EQ(0.0, copysign(0.0, 1.0)); 1067 ASSERT_DOUBLE_EQ(-0.0, copysign(0.0, -1.0)); 1068 ASSERT_DOUBLE_EQ(2.0, copysign(2.0, 1.0)); 1069 ASSERT_DOUBLE_EQ(-2.0, copysign(2.0, -1.0)); 1070 } 1071 1072 TEST(math, copysignf) { 1073 ASSERT_FLOAT_EQ(0.0f, copysignf(0.0f, 1.0f)); 1074 ASSERT_FLOAT_EQ(-0.0f, copysignf(0.0f, -1.0f)); 1075 ASSERT_FLOAT_EQ(2.0f, copysignf(2.0f, 1.0f)); 1076 ASSERT_FLOAT_EQ(-2.0f, copysignf(2.0f, -1.0f)); 1077 } 1078 1079 TEST(math, copysignl) { 1080 ASSERT_DOUBLE_EQ(0.0L, copysignl(0.0L, 1.0L)); 1081 ASSERT_DOUBLE_EQ(-0.0L, copysignl(0.0L, -1.0L)); 1082 ASSERT_DOUBLE_EQ(2.0L, copysignl(2.0L, 1.0L)); 1083 ASSERT_DOUBLE_EQ(-2.0L, copysignl(2.0L, -1.0L)); 1084 } 1085 1086 TEST(math, significand) { 1087 ASSERT_DOUBLE_EQ(0.0, significand(0.0)); 1088 ASSERT_DOUBLE_EQ(1.2, significand(1.2)); 1089 ASSERT_DOUBLE_EQ(1.53125, significand(12.25)); 1090 } 1091 1092 TEST(math, significandf) { 1093 ASSERT_FLOAT_EQ(0.0f, significandf(0.0f)); 1094 ASSERT_FLOAT_EQ(1.2f, significandf(1.2f)); 1095 ASSERT_FLOAT_EQ(1.53125f, significandf(12.25f)); 1096 } 1097 1098 TEST(math, significandl) { 1099 ASSERT_DOUBLE_EQ(0.0L, significandl(0.0L)); 1100 ASSERT_DOUBLE_EQ(1.2L, significandl(1.2L)); 1101 ASSERT_DOUBLE_EQ(1.53125L, significandl(12.25L)); 1102 } 1103 1104 TEST(math, scalb) { 1105 ASSERT_DOUBLE_EQ(12.0, scalb(3.0, 2.0)); 1106 } 1107 1108 TEST(math, scalbf) { 1109 ASSERT_FLOAT_EQ(12.0f, scalbf(3.0f, 2.0f)); 1110 } 1111 1112 TEST(math, scalbln) { 1113 ASSERT_DOUBLE_EQ(12.0, scalbln(3.0, 2L)); 1114 } 1115 1116 TEST(math, scalblnf) { 1117 ASSERT_FLOAT_EQ(12.0f, scalblnf(3.0f, 2L)); 1118 } 1119 1120 TEST(math, scalblnl) { 1121 ASSERT_DOUBLE_EQ(12.0L, scalblnl(3.0L, 2L)); 1122 } 1123 1124 TEST(math, scalbn) { 1125 ASSERT_DOUBLE_EQ(12.0, scalbn(3.0, 2)); 1126 } 1127 1128 TEST(math, scalbnf) { 1129 ASSERT_FLOAT_EQ(12.0f, scalbnf(3.0f, 2)); 1130 } 1131 1132 TEST(math, scalbnl) { 1133 ASSERT_DOUBLE_EQ(12.0L, scalbnl(3.0L, 2)); 1134 } 1135 1136 TEST(math, gamma) { 1137 ASSERT_DOUBLE_EQ(log(24.0), gamma(5.0)); 1138 } 1139 1140 TEST(math, gammaf) { 1141 ASSERT_FLOAT_EQ(logf(24.0f), gammaf(5.0f)); 1142 } 1143 1144 TEST(math, gamma_r) { 1145 #if defined(__BIONIC__) 1146 int sign; 1147 ASSERT_DOUBLE_EQ(log(24.0), gamma_r(5.0, &sign)); 1148 ASSERT_EQ(1, sign); 1149 #else // __BIONIC__ 1150 GTEST_LOG_(INFO) << "glibc doesn't have gamma_r.\n"; 1151 #endif // __BIONIC__ 1152 } 1153 1154 TEST(math, gammaf_r) { 1155 #if defined(__BIONIC__) 1156 int sign; 1157 ASSERT_FLOAT_EQ(logf(24.0f), gammaf_r(5.0f, &sign)); 1158 ASSERT_EQ(1, sign); 1159 #else // __BIONIC__ 1160 GTEST_LOG_(INFO) << "glibc doesn't have gammaf_r.\n"; 1161 #endif // __BIONIC__ 1162 } 1163 1164 TEST(math, lgamma) { 1165 ASSERT_DOUBLE_EQ(log(24.0), lgamma(5.0)); 1166 } 1167 1168 TEST(math, lgammaf) { 1169 ASSERT_FLOAT_EQ(logf(24.0f), lgammaf(5.0f)); 1170 } 1171 1172 TEST(math, lgammal) { 1173 ASSERT_DOUBLE_EQ(logl(24.0L), lgammal(5.0L)); 1174 } 1175 1176 TEST(math, lgamma_r) { 1177 int sign; 1178 ASSERT_DOUBLE_EQ(log(24.0), lgamma_r(5.0, &sign)); 1179 ASSERT_EQ(1, sign); 1180 } 1181 1182 TEST(math, lgamma_r_17471883) { 1183 int sign; 1184 1185 sign = 0; 1186 ASSERT_DOUBLE_EQ(HUGE_VAL, lgamma_r(0.0, &sign)); 1187 ASSERT_EQ(1, sign); 1188 sign = 0; 1189 ASSERT_DOUBLE_EQ(HUGE_VAL, lgamma_r(-0.0, &sign)); 1190 ASSERT_EQ(-1, sign); 1191 } 1192 1193 TEST(math, lgammaf_r) { 1194 int sign; 1195 ASSERT_FLOAT_EQ(logf(24.0f), lgammaf_r(5.0f, &sign)); 1196 ASSERT_EQ(1, sign); 1197 } 1198 1199 TEST(math, lgammaf_r_17471883) { 1200 int sign; 1201 1202 sign = 0; 1203 ASSERT_FLOAT_EQ(HUGE_VALF, lgammaf_r(0.0f, &sign)); 1204 ASSERT_EQ(1, sign); 1205 sign = 0; 1206 ASSERT_FLOAT_EQ(HUGE_VALF, lgammaf_r(-0.0f, &sign)); 1207 ASSERT_EQ(-1, sign); 1208 } 1209 1210 TEST(math, lgammal_r) { 1211 int sign; 1212 ASSERT_DOUBLE_EQ(log(24.0L), lgamma_r(5.0L, &sign)); 1213 ASSERT_EQ(1, sign); 1214 } 1215 1216 TEST(math, lgammal_r_17471883) { 1217 int sign; 1218 1219 sign = 0; 1220 ASSERT_DOUBLE_EQ(HUGE_VAL, lgammal_r(0.0L, &sign)); 1221 ASSERT_EQ(1, sign); 1222 sign = 0; 1223 ASSERT_DOUBLE_EQ(HUGE_VAL, lgammal_r(-0.0L, &sign)); 1224 ASSERT_EQ(-1, sign); 1225 } 1226 1227 TEST(math, tgamma) { 1228 ASSERT_DOUBLE_EQ(24.0, tgamma(5.0)); 1229 } 1230 1231 TEST(math, tgammaf) { 1232 ASSERT_FLOAT_EQ(24.0f, tgammaf(5.0f)); 1233 } 1234 1235 TEST(math, tgammal) { 1236 ASSERT_DOUBLE_EQ(24.0L, tgammal(5.0L)); 1237 } 1238 1239 TEST(math, j0) { 1240 ASSERT_DOUBLE_EQ(1.0, j0(0.0)); 1241 ASSERT_DOUBLE_EQ(0.76519768655796661, j0(1.0)); 1242 } 1243 1244 TEST(math, j0f) { 1245 ASSERT_FLOAT_EQ(1.0f, j0f(0.0f)); 1246 ASSERT_FLOAT_EQ(0.76519769f, j0f(1.0f)); 1247 } 1248 1249 TEST(math, j1) { 1250 ASSERT_DOUBLE_EQ(0.0, j1(0.0)); 1251 ASSERT_DOUBLE_EQ(0.44005058574493355, j1(1.0)); 1252 } 1253 1254 TEST(math, j1f) { 1255 ASSERT_FLOAT_EQ(0.0f, j1f(0.0f)); 1256 ASSERT_FLOAT_EQ(0.44005057f, j1f(1.0f)); 1257 } 1258 1259 TEST(math, jn) { 1260 ASSERT_DOUBLE_EQ(0.0, jn(4, 0.0)); 1261 ASSERT_DOUBLE_EQ(0.0024766389641099553, jn(4, 1.0)); 1262 } 1263 1264 TEST(math, jnf) { 1265 ASSERT_FLOAT_EQ(0.0f, jnf(4, 0.0f)); 1266 ASSERT_FLOAT_EQ(0.0024766389f, jnf(4, 1.0f)); 1267 } 1268 1269 TEST(math, y0) { 1270 ASSERT_DOUBLE_EQ(-HUGE_VAL, y0(0.0)); 1271 ASSERT_DOUBLE_EQ(0.08825696421567697, y0(1.0)); 1272 } 1273 1274 TEST(math, y0f) { 1275 ASSERT_FLOAT_EQ(-HUGE_VALF, y0f(0.0f)); 1276 ASSERT_FLOAT_EQ(0.088256963f, y0f(1.0f)); 1277 } 1278 1279 TEST(math, y1) { 1280 ASSERT_DOUBLE_EQ(-HUGE_VAL, y1(0.0)); 1281 ASSERT_DOUBLE_EQ(-0.78121282130028868, y1(1.0)); 1282 } 1283 1284 TEST(math, y1f) { 1285 ASSERT_FLOAT_EQ(-HUGE_VALF, y1f(0.0f)); 1286 ASSERT_FLOAT_EQ(-0.78121281f, y1f(1.0f)); 1287 } 1288 1289 TEST(math, yn) { 1290 ASSERT_DOUBLE_EQ(-HUGE_VAL, yn(4, 0.0)); 1291 ASSERT_DOUBLE_EQ(-33.278423028972114, yn(4, 1.0)); 1292 } 1293 1294 TEST(math, ynf) { 1295 ASSERT_FLOAT_EQ(-HUGE_VALF, ynf(4, 0.0f)); 1296 ASSERT_FLOAT_EQ(-33.278423f, ynf(4, 1.0f)); 1297 } 1298 1299 TEST(math, frexp) { 1300 int exp; 1301 double dr = frexp(1024.0, &exp); 1302 ASSERT_DOUBLE_EQ(1024.0, scalbn(dr, exp)); 1303 } 1304 1305 TEST(math, frexpf) { 1306 int exp; 1307 float fr = frexpf(1024.0f, &exp); 1308 ASSERT_FLOAT_EQ(1024.0f, scalbnf(fr, exp)); 1309 } 1310 1311 TEST(math, frexpl) { 1312 int exp; 1313 long double ldr = frexpl(1024.0L, &exp); 1314 ASSERT_DOUBLE_EQ(1024.0L, scalbnl(ldr, exp)); 1315 } 1316 1317 TEST(math, modf) { 1318 double di; 1319 double df = modf(123.75, &di); 1320 ASSERT_DOUBLE_EQ(123.0, di); 1321 ASSERT_DOUBLE_EQ(0.75, df); 1322 } 1323 1324 TEST(math, modff) { 1325 float fi; 1326 float ff = modff(123.75f, &fi); 1327 ASSERT_FLOAT_EQ(123.0f, fi); 1328 ASSERT_FLOAT_EQ(0.75f, ff); 1329 } 1330 1331 TEST(math, modfl) { 1332 long double ldi; 1333 long double ldf = modfl(123.75L, &ldi); 1334 ASSERT_DOUBLE_EQ(123.0L, ldi); 1335 ASSERT_DOUBLE_EQ(0.75L, ldf); 1336 } 1337 1338 TEST(math, remquo) { 1339 int q; 1340 double d = remquo(13.0, 4.0, &q); 1341 ASSERT_EQ(3, q); 1342 ASSERT_DOUBLE_EQ(1.0, d); 1343 } 1344 1345 TEST(math, remquof) { 1346 int q; 1347 float f = remquof(13.0f, 4.0f, &q); 1348 ASSERT_EQ(3, q); 1349 ASSERT_FLOAT_EQ(1.0, f); 1350 } 1351 1352 TEST(math, remquol) { 1353 int q; 1354 long double ld = remquol(13.0L, 4.0L, &q); 1355 ASSERT_DOUBLE_EQ(3L, q); 1356 ASSERT_DOUBLE_EQ(1.0L, ld); 1357 } 1358 1359 // https://code.google.com/p/android/issues/detail?id=6697 1360 TEST(math, frexpf_public_bug_6697) { 1361 int exp; 1362 float fr = frexpf(14.1f, &exp); 1363 ASSERT_FLOAT_EQ(14.1f, scalbnf(fr, exp)); 1364 } 1365 1366 TEST(math, exp2_STRICT_ALIGN_OpenBSD_bug) { 1367 // OpenBSD/x86's libm had a bug here, but it was already fixed in FreeBSD: 1368 // http://svnweb.FreeBSD.org/base/head/lib/msun/src/math_private.h?revision=240827&view=markup 1369 ASSERT_DOUBLE_EQ(5.0, exp2(log2(5))); 1370 ASSERT_FLOAT_EQ(5.0f, exp2f(log2f(5))); 1371 ASSERT_DOUBLE_EQ(5.0L, exp2l(log2l(5))); 1372 } 1373 1374 TEST(math, nextafterl_OpenBSD_bug) { 1375 // OpenBSD/x86's libm had a bug here. 1376 ASSERT_TRUE(nextafter(1.0, 0.0) - 1.0 < 0.0); 1377 ASSERT_TRUE(nextafterf(1.0f, 0.0f) - 1.0f < 0.0f); 1378 ASSERT_TRUE(nextafterl(1.0L, 0.0L) - 1.0L < 0.0L); 1379 } 1380 1381 #include "math_data/acos_intel_data.h" 1382 TEST(math, acos_intel) { 1383 DoMathDataTest<1>(g_acos_intel_data, acos); 1384 } 1385 1386 #include "math_data/acosf_intel_data.h" 1387 TEST(math, acosf_intel) { 1388 DoMathDataTest<1>(g_acosf_intel_data, acosf); 1389 } 1390 1391 #include "math_data/acosh_intel_data.h" 1392 TEST(math, acosh_intel) { 1393 DoMathDataTest<2>(g_acosh_intel_data, acosh); 1394 } 1395 1396 #include "math_data/acoshf_intel_data.h" 1397 TEST(math, acoshf_intel) { 1398 DoMathDataTest<2>(g_acoshf_intel_data, acoshf); 1399 } 1400 1401 #include "math_data/asin_intel_data.h" 1402 TEST(math, asin_intel) { 1403 DoMathDataTest<1>(g_asin_intel_data, asin); 1404 } 1405 1406 #include "math_data/asinf_intel_data.h" 1407 TEST(math, asinf_intel) { 1408 DoMathDataTest<1>(g_asinf_intel_data, asinf); 1409 } 1410 1411 #include "math_data/asinh_intel_data.h" 1412 TEST(math, asinh_intel) { 1413 DoMathDataTest<2>(g_asinh_intel_data, asinh); 1414 } 1415 1416 #include "math_data/asinhf_intel_data.h" 1417 TEST(math, asinhf_intel) { 1418 DoMathDataTest<2>(g_asinhf_intel_data, asinhf); 1419 } 1420 1421 #include "math_data/atan2_intel_data.h" 1422 TEST(math, atan2_intel) { 1423 DoMathDataTest<2>(g_atan2_intel_data, atan2); 1424 } 1425 1426 #include "math_data/atan2f_intel_data.h" 1427 TEST(math, atan2f_intel) { 1428 DoMathDataTest<2>(g_atan2f_intel_data, atan2f); 1429 } 1430 1431 #include "math_data/atan_intel_data.h" 1432 TEST(math, atan_intel) { 1433 DoMathDataTest<1>(g_atan_intel_data, atan); 1434 } 1435 1436 #include "math_data/atanf_intel_data.h" 1437 TEST(math, atanf_intel) { 1438 DoMathDataTest<1>(g_atanf_intel_data, atanf); 1439 } 1440 1441 #include "math_data/atanh_intel_data.h" 1442 TEST(math, atanh_intel) { 1443 DoMathDataTest<2>(g_atanh_intel_data, atanh); 1444 } 1445 1446 #include "math_data/atanhf_intel_data.h" 1447 TEST(math, atanhf_intel) { 1448 DoMathDataTest<2>(g_atanhf_intel_data, atanhf); 1449 } 1450 1451 #include "math_data/cbrt_intel_data.h" 1452 TEST(math, cbrt_intel) { 1453 DoMathDataTest<1>(g_cbrt_intel_data, cbrt); 1454 } 1455 1456 #include "math_data/cbrtf_intel_data.h" 1457 TEST(math, cbrtf_intel) { 1458 DoMathDataTest<1>(g_cbrtf_intel_data, cbrtf); 1459 } 1460 1461 #include "math_data/ceil_intel_data.h" 1462 TEST(math, ceil_intel) { 1463 DoMathDataTest<1>(g_ceil_intel_data, ceil); 1464 } 1465 1466 #include "math_data/ceilf_intel_data.h" 1467 TEST(math, ceilf_intel) { 1468 DoMathDataTest<1>(g_ceilf_intel_data, ceilf); 1469 } 1470 1471 #include "math_data/copysign_intel_data.h" 1472 TEST(math, copysign_intel) { 1473 DoMathDataTest<1>(g_copysign_intel_data, copysign); 1474 } 1475 1476 #include "math_data/copysignf_intel_data.h" 1477 TEST(math, copysignf_intel) { 1478 DoMathDataTest<1>(g_copysignf_intel_data, copysignf); 1479 } 1480 1481 #include "math_data/cos_intel_data.h" 1482 TEST(math, cos_intel) { 1483 DoMathDataTest<1>(g_cos_intel_data, cos); 1484 } 1485 1486 #include "math_data/cosf_intel_data.h" 1487 TEST(math, cosf_intel) { 1488 DoMathDataTest<1>(g_cosf_intel_data, cosf); 1489 } 1490 1491 #include "math_data/cosh_intel_data.h" 1492 TEST(math, cosh_intel) { 1493 DoMathDataTest<2>(g_cosh_intel_data, cosh); 1494 } 1495 1496 #include "math_data/coshf_intel_data.h" 1497 TEST(math, coshf_intel) { 1498 DoMathDataTest<2>(g_coshf_intel_data, coshf); 1499 } 1500 1501 #include "math_data/exp_intel_data.h" 1502 TEST(math, exp_intel) { 1503 DoMathDataTest<1>(g_exp_intel_data, exp); 1504 } 1505 1506 #include "math_data/expf_intel_data.h" 1507 TEST(math, expf_intel) { 1508 DoMathDataTest<1>(g_expf_intel_data, expf); 1509 } 1510 1511 #include "math_data/exp2_intel_data.h" 1512 TEST(math, exp2_intel) { 1513 DoMathDataTest<1>(g_exp2_intel_data, exp2); 1514 } 1515 1516 #include "math_data/exp2f_intel_data.h" 1517 TEST(math, exp2f_intel) { 1518 DoMathDataTest<1>(g_exp2f_intel_data, exp2f); 1519 } 1520 1521 #include "math_data/expm1_intel_data.h" 1522 TEST(math, expm1_intel) { 1523 DoMathDataTest<1>(g_expm1_intel_data, expm1); 1524 } 1525 1526 #include "math_data/expm1f_intel_data.h" 1527 TEST(math, expm1f_intel) { 1528 DoMathDataTest<1>(g_expm1f_intel_data, expm1f); 1529 } 1530 1531 #include "math_data/fabs_intel_data.h" 1532 TEST(math, fabs_intel) { 1533 DoMathDataTest<1>(g_fabs_intel_data, fabs); 1534 } 1535 1536 #include "math_data/fabsf_intel_data.h" 1537 TEST(math, fabsf_intel) { 1538 DoMathDataTest<1>(g_fabsf_intel_data, fabsf); 1539 } 1540 1541 #include "math_data/fdim_intel_data.h" 1542 TEST(math, fdim_intel) { 1543 DoMathDataTest<1>(g_fdim_intel_data, fdim); 1544 } 1545 1546 #include "math_data/fdimf_intel_data.h" 1547 TEST(math, fdimf_intel) { 1548 DoMathDataTest<1>(g_fdimf_intel_data, fdimf); 1549 } 1550 1551 #include "math_data/floor_intel_data.h" 1552 TEST(math, floor_intel) { 1553 DoMathDataTest<1>(g_floor_intel_data, floor); 1554 } 1555 1556 #include "math_data/floorf_intel_data.h" 1557 TEST(math, floorf_intel) { 1558 DoMathDataTest<1>(g_floorf_intel_data, floorf); 1559 } 1560 1561 #include "math_data/fma_intel_data.h" 1562 TEST(math, fma_intel) { 1563 DoMathDataTest<1>(g_fma_intel_data, fma); 1564 } 1565 1566 #include "math_data/fmaf_intel_data.h" 1567 TEST(math, fmaf_intel) { 1568 DoMathDataTest<1>(g_fmaf_intel_data, fmaf); 1569 } 1570 1571 #include "math_data/fmax_intel_data.h" 1572 TEST(math, fmax_intel) { 1573 DoMathDataTest<1>(g_fmax_intel_data, fmax); 1574 } 1575 1576 #include "math_data/fmaxf_intel_data.h" 1577 TEST(math, fmaxf_intel) { 1578 DoMathDataTest<1>(g_fmaxf_intel_data, fmaxf); 1579 } 1580 1581 #include "math_data/fmin_intel_data.h" 1582 TEST(math, fmin_intel) { 1583 DoMathDataTest<1>(g_fmin_intel_data, fmin); 1584 } 1585 1586 #include "math_data/fminf_intel_data.h" 1587 TEST(math, fminf_intel) { 1588 DoMathDataTest<1>(g_fminf_intel_data, fminf); 1589 } 1590 1591 #include "math_data/fmod_intel_data.h" 1592 TEST(math, fmod_intel) { 1593 DoMathDataTest<1>(g_fmod_intel_data, fmod); 1594 } 1595 1596 #include "math_data/fmodf_intel_data.h" 1597 TEST(math, fmodf_intel) { 1598 DoMathDataTest<1>(g_fmodf_intel_data, fmodf); 1599 } 1600 1601 #include "math_data/frexp_intel_data.h" 1602 TEST(math, frexp_intel) { 1603 DoMathDataTest<1>(g_frexp_intel_data, frexp); 1604 } 1605 1606 #include "math_data/frexpf_intel_data.h" 1607 TEST(math, frexpf_intel) { 1608 DoMathDataTest<1>(g_frexpf_intel_data, frexpf); 1609 } 1610 1611 #include "math_data/hypot_intel_data.h" 1612 TEST(math, hypot_intel) { 1613 DoMathDataTest<1>(g_hypot_intel_data, hypot); 1614 } 1615 1616 #include "math_data/hypotf_intel_data.h" 1617 TEST(math, hypotf_intel) { 1618 DoMathDataTest<1>(g_hypotf_intel_data, hypotf); 1619 } 1620 1621 #include "math_data/ilogb_intel_data.h" 1622 TEST(math, ilogb_intel) { 1623 DoMathDataTest<1>(g_ilogb_intel_data, ilogb); 1624 } 1625 1626 #include "math_data/ilogbf_intel_data.h" 1627 TEST(math, ilogbf_intel) { 1628 DoMathDataTest<1>(g_ilogbf_intel_data, ilogbf); 1629 } 1630 1631 #include "math_data/ldexp_intel_data.h" 1632 TEST(math, ldexp_intel) { 1633 DoMathDataTest<1>(g_ldexp_intel_data, ldexp); 1634 } 1635 1636 #include "math_data/ldexpf_intel_data.h" 1637 TEST(math, ldexpf_intel) { 1638 DoMathDataTest<1>(g_ldexpf_intel_data, ldexpf); 1639 } 1640 1641 #include "math_data/llrint_intel_data.h" 1642 TEST(math, llrint_intel) { 1643 DoMathDataTest<1>(g_llrint_intel_data, llrint); 1644 } 1645 1646 #include "math_data/llrintf_intel_data.h" 1647 TEST(math, llrintf_intel) { 1648 DoMathDataTest<1>(g_llrintf_intel_data, llrintf); 1649 } 1650 1651 #include "math_data/log_intel_data.h" 1652 TEST(math, log_intel) { 1653 DoMathDataTest<1>(g_log_intel_data, log); 1654 } 1655 1656 #include "math_data/logf_intel_data.h" 1657 TEST(math, logf_intel) { 1658 DoMathDataTest<1>(g_logf_intel_data, logf); 1659 } 1660 1661 #include "math_data/log10_intel_data.h" 1662 TEST(math, log10_intel) { 1663 DoMathDataTest<1>(g_log10_intel_data, log10); 1664 } 1665 1666 #include "math_data/log10f_intel_data.h" 1667 TEST(math, log10f_intel) { 1668 DoMathDataTest<1>(g_log10f_intel_data, log10f); 1669 } 1670 1671 #include "math_data/log1p_intel_data.h" 1672 TEST(math, log1p_intel) { 1673 DoMathDataTest<1>(g_log1p_intel_data, log1p); 1674 } 1675 1676 #include "math_data/log1pf_intel_data.h" 1677 TEST(math, log1pf_intel) { 1678 DoMathDataTest<1>(g_log1pf_intel_data, log1pf); 1679 } 1680 1681 #include "math_data/log2_intel_data.h" 1682 TEST(math, log2_intel) { 1683 DoMathDataTest<1>(g_log2_intel_data, log2); 1684 } 1685 1686 #include "math_data/log2f_intel_data.h" 1687 TEST(math, log2f_intel) { 1688 DoMathDataTest<1>(g_log2f_intel_data, log2f); 1689 } 1690 1691 #include "math_data/logb_intel_data.h" 1692 TEST(math, logb_intel) { 1693 DoMathDataTest<1>(g_logb_intel_data, logb); 1694 } 1695 1696 #include "math_data/logbf_intel_data.h" 1697 TEST(math, logbf_intel) { 1698 DoMathDataTest<1>(g_logbf_intel_data, logbf); 1699 } 1700 1701 #include "math_data/lrint_intel_data.h" 1702 TEST(math, lrint_intel) { 1703 DoMathDataTest<1>(g_lrint_intel_data, lrint); 1704 } 1705 1706 #include "math_data/lrintf_intel_data.h" 1707 TEST(math, lrintf_intel) { 1708 DoMathDataTest<1>(g_lrintf_intel_data, lrintf); 1709 } 1710 1711 #include "math_data/modf_intel_data.h" 1712 TEST(math, modf_intel) { 1713 DoMathDataTest<1>(g_modf_intel_data, modf); 1714 } 1715 1716 #include "math_data/modff_intel_data.h" 1717 TEST(math, modff_intel) { 1718 DoMathDataTest<1>(g_modff_intel_data, modff); 1719 } 1720 1721 #include "math_data/nearbyint_intel_data.h" 1722 TEST(math, nearbyint_intel) { 1723 DoMathDataTest<1>(g_nearbyint_intel_data, nearbyint); 1724 } 1725 1726 #include "math_data/nearbyintf_intel_data.h" 1727 TEST(math, nearbyintf_intel) { 1728 DoMathDataTest<1>(g_nearbyintf_intel_data, nearbyintf); 1729 } 1730 1731 #include "math_data/nextafter_intel_data.h" 1732 TEST(math, nextafter_intel) { 1733 DoMathDataTest<1>(g_nextafter_intel_data, nextafter); 1734 } 1735 1736 #include "math_data/nextafterf_intel_data.h" 1737 TEST(math, nextafterf_intel) { 1738 DoMathDataTest<1>(g_nextafterf_intel_data, nextafterf); 1739 } 1740 1741 #include "math_data/pow_intel_data.h" 1742 TEST(math, pow_intel) { 1743 DoMathDataTest<1>(g_pow_intel_data, pow); 1744 } 1745 1746 #include "math_data/powf_intel_data.h" 1747 TEST(math, powf_intel) { 1748 DoMathDataTest<1>(g_powf_intel_data, powf); 1749 } 1750 1751 #include "math_data/remainder_intel_data.h" 1752 TEST(math, remainder_intel) { 1753 DoMathDataTest<1>(g_remainder_intel_data, remainder); 1754 } 1755 1756 #include "math_data/remainderf_intel_data.h" 1757 TEST(math, remainderf_intel) { 1758 DoMathDataTest<1>(g_remainderf_intel_data, remainderf); 1759 } 1760 1761 #include "math_data/remquo_intel_data.h" 1762 TEST(math, remquo_intel) { 1763 DoMathDataTest<1>(g_remquo_intel_data, remquo); 1764 } 1765 1766 #include "math_data/remquof_intel_data.h" 1767 TEST(math, remquof_intel) { 1768 DoMathDataTest<1>(g_remquof_intel_data, remquof); 1769 } 1770 1771 #include "math_data/rint_intel_data.h" 1772 TEST(math, rint_intel) { 1773 DoMathDataTest<1>(g_rint_intel_data, rint); 1774 } 1775 1776 #include "math_data/rintf_intel_data.h" 1777 TEST(math, rintf_intel) { 1778 DoMathDataTest<1>(g_rintf_intel_data, rintf); 1779 } 1780 1781 #include "math_data/round_intel_data.h" 1782 TEST(math, round_intel) { 1783 DoMathDataTest<1>(g_round_intel_data, round); 1784 } 1785 1786 #include "math_data/roundf_intel_data.h" 1787 TEST(math, roundf_intel) { 1788 DoMathDataTest<1>(g_roundf_intel_data, roundf); 1789 } 1790 1791 #include "math_data/scalb_intel_data.h" 1792 TEST(math, scalb_intel) { 1793 DoMathDataTest<1>(g_scalb_intel_data, scalb); 1794 } 1795 1796 #include "math_data/scalbf_intel_data.h" 1797 TEST(math, scalbf_intel) { 1798 DoMathDataTest<1>(g_scalbf_intel_data, scalbf); 1799 } 1800 1801 #include "math_data/scalbn_intel_data.h" 1802 TEST(math, scalbn_intel) { 1803 DoMathDataTest<1>(g_scalbn_intel_data, scalbn); 1804 } 1805 1806 #include "math_data/scalbnf_intel_data.h" 1807 TEST(math, scalbnf_intel) { 1808 DoMathDataTest<1>(g_scalbnf_intel_data, scalbnf); 1809 } 1810 1811 #include "math_data/significand_intel_data.h" 1812 TEST(math, significand_intel) { 1813 DoMathDataTest<1>(g_significand_intel_data, significand); 1814 } 1815 1816 #include "math_data/significandf_intel_data.h" 1817 TEST(math, significandf_intel) { 1818 DoMathDataTest<1>(g_significandf_intel_data, significandf); 1819 } 1820 1821 #include "math_data/sin_intel_data.h" 1822 TEST(math, sin_intel) { 1823 DoMathDataTest<1>(g_sin_intel_data, sin); 1824 } 1825 1826 #include "math_data/sinf_intel_data.h" 1827 TEST(math, sinf_intel) { 1828 DoMathDataTest<1>(g_sinf_intel_data, sinf); 1829 } 1830 1831 #include "math_data/sinh_intel_data.h" 1832 TEST(math, sinh_intel) { 1833 DoMathDataTest<2>(g_sinh_intel_data, sinh); 1834 } 1835 1836 #include "math_data/sinhf_intel_data.h" 1837 TEST(math, sinhf_intel) { 1838 DoMathDataTest<2>(g_sinhf_intel_data, sinhf); 1839 } 1840 1841 #include "math_data/sincos_intel_data.h" 1842 TEST(math, sincos_intel) { 1843 DoMathDataTest<1>(g_sincos_intel_data, sincos); 1844 } 1845 1846 #include "math_data/sincosf_intel_data.h" 1847 TEST(math, sincosf_intel) { 1848 DoMathDataTest<1>(g_sincosf_intel_data, sincosf); 1849 } 1850 1851 #include "math_data/sqrt_intel_data.h" 1852 TEST(math, sqrt_intel) { 1853 DoMathDataTest<1>(g_sqrt_intel_data, sqrt); 1854 } 1855 1856 #include "math_data/sqrtf_intel_data.h" 1857 TEST(math, sqrtf_intel) { 1858 DoMathDataTest<1>(g_sqrtf_intel_data, sqrtf); 1859 } 1860 1861 #include "math_data/tan_intel_data.h" 1862 TEST(math, tan_intel) { 1863 DoMathDataTest<1>(g_tan_intel_data, tan); 1864 } 1865 1866 #include "math_data/tanf_intel_data.h" 1867 TEST(math, tanf_intel) { 1868 DoMathDataTest<1>(g_tanf_intel_data, tanf); 1869 } 1870 1871 #include "math_data/tanh_intel_data.h" 1872 TEST(math, tanh_intel) { 1873 DoMathDataTest<2>(g_tanh_intel_data, tanh); 1874 } 1875 1876 #include "math_data/tanhf_intel_data.h" 1877 TEST(math, tanhf_intel) { 1878 DoMathDataTest<2>(g_tanhf_intel_data, tanhf); 1879 } 1880 1881 #include "math_data/trunc_intel_data.h" 1882 TEST(math, trunc_intel) { 1883 DoMathDataTest<1>(g_trunc_intel_data, trunc); 1884 } 1885 1886 #include "math_data/truncf_intel_data.h" 1887 TEST(math, truncf_intel) { 1888 DoMathDataTest<1>(g_truncf_intel_data, truncf); 1889 } 1890
