## 1.5. Single Precision Mathematical Functions

This section describes single precision mathematical functions. To use these functions you do not need to include any additional header files in your program.

### Functions

__device__ ​ float acosf ( float  x )
Calculate the arc cosine of the input argument.
__device__ ​ float acoshf ( float  x )
Calculate the nonnegative inverse hyperbolic cosine of the input argument.
__device__ ​ float asinf ( float  x )
Calculate the arc sine of the input argument.
__device__ ​ float asinhf ( float  x )
Calculate the inverse hyperbolic sine of the input argument.
__device__ ​ float atan2f ( float  y, float  x )
Calculate the arc tangent of the ratio of first and second input arguments.
__device__ ​ float atanf ( float  x )
Calculate the arc tangent of the input argument.
__device__ ​ float atanhf ( float  x )
Calculate the inverse hyperbolic tangent of the input argument.
__device__ ​ float cbrtf ( float  x )
Calculate the cube root of the input argument.
__device__ ​ float ceilf ( float  x )
Calculate ceiling of the input argument.
__device__ ​ float copysignf ( float  x, float  y )
Create value with given magnitude, copying sign of second value.
__device__ ​ float cosf ( float  x )
Calculate the cosine of the input argument.
__device__ ​ float coshf ( float  x )
Calculate the hyperbolic cosine of the input argument.
__device__ ​ float cospif ( float  x )
Calculate the cosine of the input argument $×\pi$ .
__device__ ​ float cyl_bessel_i0f ( float  x )
Calculate the value of the regular modified cylindrical Bessel function of order 0 for the input argument.
__device__ ​ float cyl_bessel_i1f ( float  x )
Calculate the value of the regular modified cylindrical Bessel function of order 1 for the input argument.
__device__ ​ float erfcf ( float  x )
Calculate the complementary error function of the input argument.
__device__ ​ float erfcinvf ( float  x )
Calculate the inverse complementary error function of the input argument.
__device__ ​ float erfcxf ( float  x )
Calculate the scaled complementary error function of the input argument.
__device__ ​ float erff ( float  x )
Calculate the error function of the input argument.
__device__ ​ float erfinvf ( float  x )
Calculate the inverse error function of the input argument.
__device__ ​ float exp10f ( float  x )
Calculate the base 10 exponential of the input argument.
__device__ ​ float exp2f ( float  x )
Calculate the base 2 exponential of the input argument.
__device__ ​ float expf ( float  x )
Calculate the base $e$ exponential of the input argument.
__device__ ​ float expm1f ( float  x )
Calculate the base $e$ exponential of the input argument, minus 1.
__device__ ​ float fabsf ( float  x )
Calculate the absolute value of its argument.
__device__ ​ float fdimf ( float  x, float  y )
Compute the positive difference between x and y.
__device__ ​ float fdividef ( float  x, float  y )
Divide two floating-point values.
__device__ ​ float floorf ( float  x )
Calculate the largest integer less than or equal to x.
__device__ ​ float fmaf ( float  x, float  y, float  z )
Compute $x×y+z$ as a single operation.
__device__ ​ float fmaxf ( float  x, float  y )
Determine the maximum numeric value of the arguments.
__device__ ​ float fminf ( float  x, float  y )
Determine the minimum numeric value of the arguments.
__device__ ​ float fmodf ( float  x, float  y )
Calculate the floating-point remainder of x / y.
__device__ ​ float frexpf ( float  x, int* nptr )
Extract mantissa and exponent of a floating-point value.
__device__ ​ float hypotf ( float  x, float  y )
Calculate the square root of the sum of squares of two arguments.
__device__ ​ int ilogbf ( float  x )
Compute the unbiased integer exponent of the argument.
__device__ ​ __RETURN_TYPE isfinite ( float  a )
Determine whether argument is finite.
__device__ ​ __RETURN_TYPE isinf ( float  a )
Determine whether argument is infinite.
__device__ ​ __RETURN_TYPE isnan ( float  a )
Determine whether argument is a NaN.
__device__ ​ float j0f ( float  x )
Calculate the value of the Bessel function of the first kind of order 0 for the input argument.
__device__ ​ float j1f ( float  x )
Calculate the value of the Bessel function of the first kind of order 1 for the input argument.
__device__ ​ float jnf ( int  n, float  x )
Calculate the value of the Bessel function of the first kind of order n for the input argument.
__device__ ​ float ldexpf ( float  x, int  exp )
Calculate the value of $x\cdot {2}^{exp}$ .
__device__ ​ float lgammaf ( float  x )
Calculate the natural logarithm of the absolute value of the gamma function of the input argument.
__device__ ​ long long int llrintf ( float  x )
Round input to nearest integer value.
__device__ ​ long long int llroundf ( float  x )
Round to nearest integer value.
__device__ ​ float log10f ( float  x )
Calculate the base 10 logarithm of the input argument.
__device__ ​ float log1pf ( float  x )
Calculate the value of ${log}_{e}\left(1+x\right)$ .
__device__ ​ float log2f ( float  x )
Calculate the base 2 logarithm of the input argument.
__device__ ​ float logbf ( float  x )
Calculate the floating-point representation of the exponent of the input argument.
__device__ ​ float logf ( float  x )
Calculate the natural logarithm of the input argument.
__device__ ​ long int lrintf ( float  x )
Round input to nearest integer value.
__device__ ​ long int lroundf ( float  x )
Round to nearest integer value.
__device__ ​ float max ( const float  a, const float  b )
Calculate the maximum value of the input float arguments.
__device__ ​ float min ( const float  a, const float  b )
Calculate the minimum value of the input float arguments.
__device__ ​ float modff ( float  x, float* iptr )
Break down the input argument into fractional and integral parts.
__device__ ​ float nanf ( const char* tagp )
Returns "Not a Number" value.
__device__ ​ float nearbyintf ( float  x )
Round the input argument to the nearest integer.
__device__ ​ float nextafterf ( float  x, float  y )
Return next representable single-precision floating-point value after argument x in the direction of y.
__device__ ​ float norm3df ( float  a, float  b, float  c )
Calculate the square root of the sum of squares of three coordinates of the argument.
__device__ ​ float norm4df ( float  a, float  b, float  c, float  d )
Calculate the square root of the sum of squares of four coordinates of the argument.
__device__ ​ float normcdff ( float  x )
Calculate the standard normal cumulative distribution function.
__device__ ​ float normcdfinvf ( float  x )
Calculate the inverse of the standard normal cumulative distribution function.
__device__ ​ float normf ( int  dim, const float* p )
Calculate the square root of the sum of squares of any number of coordinates.
__device__ ​ float powf ( float  x, float  y )
Calculate the value of first argument to the power of second argument.
__device__ ​ float rcbrtf ( float  x )
Calculate reciprocal cube root function.
__device__ ​ float remainderf ( float  x, float  y )
Compute single-precision floating-point remainder.
__device__ ​ float remquof ( float  x, float  y, int* quo )
Compute single-precision floating-point remainder and part of quotient.
__device__ ​ float rhypotf ( float  x, float  y )
Calculate one over the square root of the sum of squares of two arguments.
__device__ ​ float rintf ( float  x )
Round input to nearest integer value in floating-point.
__device__ ​ float rnorm3df ( float  a, float  b, float  c )
Calculate one over the square root of the sum of squares of three coordinates.
__device__ ​ float rnorm4df ( float  a, float  b, float  c, float  d )
Calculate one over the square root of the sum of squares of four coordinates.
__device__ ​ float rnormf ( int  dim, const float* p )
Calculate the reciprocal of square root of the sum of squares of any number of coordinates.
__device__ ​ float roundf ( float  x )
Round to nearest integer value in floating-point.
__device__ ​ float rsqrtf ( float  x )
Calculate the reciprocal of the square root of the input argument.
__device__ ​ float scalblnf ( float  x, long int  n )
Scale floating-point input by integer power of two.
__device__ ​ float scalbnf ( float  x, int  n )
Scale floating-point input by integer power of two.
__device__ ​ __RETURN_TYPE signbit ( float  a )
Return the sign bit of the input.
__device__ ​ void sincosf ( float  x, float* sptr, float* cptr )
Calculate the sine and cosine of the first input argument.
__device__ ​ void sincospif ( float  x, float* sptr, float* cptr )
Calculate the sine and cosine of the first input argument $×\pi$ .
__device__ ​ float sinf ( float  x )
Calculate the sine of the input argument.
__device__ ​ float sinhf ( float  x )
Calculate the hyperbolic sine of the input argument.
__device__ ​ float sinpif ( float  x )
Calculate the sine of the input argument $×\pi$ .
__device__ ​ float sqrtf ( float  x )
Calculate the square root of the input argument.
__device__ ​ float tanf ( float  x )
Calculate the tangent of the input argument.
__device__ ​ float tanhf ( float  x )
Calculate the hyperbolic tangent of the input argument.
__device__ ​ float tgammaf ( float  x )
Calculate the gamma function of the input argument.
__device__ ​ float truncf ( float  x )
Truncate input argument to the integral part.
__device__ ​ float y0f ( float  x )
Calculate the value of the Bessel function of the second kind of order 0 for the input argument.
__device__ ​ float y1f ( float  x )
Calculate the value of the Bessel function of the second kind of order 1 for the input argument.
__device__ ​ float ynf ( int  n, float  x )
Calculate the value of the Bessel function of the second kind of order n for the input argument.

