Math and floating-point support

The Universal C Runtime library (UCRT) provides many integral and floating-point math library functions, including all of those required by ISO C99. The floating-point functions are implemented to balance performance with correctness. Because producing the correctly rounded result may be prohibitively expensive, these functions are designed to efficiently produce a close approximation to the correctly rounded result. In most cases, the result produced is within +/-1 ulp of the correctly rounded result, though there may be cases where there is greater inaccuracy.

Many of the floating point math library functions have different implementations for different CPU architectures. For example, the 32-bit x86 CRT may have a different implementation than the 64-bit x64 CRT. In addition, some of the functions may have multiple implementations for a given CPU architecture. The most efficient implementation is selected dynamically at run-time depending on the instruction sets supported by the CPU. For example, in the 32-bit x86 CRT, some functions have both an x87 implementation and an SSE2 implementation. When running on a CPU that supports SSE2, the faster SSE2 implementation is used. When running on a CPU that does not support SSE2, the slower x87 implementation is used. Because different implementations of the math library functions may use different CPU instructions and different algorithms to produce their results, the functions may produce different results across CPUs. In most cases, the results are within +/-1 ulp of the correctly rounded result, but the actual results may vary across CPUs.

Previous 16-bit versions of Microsoft C/C++ and Microsoft Visual C++ supported the long double type as an 80-bit precision floating-point data type. In later versions of Visual C++, the long double data type is a 64-bit precision floating-point data type identical to the double type. The compiler treats long double and double as distinct types, but the long double functions are identical to their double counterparts. The CRT provides long double versions of the math functions for ISO C99 source code compatibility, but note that the binary representation may differ from other compilers.

Supported math and floating-point routines

