tests/math_test.cpp

   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_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
 494 TEST(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
 501 TEST(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
 508 TEST(math, ceil) {
 509   ASSERT_FLOAT_EQ(1.0, ceil(0.9));
 510 }
 511
 512 TEST(math, ceilf) {
 513   ASSERT_FLOAT_EQ(1.0f, ceilf(0.9f));
 514 }
 515
 516 TEST(math, ceill) {
 517   ASSERT_FLOAT_EQ(1.0, ceill(0.9));
 518 }
 519
 520 TEST(math, floor) {
 521   ASSERT_FLOAT_EQ(1.0, floor(1.1));
 522 }
 523
 524 TEST(math, floorf) {
 525   ASSERT_FLOAT_EQ(1.0f, floorf(1.1f));
 526 }
 527
 528 TEST(math, floorl) {
 529   ASSERT_FLOAT_EQ(1.0, floorl(1.1));
 530 }
 531
 532 TEST(math, fabs) {
 533   ASSERT_FLOAT_EQ(1.0, fabs(-1.0));
 534 }
 535
 536 TEST(math, fabsf) {
 537   ASSERT_FLOAT_EQ(1.0f, fabsf(-1.0f));
 538 }
 539
 540 TEST(math, fabsl) {
 541   ASSERT_FLOAT_EQ(1.0, fabsl(-1.0));
 542 }
 543
 544 TEST(math, ldexp) {
 545   ASSERT_FLOAT_EQ(16.0, ldexp(2.0, 3.0));
 546 }
 547
 548 TEST(math, ldexpf) {
 549   ASSERT_FLOAT_EQ(16.0f, ldexpf(2.0f, 3.0f));
 550 }
 551
 552 TEST(math, ldexpl) {
 553   ASSERT_FLOAT_EQ(16.0, ldexpl(2.0, 3.0));
 554 }
 555
 556 TEST(math, fmod) {
 557   ASSERT_FLOAT_EQ(2.0, fmod(12.0, 10.0));
 558 }
 559
 560 TEST(math, fmodf) {
 561   ASSERT_FLOAT_EQ(2.0f, fmodf(12.0f, 10.0f));
 562 }
 563
 564 TEST(math, fmodl) {
 565   ASSERT_FLOAT_EQ(2.0, fmodl(12.0, 10.0));
 566 }
 567
 568 TEST(math, remainder) {
 569   ASSERT_FLOAT_EQ(2.0, remainder(12.0, 10.0));
 570 }
 571
 572 TEST(math, remainderf) {
 573   ASSERT_FLOAT_EQ(2.0f, remainderf(12.0f, 10.0f));
 574 }
 575
 576 TEST(math, remainderl) {
 577   ASSERT_FLOAT_EQ(2.0, remainderl(12.0, 10.0));
 578 }
 579
 580 TEST(math, drem) {
 581   ASSERT_FLOAT_EQ(2.0, drem(12.0, 10.0));
 582 }
 583
 584 TEST(math, dremf) {
 585   ASSERT_FLOAT_EQ(2.0f, dremf(12.0f, 10.0f));
 586 }
 587
 588 TEST(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
 594 TEST(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
 600 TEST(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
 606 TEST(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
 612 TEST(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
 618 TEST(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
 624 TEST(math, fma) {
 625   ASSERT_FLOAT_EQ(10.0, fma(2.0, 3.0, 4.0));
 626 }
 627
 628 TEST(math, fmaf) {
 629   ASSERT_FLOAT_EQ(10.0f, fmaf(2.0f, 3.0f, 4.0f));
 630 }
 631
 632 TEST(math, fmal) {
 633   ASSERT_FLOAT_EQ(10.0, fmal(2.0, 3.0, 4.0));
 634 }
 635
 636 TEST(math, hypot) {
 637   ASSERT_FLOAT_EQ(5.0, hypot(3.0, 4.0));
 638 }
 639
 640 TEST(math, hypotf) {
 641   ASSERT_FLOAT_EQ(5.0f, hypotf(3.0f, 4.0f));
 642 }
 643
 644 TEST(math, hypotl) {
 645   ASSERT_FLOAT_EQ(5.0, hypotl(3.0, 4.0));
 646 }
 647
 648 TEST(math, erf) {
 649   ASSERT_FLOAT_EQ(0.84270078, erf(1.0));
 650 }
 651
 652 TEST(math, erff) {
 653   ASSERT_FLOAT_EQ(0.84270078f, erff(1.0f));
 654 }
 655
 656 TEST(math, erfl) {
 657   ASSERT_FLOAT_EQ(0.84270078, erfl(1.0));
 658 }
 659
 660 TEST(math, erfc) {
 661   ASSERT_FLOAT_EQ(0.15729921, erfc(1.0));
 662 }
 663
 664 TEST(math, erfcf) {
 665   ASSERT_FLOAT_EQ(0.15729921f, erfcf(1.0f));
 666 }
 667
 668 TEST(math, erfcl) {
 669   ASSERT_FLOAT_EQ(0.15729921, erfcl(1.0));
 670 }
 671
 672 TEST(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
 692 TEST(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
 718 TEST(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
 744 TEST(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
 751 TEST(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
 758 TEST(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
 766 TEST(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
 774 TEST(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
 782 TEST(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
 790 TEST(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
 798 TEST(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
 806 TEST(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
 813 TEST(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
 820 TEST(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
 827 TEST(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
 833 TEST(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
 839 TEST(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
 845 TEST(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
 855 TEST(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
 865 TEST(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
 875 TEST(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
 885 TEST(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
 895 TEST(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
 905 TEST(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
 911 TEST(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
 917 TEST(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
 927 TEST(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
 934 TEST(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
 941 TEST(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
 948 TEST(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
 954 TEST(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
 960 extern "C" long double significandl(long double); // BSD's <math.h> doesn't declare this.
 961
 962 TEST(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
 968 TEST(math, scalb) {
 969   ASSERT_FLOAT_EQ(12.0, scalb(3.0, 2.0));
 970 }
 971
 972 TEST(math, scalbf) {
 973   ASSERT_FLOAT_EQ(12.0f, scalbf(3.0f, 2.0f));
 974 }
 975
 976 TEST(math, scalbln) {
 977   ASSERT_FLOAT_EQ(12.0, scalbln(3.0, 2L));
 978 }
 979
 980 TEST(math, scalblnf) {
 981   ASSERT_FLOAT_EQ(12.0f, scalblnf(3.0f, 2L));
 982 }
 983
 984 TEST(math, scalblnl) {
 985   ASSERT_FLOAT_EQ(12.0, scalblnl(3.0, 2L));
 986 }
 987
 988 TEST(math, scalbn) {
 989   ASSERT_FLOAT_EQ(12.0, scalbn(3.0, 2));
 990 }
 991
 992 TEST(math, scalbnf) {
 993   ASSERT_FLOAT_EQ(12.0f, scalbnf(3.0f, 2));
 994 }
 995
 996 TEST(math, scalbnl) {
 997   ASSERT_FLOAT_EQ(12.0, scalbnl(3.0, 2));
 998 }
 999
1000 TEST(math, gamma) {
1001   ASSERT_FLOAT_EQ(log(24.0), gamma(5.0));
1002 }
1003
1004 TEST(math, gammaf) {
1005   ASSERT_FLOAT_EQ(logf(24.0f), gammaf(5.0f));
1006 }
1007
1008 #if defined(__BIONIC__)
1009 TEST(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__)
1017 TEST(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
1024 TEST(math, lgamma) {
1025   ASSERT_FLOAT_EQ(log(24.0), lgamma(5.0));
1026 }
1027
1028 TEST(math, lgammaf) {
1029   ASSERT_FLOAT_EQ(logf(24.0f), lgammaf(5.0f));
1030 }
1031
1032 TEST(math, lgammal) {
1033   ASSERT_FLOAT_EQ(logl(24.0), lgammal(5.0));
1034 }
1035
1036 TEST(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
1042 TEST(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
1048 TEST(math, tgamma) {
1049   ASSERT_FLOAT_EQ(24.0, tgamma(5.0));
1050 }
1051
1052 TEST(math, tgammaf) {
1053   ASSERT_FLOAT_EQ(24.0f, tgammaf(5.0f));
1054 }
1055
1056 TEST(math, tgammal) {
1057   ASSERT_FLOAT_EQ(24.0, tgammal(5.0));
1058 }
1059
1060 TEST(math, j0) {
1061   ASSERT_FLOAT_EQ(1.0, j0(0.0));
1062   ASSERT_FLOAT_EQ(0.76519769, j0(1.0));
1063 }
1064
1065 TEST(math, j0f) {
1066   ASSERT_FLOAT_EQ(1.0f, j0f(0.0f));
1067   ASSERT_FLOAT_EQ(0.76519769f, j0f(1.0f));
1068 }
1069
1070 TEST(math, j1) {
1071   ASSERT_FLOAT_EQ(0.0, j1(0.0));
1072   ASSERT_FLOAT_EQ(0.44005057, j1(1.0));
1073 }
1074
1075 TEST(math, j1f) {
1076   ASSERT_FLOAT_EQ(0.0f, j1f(0.0f));
1077   ASSERT_FLOAT_EQ(0.44005057f, j1f(1.0f));
1078 }
1079
1080 TEST(math, jn) {
1081   ASSERT_FLOAT_EQ(0.0, jn(4, 0.0));
1082   ASSERT_FLOAT_EQ(0.0024766389, jn(4, 1.0));
1083 }
1084
1085 TEST(math, jnf) {
1086   ASSERT_FLOAT_EQ(0.0f, jnf(4, 0.0f));
1087   ASSERT_FLOAT_EQ(0.0024766389f, jnf(4, 1.0f));
1088 }
1089
1090 TEST(math, y0) {
1091   ASSERT_FLOAT_EQ(-HUGE_VAL, y0(0.0));
1092   ASSERT_FLOAT_EQ(0.088256963, y0(1.0));
1093 }
1094
1095 TEST(math, y0f) {
1096   ASSERT_FLOAT_EQ(-HUGE_VALF, y0f(0.0f));
1097   ASSERT_FLOAT_EQ(0.088256963f, y0f(1.0f));
1098 }
1099
1100 TEST(math, y1) {
1101   ASSERT_FLOAT_EQ(-HUGE_VAL, y1(0.0));
1102   ASSERT_FLOAT_EQ(-0.78121281, y1(1.0));
1103 }
1104
1105 TEST(math, y1f) {
1106   ASSERT_FLOAT_EQ(-HUGE_VALF, y1f(0.0f));
1107   ASSERT_FLOAT_EQ(-0.78121281f, y1f(1.0f));
1108 }
1109
1110 TEST(math, yn) {
1111   ASSERT_FLOAT_EQ(-HUGE_VAL, yn(4, 0.0));
1112   ASSERT_FLOAT_EQ(-33.278423, yn(4, 1.0));
1113 }
1114
1115 TEST(math, ynf) {
1116   ASSERT_FLOAT_EQ(-HUGE_VALF, ynf(4, 0.0f));
1117   ASSERT_FLOAT_EQ(-33.278423f, ynf(4, 1.0f));
1118 }
1119
1120 TEST(math, frexp) {
1121   int exp;
1122   double dr = frexp(1024.0, &exp);
1123   ASSERT_FLOAT_EQ(1024.0, scalbn(dr, exp));
1124 }
1125
1126 TEST(math, frexpf) {
1127   int exp;
1128   float fr = frexpf(1024.0f, &exp);
1129   ASSERT_FLOAT_EQ(1024.0f, scalbnf(fr, exp));
1130 }
1131
1132 TEST(math, frexpl) {
1133   int exp;
1134   long double ldr = frexpl(1024.0, &exp);
1135   ASSERT_FLOAT_EQ(1024.0, scalbnl(ldr, exp));
1136 }
1137
1138 TEST(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
1145 TEST(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
1152 TEST(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
1159 TEST(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
1166 TEST(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
1173 TEST(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
1181 TEST(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 }