### Functions

__device__ ​ float acosf ( float  x )
Calculate the arc cosine of the input argument.
###### Returns

Result will be in radians, in the interval [0, $\pi$ ] for x inside [-1, +1].

• acosf(1) returns +0.
• acosf(x) returns NaN for x outside [-1, +1].
###### Description

Calculate the principal value of the arc cosine of the input argument x.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float acoshf ( float  x )
Calculate the nonnegative inverse hyperbolic cosine of the input argument.
###### Returns

Result will be in the interval [0, $+\mathrm{\infty }$ ].

• acoshf(1) returns 0.
• acoshf(x) returns NaN for x in the interval [ $-\mathrm{\infty }$ , 1).
• acoshf( $+\mathrm{\infty }$ ) returns $+\mathrm{\infty }$ .
###### Description

Calculate the nonnegative inverse hyperbolic cosine of the input argument x.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float asinf ( float  x )
Calculate the arc sine of the input argument.
###### Returns

Result will be in radians, in the interval [- $\pi /2$ , + $\pi /2$ ] for x inside [-1, +1].

• asinf( $±0$ ) returns $±0$ .
• asinf(x) returns NaN for x outside [-1, +1].
###### Description

Calculate the principal value of the arc sine of the input argument x.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float asinhf ( float  x )
Calculate the inverse hyperbolic sine of the input argument.
###### Returns

• asinhf( $±\mathrm{0}$ ) returns $±\mathrm{0}$ .
• asinhf( $±\mathrm{\infty }$ ) returns $±\mathrm{\infty }$ .
###### Description

Calculate the inverse hyperbolic sine of the input argument x.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float atan2f ( float  y, float  x )
Calculate the arc tangent of the ratio of first and second input arguments.
###### Returns

Result will be in radians, in the interval [- $\pi$ , + $\pi$ ].

• atan2f( $±0$ , -0) returns $±\pi$ .
• atan2f( $±0$ , +0) returns $±0$ .
• atan2f( $±0$ , x) returns $±\pi$ for x < 0.
• atan2f( $±0$ , x) returns $±0$ for x > 0.
• atan2f(y, $±0$ ) returns $-\pi$ /2 for y < 0.
• atan2f(y, $±0$ ) returns $\pi$ /2 for y > 0.
• atan2f( $±y$ , $-\mathrm{\infty }$ ) returns $±\pi$ for finite y > 0.
• atan2f( $±y$ , $+\mathrm{\infty }$ ) returns $±0$ for finite y > 0.
• atan2f( $±\mathrm{\infty }$ , x) returns $±\pi$ /2 for finite x.
• atan2f( $±\mathrm{\infty }$ , $-\mathrm{\infty }$ ) returns $±3\pi$ /4.
• atan2f( $±\mathrm{\infty }$ , $+\mathrm{\infty }$ ) returns $±\pi$ /4.
###### Description

Calculate the principal value of the arc tangent of the ratio of first and second input arguments y / x. The quadrant of the result is determined by the signs of inputs y and x.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float atanf ( float  x )
Calculate the arc tangent of the input argument.
###### Returns

Result will be in radians, in the interval [- $\pi /2$ , + $\pi /2$ ].

• atanf( $±0$ ) returns $±0$ .
• atanf( $±\mathrm{\infty }$ ) returns $±\pi$ /2.
###### Description

Calculate the principal value of the arc tangent of the input argument x.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float atanhf ( float  x )
Calculate the inverse hyperbolic tangent of the input argument.
###### Returns

• atanhf( $±0$ ) returns $±0$ .
• atanhf( $±1$ ) returns $±\mathrm{\infty }$ .
• atanhf(x) returns NaN for x outside interval [-1, 1].
###### Description