Routine Use
abs, labs, llabs, _abs64 Computes the absolute value of an integer type
acos, acosf, acosl Computes the arc cosine
acosh, acoshf, acoshl Computes the hyperbolic arc cosine
asin, asinf, asinl Computes the arc sine
asinh, asinhf, asinhl Computes the hyperbolic arc sine
atan, atanf, atanl, atan2, atan2f, atan2l Computes the arc tangent
atanh, atanhf, atanhl Computes the hyperbolic arc tangent
_atodbl, _atodbl_l Converts a locale-specific string to a double
atof, _atof_l Converts a string to a double
_atoflt, _atoflt_l, _atoldbl, _atoldbl_l Converts a locale-specific string to a float or long double
cbrt, cbrtf, cbrtl Computes the cube root
ceil, ceilf, ceill Computes the ceiling
_chgsign, _chgsignf, _chgsignl Computes the additive inverse
_clear87, _clearfp Gets and clears the floating-point status register
_control87, __control87_2, _controlfp Gets and sets the floating-point control word
_controlfp_s Secure version of _controlfp
copysign, copysignf, copysignl, _copysign, _copysignf, _copysignl Returns a value that has the magnitude of one argument and the sign of another
cos, cosf, cosl Computes the sine
cosh, coshf, coshl Computes the hyperbolic sine
div, ldiv, lldiv Computes the quotient and the remainder of two integer values
_ecvt, ecvt Converts a double to a string
_ecvt_s Secure version of _ecvt
erf, erff, erfl Computes the error function
erfc, erfcf, erfcl Computes the complementary error function
exp, expf, expl Computes the exponential ex
exp2, exp2f, exp2l Computes the exponential 2x
expm1, expm1f, expm1l Computes ex-1
fabs, fabsf, fabsl Computes the absolute value of a floating-point type
_fcvt, fcvt Converts a floating-point number to a string
_fcvt_s Secure version of _fcvt
fdim, fdimf, fdiml Determines the positive difference between two values
feclearexcept Clears specified floating-point exceptions
fegetenv Stores the current floating-point environment
fegetexceptflag Gets the specified floating-point exception status
fegetround Gets the floating-point rounding mode
feholdexcept Sets non-stop floating-point exception mode
feraiseexcept Raises the specified floating-point exceptions
fesetenv Sets the current floating-point environment
fesetexceptflag Sets the specified floating-point status flags
fesetround Sets the specified floating-point rounding mode
fetestexcept Determines which floating-point exception status flags are set
feupdateenv Restores a floating-point environment then raises previous exceptions
_finite, _finitef Determines whether a value is finite
floor, floorf, floorl Computes the floor
fma, fmaf, fmal Computes a fused multiply-add
fmax, fmaxf, fmaxl Computes the maximum of the arguments
fmin, fminf, fminl Computes the minumum of the arguments
fmod, fmodf, fmodl Computes the floating-point remainder
_fpclass, _fpclassf Returns the classification of a floating-point value
fpclassify Returns the classification of a floating-point value
_fpieee_flt Sets a handler for floating-point exceptions
_fpreset Resets the floating-point environment
frexp, frexpf, frexpl Gets the mantissa and exponent of a floating-point number
_gcvt, gcvt Converts a floating-point number to a string
_gcvt_s Secure version of _gcvt
_get_FMA3_enable, _set_FMA3_enable Gets or sets a flag for use of FMA3 instructions on x64
hypot, hypotf, hypotl, _hypot, _hypotf, _hypotl Computes the hypotenuse
ilogb, ilogbf, ilogbl Computes the integer base-2 exponent
imaxabs Computes the absolute value of an integer type
imaxdiv Computes the quotient and the remainder of two integer values
isnan, _isnan, _isnanf Tests a floating-point value for NaN
_j0, _j1, _jn Computes the Bessel function
ldexp, ldexpf, ldexpl Computes x*2n
lgamma, lgammaf, lgammal Computes the natural logarithm of the absolute value of the gamma function
llrint, llrintf, llrintl Rounds a floating-point value to the nearest long long value
llround, llroundf, llroundl Rounds a floating-point value to the nearest long long value
log, logf, logl, log10, log10f, log10l Computes the natural or base-10 logarithm
log1p, log1pf, log1pl Computes the natural logarithm of 1+x
log2, log2f, log2l Computes the base-2 logarithm
logb, logbf, logbl, _logb, _logbf Returns the exponent of a floating-point value
lrint, lrintf, lrintl Rounds a floating-point value to the nearest long value
_lrotl, _lrotr Rotates an integer value left or right
lround, lroundf, lroundl Rounds a floating-point value to the nearest long value
_matherr The default math error handler
__max Macro that returns the larger of two values
__min Macro that returns the smaller of two values
modf, modff, modfl Splits a floating-point value into fractional and integer parts
nan, nanf, nanl Returns a quiet NaN value
nearbyint, nearbyintf, nearbyintl Returns the rounded value
nextafter, nextafterf, nextafterl, _nextafter, _nextafterf Returns the next representable floating-point value
nexttoward, nexttowardf, nexttowardl Returns the next representable floating-point value
pow, powf, powl Returns the value of xy
remainder, remainderf, remainderl Computes the remainder of the quotient of two floating-point values
remquo, remquof, remquol Computes the remainder of two integer values
rint, rintf, rintl Rounds a floating-point value
_rotl, _rotl64, _rotr, _rotr64 Rotates bits in integer types
round, roundf, roundl Rounds a floating-point value
_scalb, _scalbf Scales argument by a power of 2
scalbn, scalbnf, scalbnl, scalbln, scalblnf, scalblnl Multiplies a floating-point number by an integral power of FLT_RADIX
_set_controlfp Sets the floating-point control word
_set_SSE2_enable Enables or disables SSE2 instructions
sin, sinf, sinl Computes the sine
sinh, sinhf, sinhl Computes the hyperbolic sine
sqrt, sqrtf, sqrtl Computes the square root
_status87, _statusfp, _statusfp2 Gets the floating-point status word
strtof, _strtof_l Converts a string to a float
strtold, _strtold_l Converts a string to a long double
tan, tanf, tanl Computes the tangent
tanh, tanhf, tanhl Computes the hyperbolic tangent
tgamma, tgammaf, tgammal Computes the gamma function
trunc, truncf, truncl Truncates the fractional part
_wtof, _wtof_l Converts a wide string to a double
_y0, _y1, _yn Computes the Bessel function

See also

Universal C runtime routines by category