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