Calculate the inverse hyperbolic tangent of the input argument x.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float cbrtf ( float  x )
Calculate the cube root of the input argument.
###### Returns

Returns ${x}^{1/3}$ .

• cbrtf( $±0$ ) returns $±0$ .
• cbrtf( $±\mathrm{\infty }$ ) returns $±\mathrm{\infty }$ .
###### Description

Calculate the cube root of x, ${x}^{1/3}$ .

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float ceilf ( float  x )
Calculate ceiling of the input argument.
###### Returns

Returns $⌈x⌉$ expressed as a floating-point number.

• ceilf( $±0$ ) returns $±0$ .
• ceilf( $±\mathrm{\infty }$ ) returns $±\mathrm{\infty }$ .
###### Description

Compute the smallest integer value not less than x.

__device__ ​ float copysignf ( float  x, float  y )
Create value with given magnitude, copying sign of second value.
###### Returns

Returns a value with the magnitude of x and the sign of y.

###### Description

Create a floating-point value with the magnitude x and the sign of y.

__device__ ​ float cosf ( float  x )
Calculate the cosine of the input argument.
###### Returns

• cosf( $±0$ ) returns 1.
• cosf( $±\mathrm{\infty }$ ) returns NaN.
###### Description

Calculate the cosine of the input argument x (measured in radians).

Note:
• For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

• This function is affected by the --use_fast_math compiler flag. See the CUDA C++ Programming Guide, Mathematical Functions Appendix, Intrinsic Functions section for a complete list of functions affected.

__device__ ​ float coshf ( float  x )
Calculate the hyperbolic cosine of the input argument.
###### Returns

• coshf( $±0$ ) returns 1.
• coshf( $±\mathrm{\infty }$ ) returns $+\mathrm{\infty }$ .
###### Description

Calculate the hyperbolic cosine of the input argument x.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float cospif ( float  x )
Calculate the cosine of the input argument $×\pi$ .
###### Returns

• cospif( $±0$ ) returns 1.
• cospif( $±\mathrm{\infty }$ ) returns NaN.
###### Description

Calculate the cosine of x$×\pi$ (measured in radians), where x is the input argument.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float cyl_bessel_i0f ( float  x )
Calculate the value of the regular modified cylindrical Bessel function of order 0 for the input argument.
###### Returns

Returns the value of the regular modified cylindrical Bessel function of order 0.

###### Description

Calculate the value of the regular modified cylindrical Bessel function of order 0 for the input argument x, ${I}_{0}\left(x\right)$ .

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float cyl_bessel_i1f ( float  x )
Calculate the value of the regular modified cylindrical Bessel function of order 1 for the input argument.
###### Returns

Returns the value of the regular modified cylindrical Bessel function of order 1.

###### Description

Calculate the value of the regular modified cylindrical Bessel function of order 1 for the input argument x, ${I}_{1}\left(x\right)$ .

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float erfcf ( float  x )
Calculate the complementary error function of the input argument.
###### Returns

• erfcf( $-\mathrm{\infty }$ ) returns 2.
• erfcf( $+\mathrm{\infty }$ ) returns +0.
###### Description

Calculate the complementary error function of the input argument x, 1 - erf(x).

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float erfcinvf ( float  x )
Calculate the inverse complementary error function of the input argument.
###### Returns

• erfcinvf( $±0$ ) returns $+\mathrm{\infty }$ .
• erfcinvf(2) returns $-\mathrm{\infty }$ .
• erfcinvf(x) returns NaN for x outside [0, 2].
###### Description

Calculate the inverse complementary error function ${\mathrm{erfc}}^{-1}$ (x), of the input argument x in the interval [0, 2].

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float erfcxf ( float  x )
Calculate the scaled complementary error function of the input argument.
###### Returns

• erfcxf( $-\mathrm{\infty }$ ) returns $+\mathrm{\infty }$ .
• erfcxf( $+\mathrm{\infty }$ ) returns +0.
###### Description

Calculate the scaled complementary error function of the input argument x, ${e}^{{x}^{2}}\cdot \text{erfc}\left(x\right)$ .

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float erff ( float  x )
Calculate the error function of the input argument.
###### Returns

• erff( $±0$ ) returns $±0$ .
• erff( $±\mathrm{\infty }$ ) returns $±1$ .
###### Description

Calculate the value of the error function for the input argument x, $\frac{2}{\sqrt{\pi }}{\int }_{0}^{x}{e}^{-{t}^{2}}dt$ .

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float erfinvf ( float  x )
Calculate the inverse error function of the input argument.
###### Returns

• erfinvf( $±0$ ) returns $±0$ .
• erfinvf(1) returns $+\mathrm{\infty }$ .
• erfinvf(-1) returns $-\mathrm{\infty }$ .
• erfinvf(x) returns NaN for x outside [-1, +1].
###### Description

Calculate the inverse error function ${\mathrm{erf}}^{-1}$ (x), of the input argument x in the interval [-1, 1].

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float exp10f ( float  x )
Calculate the base 10 exponential of the input argument.
###### Returns

• exp10f( $±0$ ) returns 1.
• exp10f( $-\mathrm{\infty }$ ) returns +0.
• exp10f( $+\mathrm{\infty }$ ) returns $+\mathrm{\infty }$ .
###### Description

Calculate ${10}^{x}$ , the base 10 exponential of the input argument x.

Note:
• For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

• This function is affected by the --use_fast_math compiler flag. See the CUDA C++ Programming Guide, Mathematical Functions Appendix, Intrinsic Functions section for a complete list of functions affected.

__device__ ​ float exp2f ( float  x )
Calculate the base 2 exponential of the input argument.
###### Returns

• exp2f( $±0$ ) returns 1.
• exp2f( $-\mathrm{\infty }$ ) returns +0.
• exp2f( $+\mathrm{\infty }$ ) returns $+\mathrm{\infty }$ .
###### Description

Calculate ${2}^{x}$ , the base 2 exponential of the input argument x.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float expf ( float  x )
Calculate the base $e$ exponential of the input argument.
###### Returns

• expf( $±0$ ) returns 1.
• expf( $-\mathrm{\infty }$ ) returns +0.
• expf( $+\mathrm{\infty }$ ) returns $+\mathrm{\infty }$ .
###### Description

Calculate ${e}^{x}$ , the base $e$ exponential of the input argument x.

Note:
• For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

• This function is affected by the --use_fast_math compiler flag. See the CUDA C++ Programming Guide, Mathematical Functions Appendix, Intrinsic Functions section for a complete list of functions affected.

