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 <private/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 = make_scope_guard([]() { 779 fesetenv(FE_DFL_ENV); 780 }); 781 782 fesetround(FE_UPWARD); // lrint/lrintf/lrintl obey the rounding mode. 783 ASSERT_EQ(1235, lrint(1234.01)); 784 ASSERT_EQ(1235, lrintf(1234.01f)); 785 ASSERT_EQ(1235, lrintl(1234.01L)); 786 fesetround(FE_TOWARDZERO); // lrint/lrintf/lrintl obey the rounding mode. 787 ASSERT_EQ(1234, lrint(1234.01)); 788 ASSERT_EQ(1234, lrintf(1234.01f)); 789 ASSERT_EQ(1234, lrintl(1234.01L)); 790 791 fesetround(FE_UPWARD); // llrint/llrintf/llrintl obey the rounding mode. 792 ASSERT_EQ(1235L, llrint(1234.01)); 793 ASSERT_EQ(1235L, llrintf(1234.01f)); 794 ASSERT_EQ(1235L, llrintl(1234.01L)); 795 fesetround(FE_TOWARDZERO); // llrint/llrintf/llrintl obey the rounding mode. 796 ASSERT_EQ(1234L, llrint(1234.01)); 797 ASSERT_EQ(1234L, llrintf(1234.01f)); 798 ASSERT_EQ(1234L, llrintl(1234.01L)); 799 } 800 801 TEST(math, rint) { 802 auto guard = make_scope_guard([]() { 803 fesetenv(FE_DFL_ENV); 804 }); 805 806 fesetround(FE_UPWARD); // rint/rintf/rintl obey the rounding mode. 807 feclearexcept(FE_ALL_EXCEPT); // rint/rintf/rintl do set the FE_INEXACT flag. 808 ASSERT_EQ(1234.0, rint(1234.0)); 809 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 810 ASSERT_EQ(1235.0, rint(1234.01)); 811 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) != 0); 812 813 feclearexcept(FE_ALL_EXCEPT); // rint/rintf/rintl do set the FE_INEXACT flag. 814 ASSERT_EQ(1234.0f, rintf(1234.0f)); 815 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 816 ASSERT_EQ(1235.0f, rintf(1234.01f)); 817 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) != 0); 818 819 feclearexcept(FE_ALL_EXCEPT); // rint/rintf/rintl do set the FE_INEXACT flag. 820 ASSERT_EQ(1234.0, rintl(1234.0L)); 821 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 822 ASSERT_EQ(1235.0, rintl(1234.01L)); 823 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) != 0); 824 825 fesetround(FE_TOWARDZERO); // rint/rintf obey the rounding mode. 826 ASSERT_EQ(1234.0, rint(1234.01)); 827 ASSERT_EQ(1234.0f, rintf(1234.01f)); 828 ASSERT_EQ(1234.0, rintl(1234.01L)); 829 } 830 831 TEST(math, nearbyint) { 832 auto guard = make_scope_guard([]() { 833 fesetenv(FE_DFL_ENV); 834 }); 835 fesetround(FE_UPWARD); // nearbyint/nearbyintf/nearbyintl obey the rounding mode. 836 feclearexcept(FE_ALL_EXCEPT); // nearbyint/nearbyintf/nearbyintl don't set the FE_INEXACT flag. 837 ASSERT_EQ(1234.0, nearbyint(1234.0)); 838 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 839 ASSERT_EQ(1235.0, nearbyint(1234.01)); 840 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 841 842 feclearexcept(FE_ALL_EXCEPT); 843 ASSERT_EQ(1234.0f, nearbyintf(1234.0f)); 844 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 845 ASSERT_EQ(1235.0f, nearbyintf(1234.01f)); 846 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 847 848 feclearexcept(FE_ALL_EXCEPT); // nearbyint/nearbyintf/nearbyintl don't set the FE_INEXACT flag. 849 ASSERT_EQ(1234.0, nearbyintl(1234.0L)); 850 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 851 ASSERT_EQ(1235.0, nearbyintl(1234.01L)); 852 ASSERT_TRUE((fetestexcept(FE_ALL_EXCEPT) & FE_INEXACT) == 0); 853 854 fesetround(FE_TOWARDZERO); // nearbyint/nearbyintf/nearbyintl obey the rounding mode. 855 ASSERT_EQ(1234.0, nearbyint(1234.01)); 856 ASSERT_EQ(1234.0f, nearbyintf(1234.01f)); 857 ASSERT_EQ(1234.0, nearbyintl(1234.01L)); 858 } 859 860 TEST(math, lround) { 861 auto guard = make_scope_guard([]() { 862 fesetenv(FE_DFL_ENV); 863 }); 864 fesetround(FE_UPWARD); // lround ignores the rounding mode. 865 ASSERT_EQ(1234, lround(1234.01)); 866 ASSERT_EQ(1234, lroundf(1234.01f)); 867 ASSERT_EQ(1234, lroundl(1234.01L)); 868 } 869 870 TEST(math, llround) { 871 auto guard = make_scope_guard([]() { 872 fesetenv(FE_DFL_ENV); 873 }); 874 fesetround(FE_UPWARD); // llround ignores the rounding mode. 875 ASSERT_EQ(1234L, llround(1234.01)); 876 ASSERT_EQ(1234L, llroundf(1234.01f)); 877 ASSERT_EQ(1234L, llroundl(1234.01L)); 878 } 879 880 TEST(math, ilogb) { 881 ASSERT_EQ(FP_ILOGB0, ilogb(0.0)); 882 ASSERT_EQ(FP_ILOGBNAN, ilogb(nan(""))); 883 ASSERT_EQ(INT_MAX, ilogb(HUGE_VAL)); 884 ASSERT_EQ(0, ilogb(1.0)); 885 ASSERT_EQ(3, ilogb(10.0)); 886 } 887 888 TEST(math, ilogbf) { 889 ASSERT_EQ(FP_ILOGB0, ilogbf(0.0f)); 890 ASSERT_EQ(FP_ILOGBNAN, ilogbf(nanf(""))); 891 ASSERT_EQ(INT_MAX, ilogbf(HUGE_VALF)); 892 ASSERT_EQ(0, ilogbf(1.0f)); 893 ASSERT_EQ(3, ilogbf(10.0f)); 894 } 895 896 TEST(math, ilogbl) { 897 ASSERT_EQ(FP_ILOGB0, ilogbl(0.0L)); 898 ASSERT_EQ(FP_ILOGBNAN, ilogbl(nanl(""))); 899 ASSERT_EQ(INT_MAX, ilogbl(HUGE_VALL)); 900 ASSERT_EQ(0L, ilogbl(1.0L)); 901 ASSERT_EQ(3L, ilogbl(10.0L)); 902 } 903 904 TEST(math, logb) { 905 ASSERT_EQ(-HUGE_VAL, logb(0.0)); 906 ASSERT_TRUE(isnan(logb(nan("")))); 907 ASSERT_TRUE(isinf(logb(HUGE_VAL))); 908 ASSERT_EQ(0.0, logb(1.0)); 909 ASSERT_EQ(3.0, logb(10.0)); 910 } 911 912 TEST(math, logbf) { 913 ASSERT_EQ(-HUGE_VALF, logbf(0.0f)); 914 ASSERT_TRUE(isnanf(logbf(nanf("")))); 915 ASSERT_TRUE(__isinff(logbf(HUGE_VALF))); 916 ASSERT_EQ(0.0f, logbf(1.0f)); 917 ASSERT_EQ(3.0f, logbf(10.0f)); 918 } 919 920 TEST(math, logbl) { 921 ASSERT_EQ(-HUGE_VAL, logbl(0.0L)); 922 ASSERT_TRUE(isnan(logbl(nanl("")))); 923 ASSERT_TRUE(isinf(logbl(HUGE_VALL))); 924 ASSERT_EQ(0.0L, logbl(1.0L)); 925 ASSERT_EQ(3.0L, logbl(10.0L)); 926 } 927 928 TEST(math, log1p) { 929 ASSERT_EQ(-HUGE_VAL, log1p(-1.0)); 930 ASSERT_TRUE(isnan(log1p(nan("")))); 931 ASSERT_TRUE(isinf(log1p(HUGE_VAL))); 932 ASSERT_DOUBLE_EQ(1.0, log1p(M_E - 1.0)); 933 } 934 935 TEST(math, log1pf) { 936 ASSERT_EQ(-HUGE_VALF, log1pf(-1.0f)); 937 ASSERT_TRUE(isnanf(log1pf(nanf("")))); 938 ASSERT_TRUE(__isinff(log1pf(HUGE_VALF))); 939 ASSERT_FLOAT_EQ(1.0f, log1pf(static_cast<float>(M_E) - 1.0f)); 940 } 941 942 TEST(math, log1pl) { 943 ASSERT_EQ(-HUGE_VALL, log1pl(-1.0L)); 944 ASSERT_TRUE(isnan(log1pl(nanl("")))); 945 ASSERT_TRUE(isinf(log1pl(HUGE_VALL))); 946 ASSERT_DOUBLE_EQ(1.0L, log1pl(M_E - 1.0L)); 947 } 948 949 TEST(math, fdim) { 950 ASSERT_DOUBLE_EQ(0.0, fdim(1.0, 1.0)); 951 ASSERT_DOUBLE_EQ(1.0, fdim(2.0, 1.0)); 952 ASSERT_DOUBLE_EQ(0.0, fdim(1.0, 2.0)); 953 } 954 955 TEST(math, fdimf) { 956 ASSERT_FLOAT_EQ(0.0f, fdimf(1.0f, 1.0f)); 957 ASSERT_FLOAT_EQ(1.0f, fdimf(2.0f, 1.0f)); 958 ASSERT_FLOAT_EQ(0.0f, fdimf(1.0f, 2.0f)); 959 } 960 961 TEST(math, fdiml) { 962 ASSERT_DOUBLE_EQ(0.0L, fdiml(1.0L, 1.0L)); 963 ASSERT_DOUBLE_EQ(1.0L, fdiml(2.0L, 1.0L)); 964 ASSERT_DOUBLE_EQ(0.0L, fdiml(1.0L, 2.0L)); 965 } 966 967 TEST(math, round) { 968 auto guard = make_scope_guard([]() { 969 fesetenv(FE_DFL_ENV); 970 }); 971 fesetround(FE_TOWARDZERO); // round ignores the rounding mode and always rounds away from zero. 972 ASSERT_DOUBLE_EQ(1.0, round(0.5)); 973 ASSERT_DOUBLE_EQ(-1.0, round(-0.5)); 974 ASSERT_DOUBLE_EQ(0.0, round(0.0)); 975 ASSERT_DOUBLE_EQ(-0.0, round(-0.0)); 976 ASSERT_TRUE(isnan(round(nan("")))); 977 ASSERT_DOUBLE_EQ(HUGE_VAL, round(HUGE_VAL)); 978 } 979 980 TEST(math, roundf) { 981 auto guard = make_scope_guard([]() { 982 fesetenv(FE_DFL_ENV); 983 }); 984 fesetround(FE_TOWARDZERO); // roundf ignores the rounding mode and always rounds away from zero. 985 ASSERT_FLOAT_EQ(1.0f, roundf(0.5f)); 986 ASSERT_FLOAT_EQ(-1.0f, roundf(-0.5f)); 987 ASSERT_FLOAT_EQ(0.0f, roundf(0.0f)); 988 ASSERT_FLOAT_EQ(-0.0f, roundf(-0.0f)); 989 ASSERT_TRUE(isnanf(roundf(nanf("")))); 990 ASSERT_FLOAT_EQ(HUGE_VALF, roundf(HUGE_VALF)); 991 } 992 993 TEST(math, roundl) { 994 auto guard = make_scope_guard([]() { 995 fesetenv(FE_DFL_ENV); 996 }); 997 fesetround(FE_TOWARDZERO); // roundl ignores the rounding mode and always rounds away from zero. 998 ASSERT_DOUBLE_EQ(1.0L, roundl(0.5L)); 999 ASSERT_DOUBLE_EQ(-1.0L, roundl(-0.5L)); 1000 ASSERT_DOUBLE_EQ(0.0L, roundl(0.0L)); 1001 ASSERT_DOUBLE_EQ(-0.0L, roundl(-0.0L)); 1002 ASSERT_TRUE(isnan(roundl(nanl("")))); 1003 ASSERT_DOUBLE_EQ(HUGE_VALL, roundl(HUGE_VALL)); 1004 } 1005 1006 TEST(math, trunc) { 1007 auto guard = make_scope_guard([]() { 1008 fesetenv(FE_DFL_ENV); 1009 }); 1010 fesetround(FE_UPWARD); // trunc ignores the rounding mode and always rounds toward zero. 1011 ASSERT_DOUBLE_EQ(1.0, trunc(1.5)); 1012 ASSERT_DOUBLE_EQ(-1.0, trunc(-1.5)); 1013 ASSERT_DOUBLE_EQ(0.0, trunc(0.0)); 1014 ASSERT_DOUBLE_EQ(-0.0, trunc(-0.0)); 1015 ASSERT_TRUE(isnan(trunc(nan("")))); 1016 ASSERT_DOUBLE_EQ(HUGE_VAL, trunc(HUGE_VAL)); 1017 } 1018 1019 TEST(math, truncf) { 1020 auto guard = make_scope_guard([]() { 1021 fesetenv(FE_DFL_ENV); 1022 }); 1023 fesetround(FE_UPWARD); // truncf ignores the rounding mode and always rounds toward zero. 1024 ASSERT_FLOAT_EQ(1.0f, truncf(1.5f)); 1025 ASSERT_FLOAT_EQ(-1.0f, truncf(-1.5f)); 1026 ASSERT_FLOAT_EQ(0.0f, truncf(0.0f)); 1027 ASSERT_FLOAT_EQ(-0.0f, truncf(-0.0f)); 1028 ASSERT_TRUE(isnan(truncf(nanf("")))); 1029 ASSERT_FLOAT_EQ(HUGE_VALF, truncf(HUGE_VALF)); 1030 } 1031 1032 TEST(math, truncl) { 1033 auto guard = make_scope_guard([]() { 1034 fesetenv(FE_DFL_ENV); 1035 }); 1036 fesetround(FE_UPWARD); // truncl ignores the rounding mode and always rounds toward zero. 1037 ASSERT_DOUBLE_EQ(1.0L, truncl(1.5L)); 1038 ASSERT_DOUBLE_EQ(-1.0L, truncl(-1.5L)); 1039 ASSERT_DOUBLE_EQ(0.0L, truncl(0.0L)); 1040 ASSERT_DOUBLE_EQ(-0.0L, truncl(-0.0L)); 1041 ASSERT_TRUE(isnan(truncl(nan("")))); 1042 ASSERT_DOUBLE_EQ(HUGE_VALL, truncl(HUGE_VALL)); 1043 } 1044 1045 TEST(math, nextafter) { 1046 ASSERT_DOUBLE_EQ(0.0, nextafter(0.0, 0.0)); 1047 ASSERT_DOUBLE_EQ(4.9406564584124654e-324, nextafter(0.0, 1.0)); 1048 ASSERT_DOUBLE_EQ(-4.9406564584124654e-324, nextafter(0.0, -1.0)); 1049 } 1050 1051 TEST(math, nextafterf) { 1052 ASSERT_FLOAT_EQ(0.0f, nextafterf(0.0f, 0.0f)); 1053 ASSERT_FLOAT_EQ(1.4012985e-45f, nextafterf(0.0f, 1.0f)); 1054 ASSERT_FLOAT_EQ(-1.4012985e-45f, nextafterf(0.0f, -1.0f)); 1055 } 1056 1057 TEST(math, nextafterl) { 1058 ASSERT_DOUBLE_EQ(0.0L, nextafterl(0.0L, 0.0L)); 1059 // Use a runtime value to accomodate the case when 1060 // sizeof(double) == sizeof(long double) 1061 long double smallest_positive = ldexpl(1.0L, LDBL_MIN_EXP - LDBL_MANT_DIG); 1062 ASSERT_DOUBLE_EQ(smallest_positive, nextafterl(0.0L, 1.0L)); 1063 ASSERT_DOUBLE_EQ(-smallest_positive, nextafterl(0.0L, -1.0L)); 1064 } 1065 1066 TEST(math, nexttoward) { 1067 ASSERT_DOUBLE_EQ(0.0, nexttoward(0.0, 0.0L)); 1068 ASSERT_DOUBLE_EQ(4.9406564584124654e-324, nexttoward(0.0, 1.0L)); 1069 ASSERT_DOUBLE_EQ(-4.9406564584124654e-324, nexttoward(0.0, -1.0L)); 1070 } 1071 1072 TEST(math, nexttowardf) { 1073 ASSERT_FLOAT_EQ(0.0f, nexttowardf(0.0f, 0.0L)); 1074 ASSERT_FLOAT_EQ(1.4012985e-45f, nexttowardf(0.0f, 1.0L)); 1075 ASSERT_FLOAT_EQ(-1.4012985e-45f, nexttowardf(0.0f, -1.0L)); 1076 } 1077 1078 TEST(math, nexttowardl) { 1079 ASSERT_DOUBLE_EQ(0.0L, nexttowardl(0.0L, 0.0L)); 1080 // Use a runtime value to accomodate the case when 1081 // sizeof(double) == sizeof(long double) 1082 long double smallest_positive = ldexpl(1.0L, LDBL_MIN_EXP - LDBL_MANT_DIG); 1083 ASSERT_DOUBLE_EQ(smallest_positive, nexttowardl(0.0L, 1.0L)); 1084 ASSERT_DOUBLE_EQ(-smallest_positive, nexttowardl(0.0L, -1.0L)); 1085 } 1086 1087 TEST(math, copysign) { 1088 ASSERT_DOUBLE_EQ(0.0, copysign(0.0, 1.0)); 1089 ASSERT_DOUBLE_EQ(-0.0, copysign(0.0, -1.0)); 1090 ASSERT_DOUBLE_EQ(2.0, copysign(2.0, 1.0)); 1091 ASSERT_DOUBLE_EQ(-2.0, copysign(2.0, -1.0)); 1092 } 1093 1094 TEST(math, copysignf) { 1095 ASSERT_FLOAT_EQ(0.0f, copysignf(0.0f, 1.0f)); 1096 ASSERT_FLOAT_EQ(-0.0f, copysignf(0.0f, -1.0f)); 1097 ASSERT_FLOAT_EQ(2.0f, copysignf(2.0f, 1.0f)); 1098 ASSERT_FLOAT_EQ(-2.0f, copysignf(2.0f, -1.0f)); 1099 } 1100 1101 TEST(math, copysignl) { 1102 ASSERT_DOUBLE_EQ(0.0L, copysignl(0.0L, 1.0L)); 1103 ASSERT_DOUBLE_EQ(-0.0L, copysignl(0.0L, -1.0L)); 1104 ASSERT_DOUBLE_EQ(2.0L, copysignl(2.0L, 1.0L)); 1105 ASSERT_DOUBLE_EQ(-2.0L, copysignl(2.0L, -1.0L)); 1106 } 1107 1108 TEST(math, significand) { 1109 ASSERT_DOUBLE_EQ(0.0, significand(0.0)); 1110 ASSERT_DOUBLE_EQ(1.2, significand(1.2)); 1111 ASSERT_DOUBLE_EQ(1.53125, significand(12.25)); 1112 } 1113 1114 TEST(math, significandf) { 1115 ASSERT_FLOAT_EQ(0.0f, significandf(0.0f)); 1116 ASSERT_FLOAT_EQ(1.2f, significandf(1.2f)); 1117 ASSERT_FLOAT_EQ(1.53125f, significandf(12.25f)); 1118 } 1119 1120 TEST(math, significandl) { 1121 ASSERT_DOUBLE_EQ(0.0L, significandl(0.0L)); 1122 ASSERT_DOUBLE_EQ(1.2L, significandl(1.2L)); 1123 ASSERT_DOUBLE_EQ(1.53125L, significandl(12.25L)); 1124 } 1125 1126 TEST(math, scalb) { 1127 ASSERT_DOUBLE_EQ(12.0, scalb(3.0, 2.0)); 1128 } 1129 1130 TEST(math, scalbf) { 1131 ASSERT_FLOAT_EQ(12.0f, scalbf(3.0f, 2.0f)); 1132 } 1133 1134 TEST(math, scalbln) { 1135 ASSERT_DOUBLE_EQ(12.0, scalbln(3.0, 2L)); 1136 } 1137 1138 TEST(math, scalblnf) { 1139 ASSERT_FLOAT_EQ(12.0f, scalblnf(3.0f, 2L)); 1140 } 1141 1142 TEST(math, scalblnl) { 1143 ASSERT_DOUBLE_EQ(12.0L, scalblnl(3.0L, 2L)); 1144 } 1145 1146 TEST(math, scalbn) { 1147 ASSERT_DOUBLE_EQ(12.0, scalbn(3.0, 2)); 1148 } 1149 1150 TEST(math, scalbnf) { 1151 ASSERT_FLOAT_EQ(12.0f, scalbnf(3.0f, 2)); 1152 } 1153 1154 TEST(math, scalbnl) { 1155 ASSERT_DOUBLE_EQ(12.0L, scalbnl(3.0L, 2)); 1156 } 1157 1158 TEST(math, gamma) { 1159 ASSERT_DOUBLE_EQ(log(24.0), gamma(5.0)); 1160 } 1161 1162 TEST(math, gammaf) { 1163 ASSERT_FLOAT_EQ(logf(24.0f), gammaf(5.0f)); 1164 } 1165 1166 TEST(math, gamma_r) { 1167 #if defined(__BIONIC__) 1168 int sign; 1169 ASSERT_DOUBLE_EQ(log(24.0), gamma_r(5.0, &sign)); 1170 ASSERT_EQ(1, sign); 1171 #else // __BIONIC__ 1172 GTEST_LOG_(INFO) << "glibc doesn't have gamma_r.\n"; 1173 #endif // __BIONIC__ 1174 } 1175 1176 TEST(math, gammaf_r) { 1177 #if defined(__BIONIC__) 1178 int sign; 1179 ASSERT_FLOAT_EQ(logf(24.0f), gammaf_r(5.0f, &sign)); 1180 ASSERT_EQ(1, sign); 1181 #else // __BIONIC__ 1182 GTEST_LOG_(INFO) << "glibc doesn't have gammaf_r.\n"; 1183 #endif // __BIONIC__ 1184 } 1185 1186 TEST(math, lgamma) { 1187 ASSERT_DOUBLE_EQ(log(24.0), lgamma(5.0)); 1188 } 1189 1190 TEST(math, lgammaf) { 1191 ASSERT_FLOAT_EQ(logf(24.0f), lgammaf(5.0f)); 1192 } 1193 1194 TEST(math, lgammal) { 1195 ASSERT_DOUBLE_EQ(logl(24.0L), lgammal(5.0L)); 1196 } 1197 1198 TEST(math, lgamma_r) { 1199 int sign; 1200 ASSERT_DOUBLE_EQ(log(24.0), lgamma_r(5.0, &sign)); 1201 ASSERT_EQ(1, sign); 1202 } 1203 1204 TEST(math, lgamma_r_17471883) { 1205 int sign; 1206 1207 sign = 0; 1208 ASSERT_DOUBLE_EQ(HUGE_VAL, lgamma_r(0.0, &sign)); 1209 ASSERT_EQ(1, sign); 1210 sign = 0; 1211 ASSERT_DOUBLE_EQ(HUGE_VAL, lgamma_r(-0.0, &sign)); 1212 ASSERT_EQ(-1, sign); 1213 } 1214 1215 TEST(math, lgammaf_r) { 1216 int sign; 1217 ASSERT_FLOAT_EQ(logf(24.0f), lgammaf_r(5.0f, &sign)); 1218 ASSERT_EQ(1, sign); 1219 } 1220 1221 TEST(math, lgammaf_r_17471883) { 1222 int sign; 1223 1224 sign = 0; 1225 ASSERT_FLOAT_EQ(HUGE_VALF, lgammaf_r(0.0f, &sign)); 1226 ASSERT_EQ(1, sign); 1227 sign = 0; 1228 ASSERT_FLOAT_EQ(HUGE_VALF, lgammaf_r(-0.0f, &sign)); 1229 ASSERT_EQ(-1, sign); 1230 } 1231 1232 TEST(math, lgammal_r) { 1233 int sign; 1234 ASSERT_DOUBLE_EQ(log(24.0L), lgamma_r(5.0L, &sign)); 1235 ASSERT_EQ(1, sign); 1236 } 1237 1238 TEST(math, lgammal_r_17471883) { 1239 int sign; 1240 1241 sign = 0; 1242 ASSERT_DOUBLE_EQ(HUGE_VAL, lgammal_r(0.0L, &sign)); 1243 ASSERT_EQ(1, sign); 1244 sign = 0; 1245 ASSERT_DOUBLE_EQ(HUGE_VAL, lgammal_r(-0.0L, &sign)); 1246 ASSERT_EQ(-1, sign); 1247 } 1248 1249 TEST(math, tgamma) { 1250 ASSERT_DOUBLE_EQ(24.0, tgamma(5.0)); 1251 } 1252 1253 TEST(math, tgammaf) { 1254 ASSERT_FLOAT_EQ(24.0f, tgammaf(5.0f)); 1255 } 1256 1257 TEST(math, tgammal) { 1258 ASSERT_DOUBLE_EQ(24.0L, tgammal(5.0L)); 1259 } 1260 1261 TEST(math, j0) { 1262 ASSERT_DOUBLE_EQ(1.0, j0(0.0)); 1263 ASSERT_DOUBLE_EQ(0.76519768655796661, j0(1.0)); 1264 } 1265 1266 TEST(math, j0f) { 1267 ASSERT_FLOAT_EQ(1.0f, j0f(0.0f)); 1268 ASSERT_FLOAT_EQ(0.76519769f, j0f(1.0f)); 1269 } 1270 1271 TEST(math, j1) { 1272 ASSERT_DOUBLE_EQ(0.0, j1(0.0)); 1273 ASSERT_DOUBLE_EQ(0.44005058574493355, j1(1.0)); 1274 } 1275 1276 TEST(math, j1f) { 1277 ASSERT_FLOAT_EQ(0.0f, j1f(0.0f)); 1278 ASSERT_FLOAT_EQ(0.44005057f, j1f(1.0f)); 1279 } 1280 1281 TEST(math, jn) { 1282 ASSERT_DOUBLE_EQ(0.0, jn(4, 0.0)); 1283 ASSERT_DOUBLE_EQ(0.0024766389641099553, jn(4, 1.0)); 1284 } 1285 1286 TEST(math, jnf) { 1287 ASSERT_FLOAT_EQ(0.0f, jnf(4, 0.0f)); 1288 ASSERT_FLOAT_EQ(0.0024766389f, jnf(4, 1.0f)); 1289 } 1290 1291 TEST(math, y0) { 1292 ASSERT_DOUBLE_EQ(-HUGE_VAL, y0(0.0)); 1293 ASSERT_DOUBLE_EQ(0.08825696421567697, y0(1.0)); 1294 } 1295 1296 TEST(math, y0f) { 1297 ASSERT_FLOAT_EQ(-HUGE_VALF, y0f(0.0f)); 1298 ASSERT_FLOAT_EQ(0.088256963f, y0f(1.0f)); 1299 } 1300 1301 TEST(math, y1) { 1302 ASSERT_DOUBLE_EQ(-HUGE_VAL, y1(0.0)); 1303 ASSERT_DOUBLE_EQ(-0.78121282130028868, y1(1.0)); 1304 } 1305 1306 TEST(math, y1f) { 1307 ASSERT_FLOAT_EQ(-HUGE_VALF, y1f(0.0f)); 1308 ASSERT_FLOAT_EQ(-0.78121281f, y1f(1.0f)); 1309 } 1310 1311 TEST(math, yn) { 1312 ASSERT_DOUBLE_EQ(-HUGE_VAL, yn(4, 0.0)); 1313 ASSERT_DOUBLE_EQ(-33.278423028972114, yn(4, 1.0)); 1314 } 1315 1316 TEST(math, ynf) { 1317 ASSERT_FLOAT_EQ(-HUGE_VALF, ynf(4, 0.0f)); 1318 ASSERT_FLOAT_EQ(-33.278423f, ynf(4, 1.0f)); 1319 } 1320 1321 TEST(math, frexp) { 1322 int exp; 1323 double dr = frexp(1024.0, &exp); 1324 ASSERT_DOUBLE_EQ(1024.0, scalbn(dr, exp)); 1325 } 1326 1327 TEST(math, frexpf) { 1328 int exp; 1329 float fr = frexpf(1024.0f, &exp); 1330 ASSERT_FLOAT_EQ(1024.0f, scalbnf(fr, exp)); 1331 } 1332 1333 TEST(math, frexpl) { 1334 int exp; 1335 long double ldr = frexpl(1024.0L, &exp); 1336 ASSERT_DOUBLE_EQ(1024.0L, scalbnl(ldr, exp)); 1337 } 1338 1339 TEST(math, modf) { 1340 double di; 1341 double df = modf(123.75, &di); 1342 ASSERT_DOUBLE_EQ(123.0, di); 1343 ASSERT_DOUBLE_EQ(0.75, df); 1344 } 1345 1346 TEST(math, modff) { 1347 float fi; 1348 float ff = modff(123.75f, &fi); 1349 ASSERT_FLOAT_EQ(123.0f, fi); 1350 ASSERT_FLOAT_EQ(0.75f, ff); 1351 } 1352 1353 TEST(math, modfl) { 1354 long double ldi; 1355 long double ldf = modfl(123.75L, &ldi); 1356 ASSERT_DOUBLE_EQ(123.0L, ldi); 1357 ASSERT_DOUBLE_EQ(0.75L, ldf); 1358 } 1359 1360 TEST(math, remquo) { 1361 int q; 1362 double d = remquo(13.0, 4.0, &q); 1363 ASSERT_EQ(3, q); 1364 ASSERT_DOUBLE_EQ(1.0, d); 1365 } 1366 1367 TEST(math, remquof) { 1368 int q; 1369 float f = remquof(13.0f, 4.0f, &q); 1370 ASSERT_EQ(3, q); 1371 ASSERT_FLOAT_EQ(1.0, f); 1372 } 1373 1374 TEST(math, remquol) { 1375 int q; 1376 long double ld = remquol(13.0L, 4.0L, &q); 1377 ASSERT_DOUBLE_EQ(3L, q); 1378 ASSERT_DOUBLE_EQ(1.0L, ld); 1379 } 1380 1381 // https://code.google.com/p/android/issues/detail?id=6697 1382 TEST(math, frexpf_public_bug_6697) { 1383 int exp; 1384 float fr = frexpf(14.1f, &exp); 1385 ASSERT_FLOAT_EQ(14.1f, scalbnf(fr, exp)); 1386 } 1387 1388 TEST(math, exp2_STRICT_ALIGN_OpenBSD_bug) { 1389 // OpenBSD/x86's libm had a bug here, but it was already fixed in FreeBSD: 1390 // http://svnweb.FreeBSD.org/base/head/lib/msun/src/math_private.h?revision=240827&view=markup 1391 ASSERT_DOUBLE_EQ(5.0, exp2(log2(5))); 1392 ASSERT_FLOAT_EQ(5.0f, exp2f(log2f(5))); 1393 ASSERT_DOUBLE_EQ(5.0L, exp2l(log2l(5))); 1394 } 1395 1396 TEST(math, nextafterl_OpenBSD_bug) { 1397 // OpenBSD/x86's libm had a bug here. 1398 ASSERT_TRUE(nextafter(1.0, 0.0) - 1.0 < 0.0); 1399 ASSERT_TRUE(nextafterf(1.0f, 0.0f) - 1.0f < 0.0f); 1400 ASSERT_TRUE(nextafterl(1.0L, 0.0L) - 1.0L < 0.0L); 1401 } 1402 1403 #include "math_data/acos_intel_data.h" 1404 TEST(math, acos_intel) { 1405 DoMathDataTest<1>(g_acos_intel_data, acos); 1406 } 1407 1408 #include "math_data/acosf_intel_data.h" 1409 TEST(math, acosf_intel) { 1410 DoMathDataTest<1>(g_acosf_intel_data, acosf); 1411 } 1412 1413 #include "math_data/acosh_intel_data.h" 1414 TEST(math, acosh_intel) { 1415 DoMathDataTest<2>(g_acosh_intel_data, acosh); 1416 } 1417 1418 #include "math_data/acoshf_intel_data.h" 1419 TEST(math, acoshf_intel) { 1420 DoMathDataTest<2>(g_acoshf_intel_data, acoshf); 1421 } 1422 1423 #include "math_data/asin_intel_data.h" 1424 TEST(math, asin_intel) { 1425 DoMathDataTest<1>(g_asin_intel_data, asin); 1426 } 1427 1428 #include "math_data/asinf_intel_data.h" 1429 TEST(math, asinf_intel) { 1430 DoMathDataTest<1>(g_asinf_intel_data, asinf); 1431 } 1432 1433 #include "math_data/asinh_intel_data.h" 1434 TEST(math, asinh_intel) { 1435 DoMathDataTest<2>(g_asinh_intel_data, asinh); 1436 } 1437 1438 #include "math_data/asinhf_intel_data.h" 1439 TEST(math, asinhf_intel) { 1440 DoMathDataTest<2>(g_asinhf_intel_data, asinhf); 1441 } 1442 1443 #include "math_data/atan2_intel_data.h" 1444 TEST(math, atan2_intel) { 1445 DoMathDataTest<2>(g_atan2_intel_data, atan2); 1446 } 1447 1448 #include "math_data/atan2f_intel_data.h" 1449 TEST(math, atan2f_intel) { 1450 DoMathDataTest<2>(g_atan2f_intel_data, atan2f); 1451 } 1452 1453 #include "math_data/atan_intel_data.h" 1454 TEST(math, atan_intel) { 1455 DoMathDataTest<1>(g_atan_intel_data, atan); 1456 } 1457 1458 #include "math_data/atanf_intel_data.h" 1459 TEST(math, atanf_intel) { 1460 DoMathDataTest<1>(g_atanf_intel_data, atanf); 1461 } 1462 1463 #include "math_data/atanh_intel_data.h" 1464 TEST(math, atanh_intel) { 1465 DoMathDataTest<2>(g_atanh_intel_data, atanh); 1466 } 1467 1468 #include "math_data/atanhf_intel_data.h" 1469 TEST(math, atanhf_intel) { 1470 DoMathDataTest<2>(g_atanhf_intel_data, atanhf); 1471 } 1472 1473 #include "math_data/cbrt_intel_data.h" 1474 TEST(math, cbrt_intel) { 1475 DoMathDataTest<1>(g_cbrt_intel_data, cbrt); 1476 } 1477 1478 #include "math_data/cbrtf_intel_data.h" 1479 TEST(math, cbrtf_intel) { 1480 DoMathDataTest<1>(g_cbrtf_intel_data, cbrtf); 1481 } 1482 1483 #include "math_data/ceil_intel_data.h" 1484 TEST(math, ceil_intel) { 1485 DoMathDataTest<1>(g_ceil_intel_data, ceil); 1486 } 1487 1488 #include "math_data/ceilf_intel_data.h" 1489 TEST(math, ceilf_intel) { 1490 DoMathDataTest<1>(g_ceilf_intel_data, ceilf); 1491 } 1492 1493 #include "math_data/copysign_intel_data.h" 1494 TEST(math, copysign_intel) { 1495 DoMathDataTest<1>(g_copysign_intel_data, copysign); 1496 } 1497 1498 #include "math_data/copysignf_intel_data.h" 1499 TEST(math, copysignf_intel) { 1500 DoMathDataTest<1>(g_copysignf_intel_data, copysignf); 1501 } 1502 1503 #include "math_data/cos_intel_data.h" 1504 TEST(math, cos_intel) { 1505 DoMathDataTest<1>(g_cos_intel_data, cos); 1506 } 1507 1508 #include "math_data/cosf_intel_data.h" 1509 TEST(math, cosf_intel) { 1510 DoMathDataTest<1>(g_cosf_intel_data, cosf); 1511 } 1512 1513 #include "math_data/cosh_intel_data.h" 1514 TEST(math, cosh_intel) { 1515 DoMathDataTest<2>(g_cosh_intel_data, cosh); 1516 } 1517 1518 #include "math_data/coshf_intel_data.h" 1519 TEST(math, coshf_intel) { 1520 DoMathDataTest<2>(g_coshf_intel_data, coshf); 1521 } 1522 1523 #include "math_data/exp_intel_data.h" 1524 TEST(math, exp_intel) { 1525 DoMathDataTest<1>(g_exp_intel_data, exp); 1526 } 1527 1528 #include "math_data/expf_intel_data.h" 1529 TEST(math, expf_intel) { 1530 DoMathDataTest<1>(g_expf_intel_data, expf); 1531 } 1532 1533 #include "math_data/exp2_intel_data.h" 1534 TEST(math, exp2_intel) { 1535 DoMathDataTest<1>(g_exp2_intel_data, exp2); 1536 } 1537 1538 #include "math_data/exp2f_intel_data.h" 1539 TEST(math, exp2f_intel) { 1540 DoMathDataTest<1>(g_exp2f_intel_data, exp2f); 1541 } 1542 1543 #include "math_data/expm1_intel_data.h" 1544 TEST(math, expm1_intel) { 1545 DoMathDataTest<1>(g_expm1_intel_data, expm1); 1546 } 1547 1548 #include "math_data/expm1f_intel_data.h" 1549 TEST(math, expm1f_intel) { 1550 DoMathDataTest<1>(g_expm1f_intel_data, expm1f); 1551 } 1552 1553 #include "math_data/fabs_intel_data.h" 1554 TEST(math, fabs_intel) { 1555 DoMathDataTest<1>(g_fabs_intel_data, fabs); 1556 } 1557 1558 #include "math_data/fabsf_intel_data.h" 1559 TEST(math, fabsf_intel) { 1560 DoMathDataTest<1>(g_fabsf_intel_data, fabsf); 1561 } 1562 1563 #include "math_data/fdim_intel_data.h" 1564 TEST(math, fdim_intel) { 1565 DoMathDataTest<1>(g_fdim_intel_data, fdim); 1566 } 1567 1568 #include "math_data/fdimf_intel_data.h" 1569 TEST(math, fdimf_intel) { 1570 DoMathDataTest<1>(g_fdimf_intel_data, fdimf); 1571 } 1572 1573 #include "math_data/floor_intel_data.h" 1574 TEST(math, floor_intel) { 1575 DoMathDataTest<1>(g_floor_intel_data, floor); 1576 } 1577 1578 #include "math_data/floorf_intel_data.h" 1579 TEST(math, floorf_intel) { 1580 DoMathDataTest<1>(g_floorf_intel_data, floorf); 1581 } 1582 1583 #include "math_data/fma_intel_data.h" 1584 TEST(math, fma_intel) { 1585 DoMathDataTest<1>(g_fma_intel_data, fma); 1586 } 1587 1588 #include "math_data/fmaf_intel_data.h" 1589 TEST(math, fmaf_intel) { 1590 DoMathDataTest<1>(g_fmaf_intel_data, fmaf); 1591 } 1592 1593 #include "math_data/fmax_intel_data.h" 1594 TEST(math, fmax_intel) { 1595 DoMathDataTest<1>(g_fmax_intel_data, fmax); 1596 } 1597 1598 #include "math_data/fmaxf_intel_data.h" 1599 TEST(math, fmaxf_intel) { 1600 DoMathDataTest<1>(g_fmaxf_intel_data, fmaxf); 1601 } 1602 1603 #include "math_data/fmin_intel_data.h" 1604 TEST(math, fmin_intel) { 1605 DoMathDataTest<1>(g_fmin_intel_data, fmin); 1606 } 1607 1608 #include "math_data/fminf_intel_data.h" 1609 TEST(math, fminf_intel) { 1610 DoMathDataTest<1>(g_fminf_intel_data, fminf); 1611 } 1612 1613 #include "math_data/fmod_intel_data.h" 1614 TEST(math, fmod_intel) { 1615 DoMathDataTest<1>(g_fmod_intel_data, fmod); 1616 } 1617 1618 #include "math_data/fmodf_intel_data.h" 1619 TEST(math, fmodf_intel) { 1620 DoMathDataTest<1>(g_fmodf_intel_data, fmodf); 1621 } 1622 1623 #include "math_data/frexp_intel_data.h" 1624 TEST(math, frexp_intel) { 1625 DoMathDataTest<1>(g_frexp_intel_data, frexp); 1626 } 1627 1628 #include "math_data/frexpf_intel_data.h" 1629 TEST(math, frexpf_intel) { 1630 DoMathDataTest<1>(g_frexpf_intel_data, frexpf); 1631 } 1632 1633 #include "math_data/hypot_intel_data.h" 1634 TEST(math, hypot_intel) { 1635 DoMathDataTest<1>(g_hypot_intel_data, hypot); 1636 } 1637 1638 #include "math_data/hypotf_intel_data.h" 1639 TEST(math, hypotf_intel) { 1640 DoMathDataTest<1>(g_hypotf_intel_data, hypotf); 1641 } 1642 1643 #include "math_data/ilogb_intel_data.h" 1644 TEST(math, ilogb_intel) { 1645 DoMathDataTest<1>(g_ilogb_intel_data, ilogb); 1646 } 1647 1648 #include "math_data/ilogbf_intel_data.h" 1649 TEST(math, ilogbf_intel) { 1650 DoMathDataTest<1>(g_ilogbf_intel_data, ilogbf); 1651 } 1652 1653 #include "math_data/ldexp_intel_data.h" 1654 TEST(math, ldexp_intel) { 1655 DoMathDataTest<1>(g_ldexp_intel_data, ldexp); 1656 } 1657 1658 #include "math_data/ldexpf_intel_data.h" 1659 TEST(math, ldexpf_intel) { 1660 DoMathDataTest<1>(g_ldexpf_intel_data, ldexpf); 1661 } 1662 1663 #include "math_data/llrint_intel_data.h" 1664 TEST(math, llrint_intel) { 1665 DoMathDataTest<1>(g_llrint_intel_data, llrint); 1666 } 1667 1668 #include "math_data/llrintf_intel_data.h" 1669 TEST(math, llrintf_intel) { 1670 DoMathDataTest<1>(g_llrintf_intel_data, llrintf); 1671 } 1672 1673 #include "math_data/log_intel_data.h" 1674 TEST(math, log_intel) { 1675 DoMathDataTest<1>(g_log_intel_data, log); 1676 } 1677 1678 #include "math_data/logf_intel_data.h" 1679 TEST(math, logf_intel) { 1680 DoMathDataTest<1>(g_logf_intel_data, logf); 1681 } 1682 1683 #include "math_data/log10_intel_data.h" 1684 TEST(math, log10_intel) { 1685 DoMathDataTest<1>(g_log10_intel_data, log10); 1686 } 1687 1688 #include "math_data/log10f_intel_data.h" 1689 TEST(math, log10f_intel) { 1690 DoMathDataTest<1>(g_log10f_intel_data, log10f); 1691 } 1692 1693 #include "math_data/log1p_intel_data.h" 1694 TEST(math, log1p_intel) { 1695 DoMathDataTest<1>(g_log1p_intel_data, log1p); 1696 } 1697 1698 #include "math_data/log1pf_intel_data.h" 1699 TEST(math, log1pf_intel) { 1700 DoMathDataTest<1>(g_log1pf_intel_data, log1pf); 1701 } 1702 1703 #include "math_data/log2_intel_data.h" 1704 TEST(math, log2_intel) { 1705 DoMathDataTest<1>(g_log2_intel_data, log2); 1706 } 1707 1708 #include "math_data/log2f_intel_data.h" 1709 TEST(math, log2f_intel) { 1710 DoMathDataTest<1>(g_log2f_intel_data, log2f); 1711 } 1712 1713 #include "math_data/logb_intel_data.h" 1714 TEST(math, logb_intel) { 1715 DoMathDataTest<1>(g_logb_intel_data, logb); 1716 } 1717 1718 #include "math_data/logbf_intel_data.h" 1719 TEST(math, logbf_intel) { 1720 DoMathDataTest<1>(g_logbf_intel_data, logbf); 1721 } 1722 1723 #include "math_data/lrint_intel_data.h" 1724 TEST(math, lrint_intel) { 1725 DoMathDataTest<1>(g_lrint_intel_data, lrint); 1726 } 1727 1728 #include "math_data/lrintf_intel_data.h" 1729 TEST(math, lrintf_intel) { 1730 DoMathDataTest<1>(g_lrintf_intel_data, lrintf); 1731 } 1732 1733 #include "math_data/modf_intel_data.h" 1734 TEST(math, modf_intel) { 1735 DoMathDataTest<1>(g_modf_intel_data, modf); 1736 } 1737 1738 #include "math_data/modff_intel_data.h" 1739 TEST(math, modff_intel) { 1740 DoMathDataTest<1>(g_modff_intel_data, modff); 1741 } 1742 1743 #include "math_data/nearbyint_intel_data.h" 1744 TEST(math, nearbyint_intel) { 1745 DoMathDataTest<1>(g_nearbyint_intel_data, nearbyint); 1746 } 1747 1748 #include "math_data/nearbyintf_intel_data.h" 1749 TEST(math, nearbyintf_intel) { 1750 DoMathDataTest<1>(g_nearbyintf_intel_data, nearbyintf); 1751 } 1752 1753 #include "math_data/nextafter_intel_data.h" 1754 TEST(math, nextafter_intel) { 1755 DoMathDataTest<1>(g_nextafter_intel_data, nextafter); 1756 } 1757 1758 #include "math_data/nextafterf_intel_data.h" 1759 TEST(math, nextafterf_intel) { 1760 DoMathDataTest<1>(g_nextafterf_intel_data, nextafterf); 1761 } 1762 1763 #include "math_data/pow_intel_data.h" 1764 TEST(math, pow_intel) { 1765 DoMathDataTest<1>(g_pow_intel_data, pow); 1766 } 1767 1768 #include "math_data/powf_intel_data.h" 1769 TEST(math, powf_intel) { 1770 DoMathDataTest<1>(g_powf_intel_data, powf); 1771 } 1772 1773 #include "math_data/remainder_intel_data.h" 1774 TEST(math, remainder_intel) { 1775 DoMathDataTest<1>(g_remainder_intel_data, remainder); 1776 } 1777 1778 #include "math_data/remainderf_intel_data.h" 1779 TEST(math, remainderf_intel) { 1780 DoMathDataTest<1>(g_remainderf_intel_data, remainderf); 1781 } 1782 1783 #include "math_data/remquo_intel_data.h" 1784 TEST(math, remquo_intel) { 1785 DoMathDataTest<1>(g_remquo_intel_data, remquo); 1786 } 1787 1788 #include "math_data/remquof_intel_data.h" 1789 TEST(math, remquof_intel) { 1790 DoMathDataTest<1>(g_remquof_intel_data, remquof); 1791 } 1792 1793 #include "math_data/rint_intel_data.h" 1794 TEST(math, rint_intel) { 1795 DoMathDataTest<1>(g_rint_intel_data, rint); 1796 } 1797 1798 #include "math_data/rintf_intel_data.h" 1799 TEST(math, rintf_intel) { 1800 DoMathDataTest<1>(g_rintf_intel_data, rintf); 1801 } 1802 1803 #include "math_data/round_intel_data.h" 1804 TEST(math, round_intel) { 1805 DoMathDataTest<1>(g_round_intel_data, round); 1806 } 1807 1808 #include "math_data/roundf_intel_data.h" 1809 TEST(math, roundf_intel) { 1810 DoMathDataTest<1>(g_roundf_intel_data, roundf); 1811 } 1812 1813 #include "math_data/scalb_intel_data.h" 1814 TEST(math, scalb_intel) { 1815 DoMathDataTest<1>(g_scalb_intel_data, scalb); 1816 } 1817 1818 #include "math_data/scalbf_intel_data.h" 1819 TEST(math, scalbf_intel) { 1820 DoMathDataTest<1>(g_scalbf_intel_data, scalbf); 1821 } 1822 1823 #include "math_data/scalbn_intel_data.h" 1824 TEST(math, scalbn_intel) { 1825 DoMathDataTest<1>(g_scalbn_intel_data, scalbn); 1826 } 1827 1828 #include "math_data/scalbnf_intel_data.h" 1829 TEST(math, scalbnf_intel) { 1830 DoMathDataTest<1>(g_scalbnf_intel_data, scalbnf); 1831 } 1832 1833 #include "math_data/significand_intel_data.h" 1834 TEST(math, significand_intel) { 1835 DoMathDataTest<1>(g_significand_intel_data, significand); 1836 } 1837 1838 #include "math_data/significandf_intel_data.h" 1839 TEST(math, significandf_intel) { 1840 DoMathDataTest<1>(g_significandf_intel_data, significandf); 1841 } 1842 1843 #include "math_data/sin_intel_data.h" 1844 TEST(math, sin_intel) { 1845 DoMathDataTest<1>(g_sin_intel_data, sin); 1846 } 1847 1848 #include "math_data/sinf_intel_data.h" 1849 TEST(math, sinf_intel) { 1850 DoMathDataTest<1>(g_sinf_intel_data, sinf); 1851 } 1852 1853 #include "math_data/sinh_intel_data.h" 1854 TEST(math, sinh_intel) { 1855 DoMathDataTest<2>(g_sinh_intel_data, sinh); 1856 } 1857 1858 #include "math_data/sinhf_intel_data.h" 1859 TEST(math, sinhf_intel) { 1860 DoMathDataTest<2>(g_sinhf_intel_data, sinhf); 1861 } 1862 1863 #include "math_data/sincos_intel_data.h" 1864 TEST(math, sincos_intel) { 1865 DoMathDataTest<1>(g_sincos_intel_data, sincos); 1866 } 1867 1868 #include "math_data/sincosf_intel_data.h" 1869 TEST(math, sincosf_intel) { 1870 DoMathDataTest<1>(g_sincosf_intel_data, sincosf); 1871 } 1872 1873 #include "math_data/sqrt_intel_data.h" 1874 TEST(math, sqrt_intel) { 1875 DoMathDataTest<1>(g_sqrt_intel_data, sqrt); 1876 } 1877 1878 #include "math_data/sqrtf_intel_data.h" 1879 TEST(math, sqrtf_intel) { 1880 DoMathDataTest<1>(g_sqrtf_intel_data, sqrtf); 1881 } 1882 1883 #include "math_data/tan_intel_data.h" 1884 TEST(math, tan_intel) { 1885 DoMathDataTest<1>(g_tan_intel_data, tan); 1886 } 1887 1888 #include "math_data/tanf_intel_data.h" 1889 TEST(math, tanf_intel) { 1890 DoMathDataTest<1>(g_tanf_intel_data, tanf); 1891 } 1892 1893 #include "math_data/tanh_intel_data.h" 1894 TEST(math, tanh_intel) { 1895 DoMathDataTest<2>(g_tanh_intel_data, tanh); 1896 } 1897 1898 #include "math_data/tanhf_intel_data.h" 1899 TEST(math, tanhf_intel) { 1900 DoMathDataTest<2>(g_tanhf_intel_data, tanhf); 1901 } 1902 1903 #include "math_data/trunc_intel_data.h" 1904 TEST(math, trunc_intel) { 1905 DoMathDataTest<1>(g_trunc_intel_data, trunc); 1906 } 1907 1908 #include "math_data/truncf_intel_data.h" 1909 TEST(math, truncf_intel) { 1910 DoMathDataTest<1>(g_truncf_intel_data, truncf); 1911 } 1912
