Rudiments
/home/dmuse/src/rudiments/include/rudiments/private/mathinlines.h
00001 #include <math.h>
00002 #include <tgmath.h>
00003 #undef remainder
00004 #undef floor
00005 #undef round
00006 
00007 #ifdef RUDIMENTS_NAMESPACE
00008 namespace rudiments {
00009 #endif
00010 
00011 RUDIMENTS_INLINE int32_t math::absoluteValue(int32_t j) {
00012         return abs(j);
00013 }
00014 
00015 RUDIMENTS_INLINE div_t math::divide(int32_t numer, int32_t denom) {
00016         return div(numer,denom);
00017 }
00018 
00019 RUDIMENTS_INLINE long math::absoluteValue(long j) {
00020         return labs(j);
00021 }
00022 
00023 RUDIMENTS_INLINE ldiv_t math::divide(long numer, long denom) {
00024         return ldiv(numer,denom);
00025 }
00026 
00027 RUDIMENTS_INLINE int64_t math::absoluteValue(int64_t j) {
00028         return llabs(j);
00029 }
00030 
00031 RUDIMENTS_INLINE lldiv_t math::divide(int64_t numer, int64_t denom) {
00032         return lldiv(numer,denom);
00033 }
00034 
00035 
00036 
00037 
00038 // float methods
00039 
00040 RUDIMENTS_INLINE bool math::isFinite(float x) {
00041         return isfinite(x);
00042 }
00043 
00044 RUDIMENTS_INLINE bool math::isNormal(float x) {
00045         return isnormal(x);
00046 }
00047 
00048 RUDIMENTS_INLINE bool math::isSubNormal(float x) {
00049         return (fpclassify(x)==FP_SUBNORMAL);
00050 }
00051 
00052 RUDIMENTS_INLINE bool math::isNaN(float x) {
00053         return isnan(x);
00054 }
00055 
00056 RUDIMENTS_INLINE bool math::isInfinite(float x) {
00057         return isinf(x);
00058 }
00059 
00060 RUDIMENTS_INLINE bool math::isGreater(float x, float y) {
00061         return isgreater(x,y);
00062 }
00063 
00064 RUDIMENTS_INLINE bool math::isGreaterOrEqual(float x, float y) {
00065         return isgreaterequal(x,y);
00066 }
00067 
00068 RUDIMENTS_INLINE bool math::isLess(float x, float y) {
00069         return isless(x,y);
00070 }
00071 
00072 RUDIMENTS_INLINE bool math::isLessOrEqual(float x, float y) {
00073         return islessequal(x,y);
00074 }
00075 
00076 RUDIMENTS_INLINE bool math::isLessOrGreater(float x, float y) {
00077         return islessgreater(x,y);
00078 }
00079 
00080 RUDIMENTS_INLINE bool math::areNaN(float x, float y) {
00081         return isunordered(x,y);
00082 }
00083 
00084 RUDIMENTS_INLINE bool math::isSignBitSet(float x) {
00085         return signbit(x);
00086 }
00087 
00088 RUDIMENTS_INLINE float math::arcCosine(float x) {
00089         return acosf(x);
00090 }
00091 
00092 RUDIMENTS_INLINE float math::arcSine(float x) {
00093         return asinf(x);
00094 }
00095 
00096 RUDIMENTS_INLINE float math::arcTangent(float x) {
00097         return atanf(x);
00098 }
00099 
00100 RUDIMENTS_INLINE float math::arcTangent(float y, float x) {
00101         return atan2f(y,x);
00102 }
00103 
00104 RUDIMENTS_INLINE float math::cosine(float x) {
00105         return cosf(x);
00106 }
00107 
00108 RUDIMENTS_INLINE float math::sine(float x) {
00109         return sinf(x);
00110 }
00111 
00112 RUDIMENTS_INLINE float math::tangent(float x) {
00113         return tanf(x);
00114 }
00115 
00116 RUDIMENTS_INLINE float math::hyperbolicArcCosine(float x) {
00117         return acoshf(x);
00118 }
00119 
00120 RUDIMENTS_INLINE float math::hyperbolicArcSine(float x) {
00121         return asinhf(x);
00122 }
00123 
00124 RUDIMENTS_INLINE float math::hyperbolicArcTangent(float x) {
00125         return atanhf(x);
00126 }
00127 
00128 RUDIMENTS_INLINE float math::hyperbolicCosine(float x) {
00129         return coshf(x);
00130 }
00131 
00132 RUDIMENTS_INLINE float math::hyperbolicSine(float x) {
00133         return sinhf(x);
00134 }
00135 
00136 RUDIMENTS_INLINE float math::hyperbolicTangent(float x) {
00137         return tanhf(x);
00138 }
00139 
00140 RUDIMENTS_INLINE float math::naturalExponent(float x) {
00141         return expf(x);
00142 }
00143 
00144 RUDIMENTS_INLINE float math::normalize(float x, int32_t *exp) {
00145         return frexpf(x,exp);
00146 }
00147 
00148 RUDIMENTS_INLINE float math::naturalLog(float x) {
00149         return logf(x);
00150 }
00151 
00152 RUDIMENTS_INLINE float math::logBase10(float x) {
00153         return log10f(x);
00154 }
00155 
00156 RUDIMENTS_INLINE float math::naturalExponentMinusOne(float x) {
00157         return expm1f(x);
00158 }
00159 
00160 RUDIMENTS_INLINE float math::naturalLogPlusOne(float x) {
00161         return log1pf(x);
00162 }
00163 
00164 RUDIMENTS_INLINE float math::exponent(float x) {
00165         return logbf(x);
00166 }
00167 
00168 RUDIMENTS_INLINE float math::exponentBase2(float x) {
00169         return exp2f(x);
00170 }
00171 
00172 RUDIMENTS_INLINE float math::logBase2(float x) {
00173         return log2f(x);
00174 }
00175 
00176 RUDIMENTS_INLINE float math::power(float x, float y) {
00177         return powf(x,y);
00178 }
00179 
00180 RUDIMENTS_INLINE float math::squareRoot(float x) {
00181         return sqrtf(x);
00182 }
00183 
00184 RUDIMENTS_INLINE float math::hypotenuse(float x, float y) {
00185         return hypotf(x,y);
00186 }
00187 
00188 RUDIMENTS_INLINE float math::cubeRoot(float x) {
00189         return cbrtf(x);
00190 }
00191 
00192 RUDIMENTS_INLINE float math::ceiling(float x) {
00193         return ceilf(x);
00194 }
00195 
00196 RUDIMENTS_INLINE float math::absoluteValue(float x) {
00197         return fabsf(x);
00198 }
00199 
00200 RUDIMENTS_INLINE float math::floor(float x) {
00201         return floorf(x);
00202 }
00203 
00204 RUDIMENTS_INLINE float math::remainder(float x, float y) {
00205         return fmodf(x,y);
00206 }
00207 
00208 RUDIMENTS_INLINE float math::nearbyInteger(float x) {
00209         return nearbyintf(x);
00210 }
00211 
00212 RUDIMENTS_INLINE float math::round(float x) {
00213         return roundf(x);
00214 }
00215 
00216 RUDIMENTS_INLINE float math::truncate(float x) {
00217         return truncf(x);
00218 }
00219 
00220 RUDIMENTS_INLINE float math::remainder(float x, float y, int32_t *quo) {
00221         return remquof(x,y,quo);
00222 }
00223 
00224 RUDIMENTS_INLINE long math::roundToLong(float x) {
00225         return lrintf(x);
00226 }
00227 
00228 RUDIMENTS_INLINE int64_t math::roundToLongLong(float x) {
00229         return llrintf(x);
00230 }
00231 
00232 RUDIMENTS_INLINE long math::roundAwayFromZeroToLong(float x) {
00233         return lroundf(x);
00234 }
00235 
00236 RUDIMENTS_INLINE int64_t math::roundAwayFromZeroToLongLong(float x) {
00237         return llroundf(x);
00238 }
00239 
00240 RUDIMENTS_INLINE float math::copySignBit(float x, float y) {
00241         return copysignf(x,y);
00242 }
00243 
00244 RUDIMENTS_INLINE float math::errorFunction(float x) {
00245         return erff(x);
00246 }
00247 
00248 RUDIMENTS_INLINE float math::complementaryErrorFunction(float x) {
00249         return erfcf(x);
00250 }
00251 
00252 RUDIMENTS_INLINE float math::trueGamma(float x) {
00253         return tgammaf(x);
00254 }
00255 
00256 RUDIMENTS_INLINE float math::naturalLogGamma(float x) {
00257         return lgammaf(x);
00258 }
00259 
00260 RUDIMENTS_INLINE float math::roundInexact(float x) {
00261         return rintf(x);
00262 }
00263 
00264 RUDIMENTS_INLINE float math::nextAfter(float x, float y) {
00265         return nextafterf(x,y);
00266 }
00267 
00268 RUDIMENTS_INLINE float math::nextToward(float x, float y) {
00269         return nexttowardf(x,y);
00270 }
00271 
00272 RUDIMENTS_INLINE float math::scaleByRadixToPower(float x, float n) {
00273         return scalbf(x,n);
00274 }
00275 
00276 RUDIMENTS_INLINE float math::scaleByRadixToPower(float x, int32_t n) {
00277         return scalbnf(x,n);
00278 }
00279 
00280 RUDIMENTS_INLINE float math::scaleByRadixToPower(float x, long n) {
00281         return scalblnf(x,n);
00282 }
00283 
00284 RUDIMENTS_INLINE int32_t math::integralExponent(float x) {
00285         return ilogbf(x);
00286 }
00287 
00288 RUDIMENTS_INLINE float math::positiveDifference(float x, float y) {
00289         return fdimf(x,y);
00290 }
00291 
00292 RUDIMENTS_INLINE float math::larger(float x, float y) {
00293         return fmaxf(x,y);
00294 }
00295 
00296 RUDIMENTS_INLINE float math::smaller(float x, float y) {
00297         return fminf(x,y);
00298 }
00299 
00300 RUDIMENTS_INLINE float math::multiplyAndAdd(float x, float y, float z) {
00301         return fmaf(x,y,z);
00302 }
00303 
00304 RUDIMENTS_INLINE float math::argument(float complex z) {
00305         return cargf(z);
00306 }
00307 
00308 RUDIMENTS_INLINE float complex math::conjugate(float complex z) {
00309         return conjf(z);
00310 }
00311 
00312 RUDIMENTS_INLINE float complex math::project(float complex z) {
00313         return cprojf(z);
00314 }
00315 
00316 RUDIMENTS_INLINE float math::imaginary(float complex z) {
00317         return cimagf(z);
00318 }
00319 
00320 RUDIMENTS_INLINE float math::real(float complex z) {
00321         return crealf(z);
00322 }
00323 
00324 
00325 
00326 // double methods
00327 
00328 RUDIMENTS_INLINE bool math::isFinite(double x) {
00329         return isfinite(x);
00330 }
00331 
00332 RUDIMENTS_INLINE bool math::isNormal(double x) {
00333         return isnormal(x);
00334 }
00335 
00336 RUDIMENTS_INLINE bool math::isSubNormal(double x) {
00337         return (fpclassify(x)==FP_SUBNORMAL);
00338 }
00339 
00340 RUDIMENTS_INLINE bool math::isNaN(double x) {
00341         return isnan(x);
00342 }
00343 
00344 RUDIMENTS_INLINE bool math::isInfinite(double x) {
00345         return isinf(x);
00346 }
00347 
00348 RUDIMENTS_INLINE bool math::isGreater(double x, double y) {
00349         return isgreater(x,y);
00350 }
00351 
00352 RUDIMENTS_INLINE bool math::isGreaterOrEqual(double x, double y) {
00353         return isgreaterequal(x,y);
00354 }
00355 
00356 RUDIMENTS_INLINE bool math::isLess(double x, double y) {
00357         return isless(x,y);
00358 }
00359 
00360 RUDIMENTS_INLINE bool math::isLessOrEqual(double x, double y) {
00361         return islessequal(x,y);
00362 }
00363 
00364 RUDIMENTS_INLINE bool math::isLessOrGreater(double x, double y) {
00365         return islessgreater(x,y);
00366 }
00367 
00368 RUDIMENTS_INLINE bool math::areNaN(double x, double y) {
00369         return isunordered(x,y);
00370 }
00371 
00372 RUDIMENTS_INLINE bool math::isSignBitSet(double x) {
00373         return signbit(x);
00374 }
00375 
00376 RUDIMENTS_INLINE double math::arcCosine(double x) {
00377         return acos(x);
00378 }
00379 
00380 RUDIMENTS_INLINE double math::arcSine(double x) {
00381         return asin(x);
00382 }
00383 
00384 RUDIMENTS_INLINE double math::arcTangent(double x) {
00385         return atan(x);
00386 }
00387 
00388 RUDIMENTS_INLINE double math::arcTangent(double y, double x) {
00389         return atan2(y,x);
00390 }
00391 
00392 RUDIMENTS_INLINE double math::cosine(double x) {
00393         return cos(x);
00394 }
00395 
00396 RUDIMENTS_INLINE double math::sine(double x) {
00397         return sin(x);
00398 }
00399 
00400 RUDIMENTS_INLINE double math::tangent(double x) {
00401         return tan(x);
00402 }
00403 
00404 RUDIMENTS_INLINE double math::hyperbolicArcCosine(double x) {
00405         return acosh(x);
00406 }
00407 
00408 RUDIMENTS_INLINE double math::hyperbolicArcSine(double x) {
00409         return asinh(x);
00410 }
00411 
00412 RUDIMENTS_INLINE double math::hyperbolicArcTangent(double x) {
00413         return atanh(x);
00414 }
00415 
00416 RUDIMENTS_INLINE double math::hyperbolicCosine(double x) {
00417         return cosh(x);
00418 }
00419 
00420 RUDIMENTS_INLINE double math::hyperbolicSine(double x) {
00421         return sinh(x);
00422 }
00423 
00424 RUDIMENTS_INLINE double math::hyperbolicTangent(double x) {
00425         return tanh(x);
00426 }
00427 
00428 RUDIMENTS_INLINE double math::naturalExponent(double x) {
00429         return exp(x);
00430 }
00431 
00432 RUDIMENTS_INLINE double math::normalize(double x, int32_t *exp) {
00433         return frexp(x,exp);
00434 }
00435 
00436 RUDIMENTS_INLINE double math::naturalLog(double x) {
00437         return log(x);
00438 }
00439 
00440 RUDIMENTS_INLINE double math::logBase10(double x) {
00441         return log10(x);
00442 }
00443 
00444 RUDIMENTS_INLINE double math::naturalExponentMinusOne(double x) {
00445         return expm1(x);
00446 }
00447 
00448 RUDIMENTS_INLINE double math::naturalLogPlusOne(double x) {
00449         return log1p(x);
00450 }
00451 
00452 RUDIMENTS_INLINE double math::exponent(double x) {
00453         return logb(x);
00454 }
00455 
00456 RUDIMENTS_INLINE double math::exponentBase2(double x) {
00457         return exp2(x);
00458 }
00459 
00460 RUDIMENTS_INLINE double math::logBase2(double x) {
00461         return log2(x);
00462 }
00463 
00464 RUDIMENTS_INLINE double math::power(double x, double y) {
00465         return pow(x,y);
00466 }
00467 
00468 RUDIMENTS_INLINE double math::squareRoot(double x) {
00469         return sqrt(x);
00470 }
00471 
00472 RUDIMENTS_INLINE double math::hypotenuse(double x, double y) {
00473         return hypot(x,y);
00474 }
00475 
00476 RUDIMENTS_INLINE double math::cubeRoot(double x) {
00477         return cbrt(x);
00478 }
00479 
00480 RUDIMENTS_INLINE double math::ceiling(double x) {
00481         return ceil(x);
00482 }
00483 
00484 RUDIMENTS_INLINE double math::absoluteValue(double x) {
00485         return fabs(x);
00486 }
00487 
00488 RUDIMENTS_INLINE double math::floor(double x) {
00489         return floor(x);
00490 }
00491 
00492 RUDIMENTS_INLINE double math::remainder(double x, double y) {
00493         return fmod(x,y);
00494 }
00495 
00496 RUDIMENTS_INLINE double math::nearbyInteger(double x) {
00497         return nearbyint(x);
00498 }
00499 
00500 RUDIMENTS_INLINE double math::round(double x) {
00501         return round(x);
00502 }
00503 
00504 RUDIMENTS_INLINE double math::truncate(double x) {
00505         return trunc(x);
00506 }
00507 
00508 RUDIMENTS_INLINE double math::remainder(double x, double y, int32_t *quo) {
00509         return remquo(x,y,quo);
00510 }
00511 
00512 RUDIMENTS_INLINE long math::roundToLong(double x) {
00513         return lrint(x);
00514 }
00515 
00516 RUDIMENTS_INLINE int64_t math::roundToLongLong(double x) {
00517         return llrint(x);
00518 }
00519 
00520 RUDIMENTS_INLINE long math::roundAwayFromZeroToLong(double x) {
00521         return lround(x);
00522 }
00523 
00524 RUDIMENTS_INLINE int64_t math::roundAwayFromZeroToLongLong(double x) {
00525         return llround(x);
00526 }
00527 
00528 RUDIMENTS_INLINE double math::copySignBit(double x, double y) {
00529         return copysign(x,y);
00530 }
00531 
00532 RUDIMENTS_INLINE double math::errorFunction(double x) {
00533         return erf(x);
00534 }
00535 
00536 RUDIMENTS_INLINE double math::complementaryErrorFunction(double x) {
00537         return erfc(x);
00538 }
00539 
00540 RUDIMENTS_INLINE double math::trueGamma(double x) {
00541         return tgamma(x);
00542 }
00543 
00544 RUDIMENTS_INLINE double math::naturalLogGamma(double x) {
00545         return lgamma(x);
00546 }
00547 
00548 RUDIMENTS_INLINE double math::roundInexact(double x) {
00549         return rint(x);
00550 }
00551 
00552 RUDIMENTS_INLINE double math::nextAfter(double x, double y) {
00553         return nextafter(x,y);
00554 }
00555 
00556 RUDIMENTS_INLINE double math::nextToward(double x, double y) {
00557         return nexttoward(x,y);
00558 }
00559 
00560 RUDIMENTS_INLINE double math::scaleByRadixToPower(double x, double n) {
00561         return scalb(x,n);
00562 }
00563 
00564 RUDIMENTS_INLINE double math::scaleByRadixToPower(double x, int32_t n) {
00565         return scalbn(x,n);
00566 }
00567 
00568 RUDIMENTS_INLINE double math::scaleByRadixToPower(double x, long n) {
00569         return scalbln(x,n);
00570 }
00571 
00572 RUDIMENTS_INLINE int32_t math::integralExponent(double x) {
00573         return ilogb(x);
00574 }
00575 
00576 RUDIMENTS_INLINE double math::positiveDifference(double x, double y) {
00577         return fdim(x,y);
00578 }
00579 
00580 RUDIMENTS_INLINE double math::larger(double x, double y) {
00581         return fmax(x,y);
00582 }
00583 
00584 RUDIMENTS_INLINE double math::smaller(double x, double y) {
00585         return fmin(x,y);
00586 }
00587 
00588 RUDIMENTS_INLINE double math::multiplyAndAdd(double x, double y, double z) {
00589         return fma(x,y,z);
00590 }
00591 
00592 RUDIMENTS_INLINE double math::argument(double complex z) {
00593         return carg(z);
00594 }
00595 
00596 RUDIMENTS_INLINE double complex math::conjugate(double complex z) {
00597         return conj(z);
00598 }
00599 
00600 RUDIMENTS_INLINE double complex math::project(double complex z) {
00601         return cproj(z);
00602 }
00603 
00604 RUDIMENTS_INLINE double math::imaginary(double complex z) {
00605         return cimag(z);
00606 }
00607 
00608 RUDIMENTS_INLINE double math::real(double complex z) {
00609         return creal(z);
00610 }
00611 
00612 
00613 // long double methods
00614 
00615 RUDIMENTS_INLINE bool math::isFinite(long double x) {
00616         return isfinite(x);
00617 }
00618 
00619 RUDIMENTS_INLINE bool math::isNormal(long double x) {
00620         return isnormal(x);
00621 }
00622 
00623 RUDIMENTS_INLINE bool math::isSubNormal(long double x) {
00624         return (fpclassify(x)==FP_SUBNORMAL);
00625 }
00626 
00627 RUDIMENTS_INLINE bool math::isNaN(long double x) {
00628         return isnan(x);
00629 }
00630 
00631 RUDIMENTS_INLINE bool math::isInfinite(long double x) {
00632         return isinf(x);
00633 }
00634 
00635 RUDIMENTS_INLINE bool math::isGreater(long double x, long double y) {
00636         return isgreater(x,y);
00637 }
00638 
00639 RUDIMENTS_INLINE bool math::isGreaterOrEqual(long double x, long double y) {
00640         return isgreaterequal(x,y);
00641 }
00642 
00643 RUDIMENTS_INLINE bool math::isLess(long double x, long double y) {
00644         return isless(x,y);
00645 }
00646 
00647 RUDIMENTS_INLINE bool math::isLessOrEqual(long double x, long double y) {
00648         return islessequal(x,y);
00649 }
00650 
00651 RUDIMENTS_INLINE bool math::isLessOrGreater(long double x, long double y) {
00652         return islessgreater(x,y);
00653 }
00654 
00655 RUDIMENTS_INLINE bool math::areNaN(long double x, long double y) {
00656         return isunordered(x,y);
00657 }
00658 
00659 RUDIMENTS_INLINE bool math::isSignBitSet(long double x) {
00660         return signbit(x);
00661 }
00662 
00663 RUDIMENTS_INLINE long double math::arcCosine(long double x) {
00664         return acosl(x);
00665 }
00666 
00667 RUDIMENTS_INLINE long double math::arcSine(long double x) {
00668         return asinl(x);
00669 }
00670 
00671 RUDIMENTS_INLINE long double math::arcTangent(long double x) {
00672         return atanl(x);
00673 }
00674 
00675 RUDIMENTS_INLINE long double math::arcTangent(long double y, long double x) {
00676         return atan2l(y,x);
00677 }
00678 
00679 RUDIMENTS_INLINE long double math::cosine(long double x) {
00680         return cosl(x);
00681 }
00682 
00683 RUDIMENTS_INLINE long double math::sine(long double x) {
00684         return sinl(x);
00685 }
00686 
00687 RUDIMENTS_INLINE long double math::tangent(long double x) {
00688         return tanl(x);
00689 }
00690 
00691 RUDIMENTS_INLINE long double math::hyperbolicArcCosine(long double x) {
00692         return acoshl(x);
00693 }
00694 
00695 RUDIMENTS_INLINE long double math::hyperbolicArcSine(long double x) {
00696         return asinhl(x);
00697 }
00698 
00699 RUDIMENTS_INLINE long double math::hyperbolicArcTangent(long double x) {
00700         return atanhl(x);
00701 }
00702 
00703 RUDIMENTS_INLINE long double math::hyperbolicCosine(long double x) {
00704         return coshl(x);
00705 }
00706 
00707 RUDIMENTS_INLINE long double math::hyperbolicSine(long double x) {
00708         return sinhl(x);
00709 }
00710 
00711 RUDIMENTS_INLINE long double math::hyperbolicTangent(long double x) {
00712         return tanhl(x);
00713 }
00714 
00715 RUDIMENTS_INLINE long double math::naturalExponent(long double x) {
00716         return expl(x);
00717 }
00718 
00719 RUDIMENTS_INLINE long double math::normalize(long double x, int32_t *exp) {
00720         return frexpl(x,exp);
00721 }
00722 
00723 RUDIMENTS_INLINE long double math::naturalLog(long double x) {
00724         return logl(x);
00725 }
00726 
00727 RUDIMENTS_INLINE long double math::logBase10(long double x) {
00728         return log10l(x);
00729 }
00730 
00731 RUDIMENTS_INLINE long double math::naturalExponentMinusOne(long double x) {
00732         return expm1l(x);
00733 }
00734 
00735 RUDIMENTS_INLINE long double math::naturalLogPlusOne(long double x) {
00736         return log1pl(x);
00737 }
00738 
00739 RUDIMENTS_INLINE long double math::exponent(long double x) {
00740         return logbl(x);
00741 }
00742 
00743 RUDIMENTS_INLINE long double math::exponentBase2(long double x) {
00744         return exp2l(x);
00745 }
00746 
00747 RUDIMENTS_INLINE long double math::logBase2(long double x) {
00748         return log2l(x);
00749 }
00750 
00751 RUDIMENTS_INLINE long double math::power(long double x, long double y) {
00752         return powl(x,y);
00753 }
00754 
00755 RUDIMENTS_INLINE long double math::squareRoot(long double x) {
00756         return sqrtl(x);
00757 }
00758 
00759 RUDIMENTS_INLINE long double math::hypotenuse(long double x, long double y) {
00760         return hypotl(x,y);
00761 }
00762 
00763 RUDIMENTS_INLINE long double math::cubeRoot(long double x) {
00764         return cbrtl(x);
00765 }
00766 
00767 RUDIMENTS_INLINE long double math::ceiling(long double x) {
00768         return ceill(x);
00769 }
00770 
00771 RUDIMENTS_INLINE long double math::absoluteValue(long double x) {
00772         return fabsl(x);
00773 }
00774 
00775 RUDIMENTS_INLINE long double math::floor(long double x) {
00776         return floorl(x);
00777 }
00778 
00779 RUDIMENTS_INLINE long double math::remainder(long double x, long double y) {
00780         return fmodl(x,y);
00781 }
00782 
00783 RUDIMENTS_INLINE long double math::nearbyInteger(long double x) {
00784         return nearbyintl(x);
00785 }
00786 
00787 RUDIMENTS_INLINE long double math::round(long double x) {
00788         return roundl(x);
00789 }
00790 
00791 RUDIMENTS_INLINE long double math::truncate(long double x) {
00792         return truncl(x);
00793 }
00794 
00795 RUDIMENTS_INLINE long double math::remainder(long double x,
00796                                                 long double y, int32_t *quo) {
00797         return remquol(x,y,quo);
00798 }
00799 
00800 RUDIMENTS_INLINE long math::roundToLong(long double x) {
00801         return lrintl(x);
00802 }
00803 
00804 RUDIMENTS_INLINE int64_t math::roundToLongLong(long double x) {
00805         return llrintl(x);
00806 }
00807 
00808 RUDIMENTS_INLINE long math::roundAwayFromZeroToLong(long double x) {
00809         return lroundl(x);
00810 }
00811 
00812 RUDIMENTS_INLINE int64_t math::roundAwayFromZeroToLongLong(long double x) {
00813         return llroundl(x);
00814 }
00815 
00816 RUDIMENTS_INLINE long double math::copySignBit(long double x, long double y) {
00817         return copysignl(x,y);
00818 }
00819 
00820 RUDIMENTS_INLINE long double math::errorFunction(long double x) {
00821         return erfl(x);
00822 }
00823 
00824 RUDIMENTS_INLINE long double math::complementaryErrorFunction(long double x) {
00825         return erfcl(x);
00826 }
00827 
00828 RUDIMENTS_INLINE long double math::trueGamma(long double x) {
00829         return tgammal(x);
00830 }
00831 
00832 RUDIMENTS_INLINE long double math::naturalLogGamma(long double x) {
00833         return lgammal(x);
00834 }
00835 
00836 RUDIMENTS_INLINE long double math::roundInexact(long double x) {
00837         return rintl(x);
00838 }
00839 
00840 RUDIMENTS_INLINE long double math::nextAfter(long double x, long double y) {
00841         return nextafterl(x,y);
00842 }
00843 
00844 RUDIMENTS_INLINE long double math::nextToward(long double x, long double y) {
00845         return nexttowardl(x,y);
00846 }
00847 
00848 RUDIMENTS_INLINE long double math::scaleByRadixToPower(long double x,
00849                                                         long double n) {
00850         return scalbl(x,n);
00851 }
00852 
00853 RUDIMENTS_INLINE long double math::scaleByRadixToPower(long double x,
00854                                                                 int32_t n) {
00855         return scalbnl(x,n);
00856 }
00857 
00858 RUDIMENTS_INLINE long double math::scaleByRadixToPower(long double x, long n) {
00859         return scalblnl(x,n);
00860 }
00861 
00862 RUDIMENTS_INLINE int32_t math::integralExponent(long double x) {
00863         return ilogbl(x);
00864 }
00865 
00866 RUDIMENTS_INLINE long double math::positiveDifference(long double x,
00867                                                         long double y) {
00868         return fdiml(x,y);
00869 }
00870 
00871 RUDIMENTS_INLINE long double math::larger(long double x, long double y) {
00872         return fmaxl(x,y);
00873 }
00874 
00875 RUDIMENTS_INLINE long double math::smaller(long double x, long double y) {
00876         return fminl(x,y);
00877 }
00878 
00879 RUDIMENTS_INLINE long double math::multiplyAndAdd(long double x,
00880                                                 long double y, long double z) {
00881         return fmal(x,y,z);
00882 }
00883 
00884 RUDIMENTS_INLINE long double math::argument(long double complex z) {
00885         return cargl(z);
00886 }
00887 
00888 RUDIMENTS_INLINE long double complex math::conjugate(long double complex z) {
00889         return conjl(z);
00890 }
00891 
00892 RUDIMENTS_INLINE long double complex math::project(long double complex z) {
00893         return cprojl(z);
00894 }
00895 
00896 RUDIMENTS_INLINE long double math::imaginary(long double complex z) {
00897         return cimagl(z);
00898 }
00899 
00900 RUDIMENTS_INLINE long double math::real(long double complex z) {
00901         return creall(z);
00902 }
00903 
00904 RUDIMENTS_INLINE float math::loadExponent(float x, int32_t exp) {
00905         return ldexpf(x,exp);
00906 }
00907 
00908 RUDIMENTS_INLINE double math::loadExponent(double x, int32_t exp) {
00909         return ldexp(x,exp);
00910 }
00911 
00912 RUDIMENTS_INLINE long double math::loadExponent(long double x, int32_t exp) {
00913         return ldexpl(x,exp);
00914 }
00915 
00916 #ifdef RUDIMENTS_NAMESPACE
00917 }
00918 #endif