__device__ ​ float expm1f ( float  x )
Calculate the base $e$ exponential of the input argument, minus 1.
###### Returns

• expm1f( $±0$ ) returns $±0$ .
• expm1f( $-\mathrm{\infty }$ ) returns -1.
• expm1f( $+\mathrm{\infty }$ ) returns $+\mathrm{\infty }$ .
###### Description

Calculate ${e}^{x}$ -1, the base $e$ exponential of the input argument x, minus 1.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float fabsf ( float  x )
Calculate the absolute value of its argument.
###### Returns

Returns the absolute value of its argument.

• fabsf( $±\mathrm{\infty }$ ) returns $+\mathrm{\infty }$ .
• fabsf( $±0$ ) returns +0.
• fabsf(NaN) returns an unspecified NaN.
###### Description

Calculate the absolute value of the input argument x.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float fdimf ( float  x, float  y )
Compute the positive difference between x and y.
###### Returns

Returns the positive difference between x and y.

• fdimf(x, y) returns x - y if x > y.
• fdimf(x, y) returns +0 if x$\le$y.
###### Description

Compute the positive difference between x and y. The positive difference is x - y when x > y and +0 otherwise.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float fdividef ( float  x, float  y )
Divide two floating-point values.

Returns x / y.

###### Description

Compute x divided by y. If --use_fast_math is specified, use __fdividef() for higher performance, otherwise use normal division.

Note:
• For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

• This function is affected by the --use_fast_math compiler flag. See the CUDA C++ Programming Guide, Mathematical Functions Appendix, Intrinsic Functions section for a complete list of functions affected.

__device__ ​ float floorf ( float  x )
Calculate the largest integer less than or equal to x.
###### Returns

Returns $⌊x⌋$ expressed as a floating-point number.

• floorf( $±\mathrm{\infty }$ ) returns $±\mathrm{\infty }$ .
• floorf( $±0$ ) returns $±0$ .
###### Description

Calculate the largest integer value which is less than or equal to x.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float fmaf ( float  x, float  y, float  z )
Compute $x×y+z$ as a single operation.
###### Returns

Returns the rounded value of $x×y+z$ as a single operation.

• fmaf( $±\mathrm{\infty }$ , $±0$ , z) returns NaN.
• fmaf( $±0$ , $±\mathrm{\infty }$ , z) returns NaN.
• fmaf(x, y, $-\mathrm{\infty }$ ) returns NaN if $x×y$ is an exact $+\mathrm{\infty }$ .
• fmaf(x, y, $+\mathrm{\infty }$ ) returns NaN if $x×y$ is an exact $-\mathrm{\infty }$ .
###### Description

Compute the value of $x×y+z$ as a single ternary operation. After computing the value to infinite precision, the value is rounded once.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float fmaxf ( float  x, float  y )
Determine the maximum numeric value of the arguments.
###### Returns

Returns the maximum numeric values of the arguments x and y.

• If both arguments are NaN, returns NaN.
• If one argument is NaN, returns the numeric argument.
###### Description

Determines the maximum numeric value of the arguments x and y. Treats NaN arguments as missing data. If one argument is a NaN and the other is legitimate numeric value, the numeric value is chosen.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float fminf ( float  x, float  y )
Determine the minimum numeric value of the arguments.
###### Returns

Returns the minimum numeric value of the arguments x and y.

• If both arguments are NaN, returns NaN.
• If one argument is NaN, returns the numeric argument.
###### Description

Determines the minimum numeric value of the arguments x and y. Treats NaN arguments as missing data. If one argument is a NaN and the other is legitimate numeric value, the numeric value is chosen.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float fmodf ( float  x, float  y )
Calculate the floating-point remainder of x / y.
###### Returns

• Returns the floating-point remainder of x / y.
• fmodf( $±0$ , y) returns $±0$ if y is not zero.
• fmodf(x, $±\mathrm{\infty }$ ) returns x if x is finite.
• fmodf(x, y) returns NaN if x is $±\mathrm{\infty }$ or y is zero.
• If either argument is NaN, NaN is returned.
###### Description

Calculate the floating-point remainder of x / y. The floating-point remainder of the division operation x / y calculated by this function is exactly the value x - n*y, where n is x / y with its fractional part truncated. The computed value will have the same sign as x, and its magnitude will be less than the magnitude of y.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float frexpf ( float  x, int* nptr )
Extract mantissa and exponent of a floating-point value.
###### Returns

Returns the fractional component m.

• frexpf( $±0$ , nptr) returns $±0$ and stores zero in the location pointed to by nptr.
• frexpf( $±\mathrm{\infty }$ , nptr) returns $±\mathrm{\infty }$ and stores an unspecified value in the location to which nptr points.
• frexpf(NaN, y) returns a NaN and stores an unspecified value in the location to which nptr points.
###### Description

Decomposes the floating-point value x into a component m for the normalized fraction element and another term n for the exponent. The absolute value of m will be greater than or equal to 0.5 and less than 1.0 or it will be equal to 0; $x=m\cdot {2}^{n}$ . The integer exponent n will be stored in the location to which nptr points.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float hypotf ( float  x, float  y )
Calculate the square root of the sum of squares of two arguments.
###### Returns

Returns the length of the hypotenuse $\sqrt{{x}^{2}+{y}^{2}}$ .

• hypotf(x,y), hypotf(y,x), and hypotf(x, -y) are equivalent.
• hypotf(x, $±0$ ) is equivalent to fabsf(x).
• hypotf( $±\mathrm{\infty }$ ,y) returns $+\mathrm{\infty }$ , even if y is a NaN.
###### Description

Calculates the length of the hypotenuse of a right triangle whose two sides have lengths x and y without undue overflow or underflow.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ int ilogbf ( float  x )
Compute the unbiased integer exponent of the argument.
###### Returns

• If successful, returns the unbiased exponent of the argument.
• ilogbf( $±0$ ) returns INT_MIN.
• ilogbf(NaN) returns INT_MIN.
• ilogbf( $±\mathrm{\infty }$ ) returns INT_MAX.
• Note: above behavior does not take into account FP_ILOGB0 nor FP_ILOGBNAN.
###### Description

Calculates the unbiased integer exponent of the input argument x.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ __RETURN_TYPE isfinite ( float  a )
Determine whether argument is finite.
###### Returns

• With Visual Studio 2013 host compiler: __RETURN_TYPE is 'bool'. Returns true if and only if a is a finite value.
• With other host compilers: __RETURN_TYPE is 'int'. Returns a nonzero value if and only if a is a finite value.
###### Description

Determine whether the floating-point value a is a finite value (zero, subnormal, or normal and not infinity or NaN).

