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