__device__ ​ __RETURN_TYPE isinf ( float  a )
Determine whether argument is infinite.
###### Returns

• With Visual Studio 2013 host compiler: __RETURN_TYPE is 'bool'. Returns true if and only if a is an infinite value.
• With other host compilers: __RETURN_TYPE is 'int'. Returns a nonzero value if and only if a is an infinite value.
###### Description

Determine whether the floating-point value a is an infinite value (positive or negative).

__device__ ​ __RETURN_TYPE isnan ( float  a )
Determine whether argument is a NaN.
###### Returns

• With Visual Studio 2013 host compiler: __RETURN_TYPE is 'bool'. Returns true if and only if a is a NaN value.
• With other host compilers: __RETURN_TYPE is 'int'. Returns a nonzero value if and only if a is a NaN value.
###### Description

Determine whether the floating-point value a is a NaN.

__device__ ​ float j0f ( float  x )
Calculate the value of the Bessel function of the first kind of order 0 for the input argument.
###### Returns

Returns the value of the Bessel function of the first kind of order 0.

• j0f( $±\mathrm{\infty }$ ) returns +0.
• j0f(NaN) returns NaN.
###### Description

Calculate the value of the Bessel function of the first kind of order 0 for the input argument x, ${J}_{0}\left(x\right)$ .

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float j1f ( float  x )
Calculate the value of the Bessel function of the first kind of order 1 for the input argument.
###### Returns

Returns the value of the Bessel function of the first kind of order 1.

• j1f( $±0$ ) returns $±0$ .
• j1f( $±\mathrm{\infty }$ ) returns $±0$ .
• j1f(NaN) returns NaN.
###### Description

Calculate the value of the Bessel function of the first kind of order 1 for the input argument x, ${J}_{1}\left(x\right)$ .

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float jnf ( int  n, float  x )
Calculate the value of the Bessel function of the first kind of order n for the input argument.
###### Returns

Returns the value of the Bessel function of the first kind of order n.

• jnf(n, NaN) returns NaN.
• jnf(n, x) returns NaN for n < 0.
• jnf(n, $+\mathrm{\infty }$ ) returns +0.
###### Description

Calculate the value of the Bessel function of the first kind of order n for the input argument x, ${J}_{n}\left(x\right)$ .

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float ldexpf ( float  x, int  exp )
Calculate the value of $x\cdot {2}^{exp}$ .
###### Returns

• ldexpf(x, exp) is equivalent to scalbnf(x, exp).
###### Description

Calculate the value of $x\cdot {2}^{exp}$ of the input arguments x and exp.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float lgammaf ( float  x )
Calculate the natural logarithm of the absolute value of the gamma function of the input argument.
###### Returns

• lgammaf(1) returns +0.
• lgammaf(2) returns +0.
• lgammaf(x) returns $+\mathrm{\infty }$ if x$\le$ 0 and x is an integer.
• lgammaf( $-\mathrm{\infty }$ ) returns $+\mathrm{\infty }$ .
• lgammaf( $+\mathrm{\infty }$ ) returns $+\mathrm{\infty }$ .
###### Description

Calculate the natural logarithm of the absolute value of the gamma function of the input argument x, namely the value of ${log}_{e}\left|{\int }_{0}^{\mathrm{\infty }}{e}^{-t}{t}^{x-1}dt\right|$

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ long long int llrintf ( float  x )
Round input to nearest integer value.
###### Returns

Returns rounded integer value.

###### Description

Round x to the nearest integer value, with halfway cases rounded to the nearest even integer value. If the result is outside the range of the return type, the behavior is undefined.

__device__ ​ long long int llroundf ( float  x )
Round to nearest integer value.
###### Returns

Returns rounded integer value.

###### Description

Round x to the nearest integer value, with halfway cases rounded away from zero. If the result is outside the range of the return type, the behavior is undefined.

Note:

This function may be slower than alternate rounding methods. See llrintf().

__device__ ​ float log10f ( float  x )
Calculate the base 10 logarithm of the input argument.
###### Returns

• log10f( $±0$ ) returns $-\mathrm{\infty }$ .
• log10f(1) returns +0.
• log10f(x) returns NaN for x < 0.
• log10f( $+\mathrm{\infty }$ ) returns $+\mathrm{\infty }$ .
###### Description

Calculate the base 10 logarithm of the input argument x.

Note:
• For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

• This function is affected by the --use_fast_math compiler flag. See the CUDA C++ Programming Guide, Mathematical Functions Appendix, Intrinsic Functions section for a complete list of functions affected.

__device__ ​ float log1pf ( float  x )
Calculate the value of ${log}_{e}\left(1+x\right)$ .
###### Returns

• log1pf( $±0$ ) returns $±0$ .
• log1pf(-1) returns $-\mathrm{\infty }$ .
• log1pf(x) returns NaN for x < -1.
• log1pf( $+\mathrm{\infty }$ ) returns $+\mathrm{\infty }$ .
###### Description

Calculate the value of ${log}_{e}\left(1+x\right)$ of the input argument x.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float log2f ( float  x )
Calculate the base 2 logarithm of the input argument.
###### Returns

• log2f( $±0$ ) returns $-\mathrm{\infty }$ .
• log2f(1) returns +0.
• log2f(x) returns NaN for x < 0.
• log2f( $+\mathrm{\infty }$ ) returns $+\mathrm{\infty }$ .
###### Description

Calculate the base 2 logarithm of the input argument x.

Note:
• For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

• This function is affected by the --use_fast_math compiler flag. See the CUDA C++ Programming Guide, Mathematical Functions Appendix, Intrinsic Functions section for a complete list of functions affected.

__device__ ​ float logbf ( float  x )
Calculate the floating-point representation of the exponent of the input argument.
###### Returns

• logbf( $±0$ ) returns $-\mathrm{\infty }$ .
• logbf( $±\mathrm{\infty }$ ) returns $+\mathrm{\infty }$ .
###### Description

Calculate the floating-point representation of the exponent of the input argument x.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float logf ( float  x )
Calculate the natural logarithm of the input argument.
###### Returns

• logf( $±0$ ) returns $-\mathrm{\infty }$ .
• logf(1) returns +0.
• logf(x) returns NaN for x < 0.
• logf( $+\mathrm{\infty }$ ) returns $+\mathrm{\infty }$ .
###### Description

Calculate the natural logarithm of the input argument x.

Note:
• For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

• This function is affected by the --use_fast_math compiler flag. See the CUDA C++ Programming Guide, Mathematical Functions Appendix, Intrinsic Functions section for a complete list of functions affected.

__device__ ​ long int lrintf ( float  x )
Round input to nearest integer value.
###### Returns

Returns rounded integer value.

###### Description

Round x to the nearest integer value, with halfway cases rounded to the nearest even integer value. If the result is outside the range of the return type, the behavior is undefined.

__device__ ​ long int lroundf ( float  x )
Round to nearest integer value.
###### Returns

Returns rounded integer value.

###### Description

Round x to the nearest integer value, with halfway cases rounded away from zero. If the result is outside the range of the return type, the behavior is undefined.

Note:

This function may be slower than alternate rounding methods. See lrintf().

__device__ ​ float max ( const float  a, const float  b )
Calculate the maximum value of the input float arguments.
###### Description

Calculate the maximum value of the arguments a and b. Behavior is equivalent to fmaxf() function.

Note, this is different from std:: specification

__device__ ​ float min ( const float  a, const float  b )
Calculate the minimum value of the input float arguments.
###### Description

Calculate the minimum value of the arguments a and b. Behavior is equivalent to fminf() function.

Note, this is different from std:: specification

__device__ ​ float modff ( float  x, float* iptr )
Break down the input argument into fractional and integral parts.
###### Returns

• modff( $±x$ , iptr) returns a result with the same sign as x.
• modff( $±\mathrm{\infty }$ , iptr) returns $±0$ and stores $±\mathrm{\infty }$ in the object pointed to by iptr.
• modff(NaN, iptr) stores a NaN in the object pointed to by iptr and returns a NaN.
###### Description

Break down the argument x into fractional and integral parts. The integral part is stored in the argument iptr. Fractional and integral parts are given the same sign as the argument x.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float nanf ( const char* tagp )
Returns "Not a Number" value.
###### Returns

• nanf(tagp) returns NaN.
###### Description

Return a representation of a quiet NaN. Argument tagp selects one of the possible representations.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float nearbyintf ( float  x )
Round the input argument to the nearest integer.
###### Returns

• nearbyintf( $±0$ ) returns $±0$ .
• nearbyintf( $±\mathrm{\infty }$ ) returns $±\mathrm{\infty }$ .
###### Description

Round argument x to an integer value in single precision floating-point format. Uses round to nearest rounding, with ties rounding to even.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float nextafterf ( float  x, float  y )
Return next representable single-precision floating-point value after argument x in the direction of y.
###### Returns

• nextafterf(x, y) = y if x equals y.
• nextafterf(x, y) = NaN if either x or y are NaN.
###### Description

Calculate the next representable single-precision floating-point value following x in the direction of y. For example, if y is greater than x, nextafterf() returns the smallest representable number greater than x

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float norm3df ( float  a, float  b, float  c )
Calculate the square root of the sum of squares of three coordinates of the argument.
###### Returns

Returns the length of the 3D vector $\sqrt{{a}^{2}+{b}^{2}+{c}^{2}}$ .

• In the presence of an exactly infinite coordinate $+\mathrm{\infty }$ is returned, even if there are NaNs.
###### Description

Calculates the length of three dimensional vector in Euclidean space without undue overflow or underflow.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float norm4df ( float  a, float  b, float  c, float  d )
Calculate the square root of the sum of squares of four coordinates of the argument.
###### Returns

Returns the length of the 4D vector $\sqrt{{a}^{2}+{b}^{2}+{c}^{2}+{d}^{2}}$ .

• In the presence of an exactly infinite coordinate $+\mathrm{\infty }$ is returned, even if there are NaNs.
###### Description

Calculates the length of four dimensional vector in Euclidean space without undue overflow or underflow.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float normcdff ( float  x )
Calculate the standard normal cumulative distribution function.
###### Returns

• normcdff( $+\mathrm{\infty }$ ) returns 1.
• normcdff( $-\mathrm{\infty }$ ) returns +0
###### Description

Calculate the cumulative distribution function of the standard normal distribution for input argument x, $\mathrm{\Phi }\left(x\right)$ .

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float normcdfinvf ( float  x )
Calculate the inverse of the standard normal cumulative distribution function.
###### Returns

• normcdfinvf( $±0$ ) returns $-\mathrm{\infty }$ .
• normcdfinvf(1) returns $+\mathrm{\infty }$ .
• normcdfinvf(x) returns NaN if x is not in the interval [0,1].
###### Description

Calculate the inverse of the standard normal cumulative distribution function for input argument x, ${\mathrm{\Phi }}^{-1}\left(x\right)$ . The function is defined for input values in the interval $\left(0,1\right)$ .

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float normf ( int  dim, const float* p )
Calculate the square root of the sum of squares of any number of coordinates.
###### Returns

Returns the length of the dim-D vector $\sqrt{{{p}_{0}}^{2}+{{p}_{1}}^{2}+ ... +{{p}_{\mathrm{dim}-1}}^{2}}$ .

• In the presence of an exactly infinite coordinate $+\mathrm{\infty }$ is returned, even if there are NaNs.
###### Description

Calculates the length of a vector p, dimension of which is passed as an argument without undue overflow or underflow.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float powf ( float  x, float  y )
Calculate the value of first argument to the power of second argument.
###### Returns

• powf( $±0$ , y) returns $±\mathrm{\infty }$ for y an odd integer less than 0.
• powf( $±0$ , y) returns $+\mathrm{\infty }$ for y less than 0 and not an odd integer.
• powf( $±0$ , y) returns $±0$ for y an odd integer greater than 0.
• powf( $±0$ , y) returns +0 for y > 0 and not an odd integer.
• powf(-1, $±\mathrm{\infty }$ ) returns 1.
• powf(+1, y) returns 1 for any y, even a NaN.
• powf(x, $±0$ ) returns 1 for any x, even a NaN.
• powf(x, y) returns a NaN for finite x < 0 and finite non-integer y.
• powf(x, $-\mathrm{\infty }$ ) returns $+\mathrm{\infty }$ for $|x|<1$ .
• powf(x, $-\mathrm{\infty }$ ) returns +0 for $|x|>1$ .
• powf(x, $+\mathrm{\infty }$ ) returns +0 for $|x|<1$ .
• powf(x, $+\mathrm{\infty }$ ) returns $+\mathrm{\infty }$ for $|x|>1$ .
• powf( $-\mathrm{\infty }$ , y) returns -0 for y an odd integer less than 0.
• powf( $-\mathrm{\infty }$ , y) returns +0 for y < 0 and not an odd integer.
• powf( $-\mathrm{\infty }$ , y) returns $-\mathrm{\infty }$ for y an odd integer greater than 0.
• powf( $-\mathrm{\infty }$ , y) returns $+\mathrm{\infty }$ for y > 0 and not an odd integer.
• powf( $+\mathrm{\infty }$ , y) returns +0 for y < 0.
• powf( $+\mathrm{\infty }$ , y) returns $+\mathrm{\infty }$ for y > 0.
###### Description

Calculate the value of x to the power of y.

Note:
• For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

• This function is affected by the --use_fast_math compiler flag. See the CUDA C++ Programming Guide, Mathematical Functions Appendix, Intrinsic Functions section for a complete list of functions affected.

__device__ ​ float rcbrtf ( float  x )
Calculate reciprocal cube root function.
###### Returns

• rcbrt( $±0$ ) returns $±\mathrm{\infty }$ .
• rcbrt( $±\mathrm{\infty }$ ) returns $±0$ .
###### Description

Calculate reciprocal cube root function of x.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float remainderf ( float  x, float  y )
Compute single-precision floating-point remainder.
###### Returns

• remainderf(x, $±0$ ) returns NaN.
• remainderf( $±\mathrm{\infty }$ , y) returns NaN.
• remainderf(x, $±\mathrm{\infty }$ ) returns x for finite x.
###### Description

Compute single-precision floating-point remainder r of dividing x by y for nonzero y. Thus $r=x-ny$ . The value n is the integer value nearest $\frac{x}{y}$ . In the case when $|n-\frac{x}{y}|=\frac{1}{2}$ , the even n value is chosen.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float remquof ( float  x, float  y, int* quo )
Compute single-precision floating-point remainder and part of quotient.
###### Returns

Returns the remainder.

• remquof(x, $±0$ , quo) returns NaN and stores an unspecified value in the location to which quo points.
• remquof( $±\mathrm{\infty }$ , y, quo) returns NaN and stores an unspecified value in the location to which quo points.
• remquof(x, y, quo) returns NaN and stores an unspecified value in the location to which quo points if either of x or y is NaN.
• remquof(x, $±\mathrm{\infty }$ , quo) returns x and stores zero in the location to which quo points for finite x.
###### Description

Compute a single-precision floating-point remainder in the same way as the remainderf() function. Argument quo returns part of quotient upon division of x by y. Value quo has the same sign as $\frac{x}{y}$ and may not be the exact quotient but agrees with the exact quotient in the low order 3 bits.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float rhypotf ( float  x, float  y )
Calculate one over the square root of the sum of squares of two arguments.
###### Returns

Returns one over the length of the hypotenuse $\frac{1}{\sqrt{{x}^{2}+{y}^{2}}}$ .

• rhypotf(x,y), rhypotf(y,x), and rhypotf(x, -y) are equivalent.
• rhypotf( $±\mathrm{\infty }$ ,y) returns +0, even if y is a NaN.
###### Description

Calculates one over the length of the hypotenuse of a right triangle whose two sides have lengths x and y without undue overflow or underflow.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float rintf ( float  x )
Round input to nearest integer value in floating-point.
###### Returns

Returns rounded integer value.

• rintf( $±0$ ) returns $±0$ .
• rintf( $±\mathrm{\infty }$ ) returns $±\mathrm{\infty }$ .
###### Description

Round x to the nearest integer value in floating-point format, with halfway cases rounded to the nearest even integer value.

__device__ ​ float rnorm3df ( float  a, float  b, float  c )
Calculate one over the square root of the sum of squares of three coordinates.
###### Returns

Returns one over the length of the 3D vector $\frac{1}{\sqrt{{a}^{2}+{b}^{2}+{c}^{2}}}$ .

• In the presence of an exactly infinite coordinate $+0$ is returned, even if there are NaNs.
###### Description

Calculates one over the length of three dimension vector in Euclidean space without undue overflow or underflow.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float rnorm4df ( float  a, float  b, float  c, float  d )
Calculate one over the square root of the sum of squares of four coordinates.
###### Returns

Returns one over the length of the 3D vector $\frac{1}{\sqrt{{a}^{2}+{b}^{2}+{c}^{2}+{d}^{2}}}$ .

• In the presence of an exactly infinite coordinate $+0$ is returned, even if there are NaNs.
###### Description

Calculates one over the length of four dimension vector in Euclidean space without undue overflow or underflow.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float rnormf ( int  dim, const float* p )
Calculate the reciprocal of square root of the sum of squares of any number of coordinates.
###### Returns

Returns one over the length of the vector $\frac{1}{\sqrt{{{p}_{0}}^{2}+{{p}_{1}}^{2}+ ... +{{p}_{\mathrm{dim}-1}}^{2}}}$ .

• In the presence of an exactly infinite coordinate $+0$ is returned, even if there are NaNs.
###### Description

Calculates one over the length of vector p, dimension of which is passed as an argument, in Euclidean space without undue overflow or underflow.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float roundf ( float  x )
Round to nearest integer value in floating-point.
###### Returns

Returns rounded integer value.

• roundf( $±0$ ) returns $±0$ .
• roundf( $±\mathrm{\infty }$ ) returns $±\mathrm{\infty }$ .
###### Description

Round x to the nearest integer value in floating-point format, with halfway cases rounded away from zero.

Note:

This function may be slower than alternate rounding methods. See rintf().

__device__ ​ float rsqrtf ( float  x )
Calculate the reciprocal of the square root of the input argument.
###### Returns

Returns $1/\sqrt{x}$ .

• rsqrtf( $+\mathrm{\infty }$ ) returns +0.
• rsqrtf( $±0$ ) returns $±\mathrm{\infty }$ .
• rsqrtf(x) returns NaN if x is less than 0.
###### Description

Calculate the reciprocal of the nonnegative square root of x, $1/\sqrt{x}$ .

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float scalblnf ( float  x, long int  n )
Scale floating-point input by integer power of two.
###### Returns

Returns x * ${2}^{n}$ .

• scalblnf( $±0$ , n) returns $±0$ .
• scalblnf(x, 0) returns x.
• scalblnf( $±\mathrm{\infty }$ , n) returns $±\mathrm{\infty }$ .
###### Description

Scale x by ${2}^{n}$ by efficient manipulation of the floating-point exponent.

__device__ ​ float scalbnf ( float  x, int  n )
Scale floating-point input by integer power of two.
###### Returns

Returns x * ${2}^{n}$ .

• scalbnf( $±0$ , n) returns $±0$ .
• scalbnf(x, 0) returns x.
• scalbnf( $±\mathrm{\infty }$ , n) returns $±\mathrm{\infty }$ .
###### Description

Scale x by ${2}^{n}$ by efficient manipulation of the floating-point exponent.

__device__ ​ __RETURN_TYPE signbit ( float  a )
Return the sign bit of the input.
###### Returns

Reports the sign bit of all values including infinities, zeros, and NaNs.

• With Visual Studio 2013 host compiler: __RETURN_TYPE is 'bool'. Returns true if and only if a is negative.
• With other host compilers: __RETURN_TYPE is 'int'. Returns a nonzero value if and only if a is negative.
###### Description

Determine whether the floating-point value a is negative.

__device__ ​ void sincosf ( float  x, float* sptr, float* cptr )
Calculate the sine and cosine of the first input argument.

• none
###### Description

Calculate the sine and cosine of the first input argument x (measured in radians). The results for sine and cosine are written into the second argument, sptr, and, respectively, third argument, cptr.

sinf() and cosf().

Note:
• For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

• This function is affected by the --use_fast_math compiler flag. See the CUDA C++ Programming Guide, Mathematical Functions Appendix, Intrinsic Functions section for a complete list of functions affected.

__device__ ​ void sincospif ( float  x, float* sptr, float* cptr )
Calculate the sine and cosine of the first input argument $×\pi$ .

• none
###### Description

Calculate the sine and cosine of the first input argument, x (measured in radians), $×\pi$ . The results for sine and cosine are written into the second argument, sptr, and, respectively, third argument, cptr.

sinpif() and cospif().

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float sinf ( float  x )
Calculate the sine of the input argument.
###### Returns

• sinf( $±0$ ) returns $±0$ .
• sinf( $±\mathrm{\infty }$ ) returns NaN.
###### Description

Calculate the sine of the input argument x (measured in radians).

Note:
• For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

• This function is affected by the --use_fast_math compiler flag. See the CUDA C++ Programming Guide, Mathematical Functions Appendix, Intrinsic Functions section for a complete list of functions affected.

__device__ ​ float sinhf ( float  x )
Calculate the hyperbolic sine of the input argument.
###### Returns

• sinhf( $±0$ ) returns $±0$ .
• sinhf( $±\mathrm{\infty }$ ) returns $±\mathrm{\infty }$ .
###### Description

Calculate the hyperbolic sine of the input argument x.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float sinpif ( float  x )
Calculate the sine of the input argument $×\pi$ .
###### Returns

• sinpif( $±0$ ) returns $±0$ .
• sinpif( $±\mathrm{\infty }$ ) returns NaN.
###### Description

Calculate the sine of x$×\pi$ (measured in radians), where x is the input argument.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float sqrtf ( float  x )
Calculate the square root of the input argument.
###### Returns

Returns $\sqrt{x}$ .

• sqrtf( $±0$ ) returns $±0$ .
• sqrtf( $+\mathrm{\infty }$ ) returns $+\mathrm{\infty }$ .
• sqrtf(x) returns NaN if x is less than 0.
###### Description

Calculate the nonnegative square root of x, $\sqrt{x}$ .

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float tanf ( float  x )
Calculate the tangent of the input argument.
###### Returns

• tanf( $±0$ ) returns $±0$ .
• tanf( $±\mathrm{\infty }$ ) returns NaN.
###### Description

Calculate the tangent of the input argument x (measured in radians).

Note:
• For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

• This function is affected by the --use_fast_math compiler flag. See the CUDA C++ Programming Guide, Mathematical Functions Appendix, Intrinsic Functions section for a complete list of functions affected.

__device__ ​ float tanhf ( float  x )
Calculate the hyperbolic tangent of the input argument.
###### Returns

• tanhf( $±0$ ) returns $±0$ .
• tanhf( $±\mathrm{\infty }$ ) returns $±1$ .
###### Description

Calculate the hyperbolic tangent of the input argument x.

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float tgammaf ( float  x )
Calculate the gamma function of the input argument.
###### Returns

• tgammaf( $±0$ ) returns $±\mathrm{\infty }$ .
• tgammaf(2) returns +1.
• tgammaf(x) returns NaN if x < 0 and x is an integer.
• tgammaf( $-\mathrm{\infty }$ ) returns NaN.
• tgammaf( $+\mathrm{\infty }$ ) returns $+\mathrm{\infty }$ .
###### Description

Calculate the gamma function of the input argument x, namely the value of ${\int }_{0}^{\mathrm{\infty }}{e}^{-t}{t}^{x-1}dt$ .

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float truncf ( float  x )
Truncate input argument to the integral part.
###### Returns

Returns truncated integer value.

• truncf( $±0$ ) returns $±0$ .
• truncf( $±\mathrm{\infty }$ ) returns $±\mathrm{\infty }$ .
###### Description

Round x to the nearest integer value that does not exceed x in magnitude.

__device__ ​ float y0f ( float  x )
Calculate the value of the Bessel function of the second kind of order 0 for the input argument.
###### Returns

Returns the value of the Bessel function of the second kind of order 0.

• y0f( $±0$ ) returns $-\mathrm{\infty }$ .
• y0f(x) returns NaN for x < 0.
• y0f( $+\mathrm{\infty }$ ) returns +0.
• y0f(NaN) returns NaN.
###### Description

Calculate the value of the Bessel function of the second kind of order 0 for the input argument x, ${Y}_{0}\left(x\right)$ .

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float y1f ( float  x )
Calculate the value of the Bessel function of the second kind of order 1 for the input argument.
###### Returns

Returns the value of the Bessel function of the second kind of order 1.

• y1f( $±0$ ) returns $-\mathrm{\infty }$ .
• y1f(x) returns NaN for x < 0.
• y1f( $+\mathrm{\infty }$ ) returns +0.
• y1f(NaN) returns NaN.
###### Description

Calculate the value of the Bessel function of the second kind of order 1 for the input argument x, ${Y}_{1}\left(x\right)$ .

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.

__device__ ​ float ynf ( int  n, float  x )
Calculate the value of the Bessel function of the second kind of order n for the input argument.
###### Returns

Returns the value of the Bessel function of the second kind of order n.

• ynf(n, x) returns NaN for n < 0.
• ynf(n, $±0$ ) returns $-\mathrm{\infty }$ .
• ynf(n, x) returns NaN for x < 0.
• ynf(n, $+\mathrm{\infty }$ ) returns +0.
• ynf(n, NaN) returns NaN.
###### Description

Calculate the value of the Bessel function of the second kind of order n for the input argument x, ${Y}_{n}\left(x\right)$ .

Note:

For accuracy information see the CUDA C++ Programming Guide, Mathematical Functions Appendix, Single-Precision Floating-Point Functions section.