Functions in the precise_math namespace have higher accuracy, but require double-precision support, which not all accelerators do. More...

Functions
float	acosf (float _X) __GPU_ONLY
	Calculates the arccosine of the argument More...

float	acos (float _X) __GPU_ONLY
	Calculates the arccosine of the argument More...

double	acos (double _X) __GPU_ONLY
	Calculates the arccosine of the argument More...

float	acoshf (float _X) __GPU_ONLY
	Calculates the inverse hyperbolic cosine of the argument More...

float	acosh (float _X) __GPU_ONLY
	Calculates the inverse hyperbolic cosine of the argument More...

double	acosh (double _X) __GPU_ONLY
	Calculates the inverse hyperbolic cosine of the argument More...

float	asinf (float _X) __GPU_ONLY
	Calculates the arcsine of the argument More...

float	asin (float _X) __GPU_ONLY
	Calculates the arcsine of the argument More...

double	asin (double _X) __GPU_ONLY
	Calculates the arcsine of the argument More...

float	asinhf (float _X) __GPU_ONLY
	Calculates the inverse hyperbolic sine of the argument More...

float	asinh (float _X) __GPU_ONLY
	Calculates the inverse hyperbolic sine of the argument More...

double	asinh (double _X) __GPU_ONLY
	Calculates the inverse hyperbolic sine of the argument More...

float	atanf (float _X) __GPU_ONLY
	Calculates the arctangent of the argument More...

float	atan (float _X) __GPU_ONLY
	Calculates the arctangent of the argument More...

double	atan (double _X) __GPU_ONLY
	Calculates the arctangent of the argument More...

float	atan2f (float _Y, float _X) __GPU_ONLY
	Calculates the arctangent of _Y/_X More...

float	atan2 (float _Y, float _X) __GPU_ONLY
	Calculates the arctangent of _Y/_X More...

double	atan2 (double _Y, double _X) __GPU_ONLY
	Calculates the arctangent of _Y/_X More...

float	atanhf (float _X) __GPU_ONLY
	Calculates the inverse hyperbolic tangent of the argument More...

float	atanh (float _X) __GPU_ONLY
	Calculates the inverse hyperbolic tangent of the argument More...

double	atanh (double _X) __GPU_ONLY
	Calculates the inverse hyperbolic tangent of the argument More...

float	cbrtf (float _X) __GPU_ONLY
	Computes the real cube root of the argument More...

float	cbrt (float _X) __GPU_ONLY
	Computes the real cube root of the argument More...

double	cbrt (double _X) __GPU_ONLY
	Computes the real cube root of the argument More...

float	ceilf (float _X) __GPU_ONLY
	Calculates the ceiling of the argument More...

float	ceil (float _X) __GPU_ONLY
	Calculates the ceiling of the argument More...

double	ceil (double _X) __GPU_ONLY
	Calculates the ceiling of the argument More...

float	copysignf (float _X, float _Y) __GPU_ONLY
	Produces a value with the magnitude of _X and the sign of _Y More...

float	copysign (float _X, float _Y) __GPU_ONLY
	Produces a value with the magnitude of _X and the sign of _Y More...

double	copysign (double _X, double _Y) __GPU_ONLY
	Produces a value with the magnitude of _X and the sign of _Y More...

float	cosf (float _X) __GPU_ONLY
	Calculates the cosine of the argument More...

float	cos (float _X) __GPU_ONLY
	Calculates the cosine of the argument More...

double	cos (double _X) __GPU_ONLY
	Calculates the cosine of the argument More...

float	coshf (float _X) __GPU_ONLY
	Calculates the hyperbolic cosine value of the argument More...

float	cosh (float _X) __GPU_ONLY
	Calculates the hyperbolic cosine value of the argument More...

double	cosh (double _X) __GPU_ONLY
	Calculates the hyperbolic cosine value of the argument More...

float	cospif (float _X) __GPU_ONLY
	Calculates the cosine value of pi * _X More...

float	cospi (float _X) __GPU_ONLY
	Calculates the cosine value of pi * _X More...

double	cospi (double _X) __GPU_ONLY
	Calculates the cosine value of pi * _X More...

float	erff (float _X) __GPU_ONLY
	Computes the error function of _X More...

float	erf (float _X) __GPU_ONLY
	Computes the error function of _X More...

double	erf (double _X) __GPU_ONLY
	Computes the error function of _X More...

float	erfcf (float _X) __GPU_ONLY
	Computes the complementary error function of _X More...

float	erfc (float _X) __GPU_ONLY
	Computes the complementary error function of _X More...

double	erfc (double _X) __GPU_ONLY
	Computes the complementary error function of _X More...

float	erfinvf (float _X) __GPU_ONLY
	Computes the inverse error function of _X More...

float	erfinv (float _X) __GPU_ONLY
	Computes the inverse error function of _X More...

double	erfinv (double _X) __GPU_ONLY
	Computes the inverse error function of _X More...

float	erfcinvf (float _X) __GPU_ONLY
	Computes the inverse complementary error function of _X More...

float	erfcinv (float _X) __GPU_ONLY
	Computes the inverse complementary error function of _X More...

double	erfcinv (double _X) __GPU_ONLY
	Computes the inverse complementary error function of _X More...

float	expf (float _X) __GPU_ONLY
	Calculates the base-e exponential of the argument More...

float	exp (float _X) __GPU_ONLY
	Calculates the base-e exponential of the argument More...

double	exp (double _X) __GPU_ONLY
	Calculates the base-e exponential of the argument More...

float	exp2f (float _X) __GPU_ONLY
	Calculates the base-2 exponential of the argument More...

float	exp2 (float _X) __GPU_ONLY
	Calculates the base-2 exponential of the argument More...

double	exp2 (double _X) __GPU_ONLY
	Calculates the base-2 exponential of the argument More...

float	exp10f (float _X) __GPU_ONLY
	Calculates the base-10 exponential of the argument More...

float	exp10 (float _X) __GPU_ONLY
	Calculates the base-10 exponential of the argument More...

double	exp10 (double _X) __GPU_ONLY
	Calculates the base-10 exponential of the argument More...

float	expm1f (float _X) __GPU_ONLY
	Calculates the base-e exponential of the argument, minus 1 More...

float	expm1 (float _X) __GPU_ONLY
	Calculates the base-e exponential of the argument, minus 1 More...

double	expm1 (double _X) __GPU_ONLY
	Calculates the base-e exponential of the argument, minus 1 More...

float	fabsf (float _X) __GPU_ONLY
	Returns the absolute value of the argument More...

float	fabs (float _X) __GPU_ONLY
	Returns the absolute value of the argument More...

double	fabs (double _X) __GPU_ONLY
	Returns the absolute value of the argument More...

float	fdimf (float _X, float _Y) __GPU_ONLY
	Determines the positive difference between the arguments More...

float	fdim (float _X, float _Y) __GPU_ONLY
	Determines the positive difference between the arguments More...

double	fdim (double _X, double _Y) __GPU_ONLY
	Determines the positive difference between the arguments More...

float	floorf (float _X) __GPU_ONLY
	Calculates the floor of the argument More...

float	floor (float _X) __GPU_ONLY
	Calculates the floor of the argument More...

double	floor (double _X) __GPU_ONLY
	Calculates the floor of the argument More...

float	fmaf (float _X, float _Y, float _Z) __GPU_ONLY
	Compute (_X * _Y) + _Z, rounded as one ternary operation More...

float	fma (float _X, float _Y, float _Z) __GPU_ONLY
	Compute (_X * _Y) + _Z, rounded as one ternary operation More...

double	fma (double _X, double _Y, double _Z) __GPU_ONLY
	Compute (_X * _Y) + _Z, rounded as one ternary operation More...

float	fmaxf (float _X, float _Y) __GPU_ONLY
	Determine the maximum numeric value of the arguments More...

float	fmax (float _X, float _Y) __GPU_ONLY
	Determine the maximum numeric value of the arguments More...

double	fmax (double _X, double _Y) __GPU_ONLY
	Determine the maximum numeric value of the arguments More...

float	fminf (float _X, float _Y) __GPU_ONLY
	Determine the minimum numeric value of the arguments More...

float	fmin (float _X, float _Y) __GPU_ONLY
	Determine the minimum numeric value of the arguments More...

double	fmin (double _X, double _Y) __GPU_ONLY
	Determine the minimum numeric value of the arguments More...

float	fmodf (float _X, float _Y) __GPU_ONLY
	Calculates the floating-point remainder of _X/_Y More...

float	fmod (float _X, float _Y) __GPU_ONLY
	Calculates the floating-point remainder of _X/_Y More...

double	fmod (double _X, double _Y) __GPU_ONLY
	Calculates the floating-point remainder of _X/_Y More...

int	fpclassify (float _X) __GPU_ONLY
	Classifies the argument value as NaN, infinite, normal, subnormal, zero More...

int	fpclassify (double _X) __GPU_ONLY
	Classifies the argument value as NaN, infinite, normal, subnormal, zero More...

float	frexpf (float _X, _Out_ int *_Exp) __GPU_ONLY
	Gets the mantissa and exponent of _X More...

float	frexp (float _X, _Out_ int *_Exp) __GPU_ONLY
	Gets the mantissa and exponent of _X More...

double	frexp (double _X, _Out_ int *_Exp) __GPU_ONLY
	Gets the mantissa and exponent of _X More...

float	hypotf (float _X, float _Y) __GPU_ONLY
	Computes the square root of the sum of the squares of _X and _Y More...

float	hypot (float _X, float _Y) __GPU_ONLY
	Computes the square root of the sum of the squares of _X and _Y More...

double	hypot (double _X, double _Y) __GPU_ONLY
	Computes the square root of the sum of the squares of _X and _Y More...

int	ilogbf (float _X) __GPU_ONLY
	Extract the exponent of _X as a signed int value More...

int	ilogb (float _X) __GPU_ONLY
	Extract the exponent of _X as a signed int value More...

int	ilogb (double _X) __GPU_ONLY
	Extract the exponent of _X as a signed int value More...

int	isfinite (float _X) __GPU_ONLY
	Determines whether the argument has a finite value More...

int	isfinite (double _X) __GPU_ONLY
	Determines whether the argument has a finite value More...

int	isinf (float _X) __GPU_ONLY
	Determines whether the argument is an infinity More...

int	isinf (double _X) __GPU_ONLY
	Determines whether the argument is an infinity More...

int	isnan (float _X) __GPU_ONLY
	Determines whether the argument is a NaN More...

int	isnan (double _X) __GPU_ONLY
	Determines whether the argument is a NaN More...

int	isnormal (float _X) __GPU_ONLY
	Determines whether the argument is a normal More...

int	isnormal (double _X) __GPU_ONLY
	Determines whether the argument is a normal More...

float	ldexpf (float _X, int _Exp) __GPU_ONLY
	Computes a real number from the mantissa and exponent More...

float	ldexp (float _X, int _Exp) __GPU_ONLY
	Computes a real number from the mantissa and exponent More...

double	ldexp (double _X, int _Exp) __GPU_ONLY
	Computes a real number from the mantissa and exponent More...

float	lgammaf (float _X, _Out_ int *_Sign) __GPU_ONLY
	Computes the natural logarithm of the absolute value of gamma of the argument More...

float	lgamma (float _X, _Out_ int *_Sign) __GPU_ONLY
	Computes the natural logarithm of the absolute value of gamma of the argument More...

double	lgamma (double _X, _Out_ int *_Sign) __GPU_ONLY
	Computes the natural logarithm of the absolute value of gamma of the argument More...

float	logf (float _X) __GPU_ONLY
	Calculates the base-e logarithm of the argument More...

float	log (float _X) __GPU_ONLY
	Calculates the base-e logarithm of the argument More...

double	log (double _X) __GPU_ONLY
	Calculates the base-e logarithm of the argument More...

float	log10f (float _X) __GPU_ONLY
	Calculates the base-10 logarithm of the argument More...

float	log10 (float _X) __GPU_ONLY
	Calculates the base-10 logarithm of the argument More...

double	log10 (double _X) __GPU_ONLY
	Calculates the base-10 logarithm of the argument More...

float	log2f (float _X) __GPU_ONLY
	Calculates the base-2 logarithm of the argument More...

float	log2 (float _X) __GPU_ONLY
	Calculates the base-2 logarithm of the argument More...

double	log2 (double _X) __GPU_ONLY
	Calculates the base-2 logarithm of the argument More...

float	log1pf (float _X) __GPU_ONLY
	Calculates the base-e logarithm of 1 plus the argument More...

float	log1p (float _X) __GPU_ONLY
	Calculates the base-e logarithm of 1 plus the argument More...

double	log1p (double _X) __GPU_ONLY
	Calculates the base-e logarithm of 1 plus the argument More...

float	logbf (float _X) __GPU_ONLY
	Extracts the exponent of _X, as a signed integer value in floating-point format More...

float	logb (float _X) __GPU_ONLY
	Extracts the exponent of _X, as a signed integer value in floating-point format More...

double	logb (double _X) __GPU_ONLY
	Extracts the exponent of _X, as a signed integer value in floating-point format More...

float	modff (float _X, _Out_ float *_Iptr) __GPU_ONLY
	Splits _X into fractional and integer parts. More...

float	modf (float _X, _Out_ float *_Iptr) __GPU_ONLY
	Splits _X into fractional and integer parts. More...

double	modf (double _X, _Out_ double *_Iptr) __GPU_ONLY
	Splits _X into fractional and integer parts. More...

float	nanf (int _X) __GPU_ONLY
	Returns a quiet NaN More...

double	nan (int _X) __GPU_ONLY
	Returns a quiet NaN More...

float	nearbyintf (float _X) __GPU_ONLY
	Rounds the argument to an integer value in floating-point format, using the current rounding direction. More...

float	nearbyint (float _X) __GPU_ONLY
	Rounds the argument to an integer value in floating-point format, using the current rounding direction. More...

double	nearbyint (double _X) __GPU_ONLY
	Rounds the argument to an integer value in floating-point format, using the current rounding direction. More...

float	nextafterf (float _X, float _Y) __GPU_ONLY
	Determine the next representable value, in the type of the function, after _X in the direction of _Y More...

float	nextafter (float _X, float _Y) __GPU_ONLY
	Determine the next representable value, in the type of the function, after _X in the direction of _Y More...

double	nextafter (double _X, double _Y) __GPU_ONLY
	Determine the next representable value, in the type of the function, after _X in the direction of _Y More...

float	phif (float _X) __GPU_ONLY
	Returns the cumulative distribution function of the argument More...

float	phi (float _X) __GPU_ONLY
	Returns the cumulative distribution function of the argument More...

double	phi (double _X) __GPU_ONLY
	Returns the cumulative distribution function of the argument More...

float	powf (float _X, float _Y) __GPU_ONLY
	Calculates _X raised to the power of _Y More...

float	pow (float _X, float _Y) __GPU_ONLY
	Calculates _X raised to the power of _Y More...

double	pow (double _X, double _Y) __GPU_ONLY
	Calculates _X raised to the power of _Y More...

float	probitf (float _X) __GPU_ONLY
	Returns the inverse cumulative distribution function of the argument More...

float	probit (float _X) __GPU_ONLY
	Returns the inverse cumulative distribution function of the argument More...

double	probit (double _X) __GPU_ONLY
	Returns the inverse cumulative distribution function of the argument More...

float	rcbrtf (float _X) __GPU_ONLY
	Returns the reciprocal of the cube root of the argument More...

float	rcbrt (float _X) __GPU_ONLY
	Returns the reciprocal of the cube root of the argument More...

double	rcbrt (double _X) __GPU_ONLY
	Returns the reciprocal of the cube root of the argument More...

float	remainderf (float _X, float _Y) __GPU_ONLY
	Computes the remainder: _X REM _Y More...

float	remainder (float _X, float _Y) __GPU_ONLY
	Computes the remainder: _X REM _Y More...

double	remainder (double _X, double _Y) __GPU_ONLY
	Computes the remainder: _X REM _Y More...

float	remquof (float _X, float _Y, _Out_ int *_Quo) __GPU_ONLY
	Computes the same remainder as _X REM _Y. Also calculates the lower 24 bits of the integral quotient _X/_Y, and gives that value the same sign as _X/_Y. It stores this signed value in the integer pointed to by _Quo. More...

float	remquo (float _X, float _Y, _Out_ int *_Quo) __GPU_ONLY
	Computes the same remainder as _X REM _Y. Also calculates the lower 24 bits of the integral quotient _X/_Y, and gives that value the same sign as _X/_Y. It stores this signed value in the integer pointed to by _Quo. More...

double	remquo (double _X, double _Y, _Out_ int *_Quo) __GPU_ONLY
	Computes the same remainder as _X REM _Y. Also calculates the lower 31 bits of the integral quotient _X/_Y, and gives that value the same sign as _X/_Y. It stores this signed value in the integer pointed to by _Quo. More...

float	roundf (float _X) __GPU_ONLY
	Rounds _X to the nearest integer More...

float	round (float _X) __GPU_ONLY
	Rounds _X to the nearest integer More...

double	round (double _X) __GPU_ONLY
	Rounds _X to the nearest integer More...

float	rsqrtf (float _X) __GPU_ONLY
	Returns the reciprocal of the square root of the argument More...

float	rsqrt (float _X) __GPU_ONLY
	Returns the reciprocal of the square root of the argument More...

double	rsqrt (double _X) __GPU_ONLY
	Returns the reciprocal of the square root of the argument More...

float	scalbf (float _X, float _Y) __GPU_ONLY
	Multiplies _X by FLT_RADIX to the power _Y More...

float	scalb (float _X, float _Y) __GPU_ONLY
	Multiplies _X by FLT_RADIX to the power _Y More...

double	scalb (double _X, double _Y) __GPU_ONLY
	Multiplies _X by FLT_RADIX to the power _Y More...

float	scalbnf (float _X, int _Y) __GPU_ONLY
	Multiplies _X by FLT_RADIX to the power _Y More...

float	scalbn (float _X, int _Y) __GPU_ONLY
	Multiplies _X by FLT_RADIX to the power _Y More...

double	scalbn (double _X, int _Y) __GPU_ONLY
	Multiplies _X by FLT_RADIX to the power _Y More...

int	signbitf (float _X) __GPU_ONLY
	Determines whether the sign of _X is negative More...

int	signbit (float _X) __GPU_ONLY
	Determines whether the sign of _X is negative More...

int	signbit (double _X) __GPU_ONLY
	Determines whether the sign of _X is negative More...

float	sinf (float _X) __GPU_ONLY
	Calculates the sine value of the argument More...

float	sin (float _X) __GPU_ONLY
	Calculates the sine value of the argument More...

double	sin (double _X) __GPU_ONLY
	Calculates the sine value of the argument More...

void	sincosf (float _X, _Out_ float _S, _Out_ float _C) __GPU_ONLY
	Calculates sine and cosine value of _X More...

void	sincos (float _X, _Out_ float _S, _Out_ float _C) __GPU_ONLY
	Calculates sine and cosine value of _X More...

void	sincos (double _X, _Out_ double _S, _Out_ double _C) __GPU_ONLY
	Calculates sine and cosine value of _X More...

float	sinhf (float _X) __GPU_ONLY
	Calculates the hyperbolic sine value of the argument More...

float	sinh (float _X) __GPU_ONLY
	Calculates the hyperbolic sine value of the argument More...

double	sinh (double _X) __GPU_ONLY
	Calculates the hyperbolic sine value of the argument More...

float	sinpif (float _X) __GPU_ONLY
	Calculates the sine value of pi * _X More...

float	sinpi (float _X) __GPU_ONLY
	Calculates the sine value of pi * _X More...

double	sinpi (double _X) __GPU_ONLY
	Calculates the sine value of pi * _X More...

float	sqrtf (float _X) __GPU_ONLY
	Calculates the squre root of the argument More...

float	sqrt (float _X) __GPU_ONLY
	Calculates the squre root of the argument More...

double	sqrt (double _X) __GPU_ONLY
	Calculates the squre root of the argument More...

float	tgammaf (float _X) __GPU_ONLY
	Computes the gamma function of _X More...

float	tgamma (float _X) __GPU_ONLY
	Computes the gamma function of _X More...

double	tgamma (double _X) __GPU_ONLY
	Computes the gamma function of _X More...

float	tanf (float _X) __GPU_ONLY
	Calculates the tangent value of the argument More...

float	tan (float _X) __GPU_ONLY
	Calculates the tangent value of the argument More...

double	tan (double _X) __GPU_ONLY
	Calculates the tangent value of the argument More...

float	tanhf (float _X) __GPU_ONLY
	Calculates the hyperbolic tangent value of the argument More...

float	tanh (float _X) __GPU_ONLY
	Calculates the hyperbolic tangent value of the argument More...

double	tanh (double _X) __GPU_ONLY
	Calculates the hyperbolic tangent value of the argument More...

float	tanpif (float _X) __GPU_ONLY
	Calculates the tangent value of pi * _X More...

float	tanpi (float _X) __GPU_ONLY
	Calculates the tangent value of pi * _X More...

double	tanpi (double _X) __GPU_ONLY
	Calculates the tangent value of pi * _X More...

float	truncf (float _X) __GPU_ONLY
	Truncates the argument to the integer component More...

float	trunc (float _X) __GPU_ONLY
	Truncates the argument to the integer component More...

double	trunc (double _X) __GPU_ONLY
	Truncates the argument to the integer component More...

Detailed Description

Functions in the precise_math namespace have higher accuracy, but require double-precision support, which not all accelerators do.

Function Documentation

float Concurrency::precise_math::acos ( float _X )

inline

Calculates the arccosine of the argument

Parameters

_X	Floating-point value

Returns: Returns the arccosine value of the argument

     {
         return __dp_math_acosf(_X);
     }

double Concurrency::precise_math::acos ( double _X )

inline

Calculates the arccosine of the argument

Parameters

_X	Floating-point value

Returns: Returns the arccosine value of the argument

     {
         return __dp_math_acos(_X);
     }

float Concurrency::precise_math::acosf ( float _X )

inline

Calculates the arccosine of the argument

Parameters

_X	Floating-point value

Returns: Returns the arccosine value of the argument

     {
         return __dp_math_acosf(_X);
     }

float Concurrency::precise_math::acosh ( float _X )

inline

Calculates the inverse hyperbolic cosine of the argument

Parameters

_X	Floating-point value

Returns: Returns the inverse hyperbolic cosine value of the argument

     {
         return __dp_math_acoshf(_X);
     }

double Concurrency::precise_math::acosh ( double _X )

inline

Calculates the inverse hyperbolic cosine of the argument

Parameters

_X	Floating-point value

Returns: Returns the inverse hyperbolic cosine value of the argument

     {
         return __dp_math_acosh(_X);
     }

float Concurrency::precise_math::acoshf ( float _X )

inline

Calculates the inverse hyperbolic cosine of the argument

Parameters

_X	Floating-point value

Returns: Returns the inverse hyperbolic cosine value of the argument

     {
         return __dp_math_acoshf(_X);
     }

float Concurrency::precise_math::asin ( float _X )

inline

Calculates the arcsine of the argument

Parameters

_X	Floating-point value

Returns: Returns the arcsine value of the argument

     {
         return __dp_math_asinf(_X);
     }

double Concurrency::precise_math::asin ( double _X )

inline

Calculates the arcsine of the argument

Parameters

_X	Floating-point value

Returns: Returns the arcsine value of the argument

     {
         return __dp_math_asin(_X);
     }

float Concurrency::precise_math::asinf ( float _X )

inline

Calculates the arcsine of the argument

Parameters

_X	Floating-point value

Returns: Returns the arcsine value of the argument

     {
         return __dp_math_asinf(_X);
     }

float Concurrency::precise_math::asinh ( float _X )

inline

Calculates the inverse hyperbolic sine of the argument

Parameters

_X	Floating-point value

Returns: Returns the inverse hyperbolic sine value of the argument

     {
         return __dp_math_asinhf(_X);
     }

double Concurrency::precise_math::asinh ( double _X )

inline

Calculates the inverse hyperbolic sine of the argument

Parameters

_X	Floating-point value

Returns: Returns the inverse hyperbolic sine value of the argument

     {
         return __dp_math_asinh(_X);
     }

float Concurrency::precise_math::asinhf ( float _X )

inline

Calculates the inverse hyperbolic sine of the argument

Parameters

_X	Floating-point value

Returns: Returns the inverse hyperbolic sine value of the argument

     {
         return __dp_math_asinhf(_X);
     }

float Concurrency::precise_math::atan ( float _X )

inline

Calculates the arctangent of the argument

Parameters

_X	Floating-point value

Returns: Returns the arctangent value of the argument

     {
         return __dp_math_atanf(_X);
     }

double Concurrency::precise_math::atan ( double _X )

inline

Calculates the arctangent of the argument

Parameters

_X	Floating-point value

Returns: Returns the arctangent value of the argument

     {
         return __dp_math_atan(_X);
     }

float Concurrency::precise_math::atan2	(	float	_Y,
		float	_X
	)

inline

Calculates the arctangent of _Y/_X

Parameters

_Y	Floating-point value
_X	Floating-point value

Returns: Returns the arctangent value of _Y/_X

     {
         return __dp_math_atan2f(_Y, _X);
     }

double Concurrency::precise_math::atan2	(	double	_Y,
		double	_X
	)

inline

Calculates the arctangent of _Y/_X

Parameters

_Y	Floating-point value
_X	Floating-point value

Returns: Returns the arctangent value of _Y/_X

     {
         return __dp_math_atan2(_Y, _X);
     }

float Concurrency::precise_math::atan2f	(	float	_Y,
		float	_X
	)

inline

Calculates the arctangent of _Y/_X

Parameters

_Y	Floating-point value
_X	Floating-point value

Returns: Returns the arctangent value of _Y/_X

     {
         return __dp_math_atan2f(_Y, _X);
     }

float Concurrency::precise_math::atanf ( float _X )

inline

Calculates the arctangent of the argument

Parameters

_X	Floating-point value

Returns: Returns the arctangent value of the argument

     {
         return __dp_math_atanf(_X);
     }

float Concurrency::precise_math::atanh ( float _X )

inline

Calculates the inverse hyperbolic tangent of the argument

Parameters

_X	Floating-point value

Returns: Returns the inverse hyperbolic tangent value of the argument

     {
         return __dp_math_atanhf(_X);
     }

double Concurrency::precise_math::atanh ( double _X )

inline

Calculates the inverse hyperbolic tangent of the argument

Parameters

_X	Floating-point value

Returns: Returns the inverse hyperbolic tangent value of the argument

     {
         return __dp_math_atanh(_X);
     }

float Concurrency::precise_math::atanhf ( float _X )

inline

Calculates the inverse hyperbolic tangent of the argument

Parameters

_X	Floating-point value

Returns: Returns the inverse hyperbolic tangent value of the argument

     {
         return __dp_math_atanhf(_X);
     }

float Concurrency::precise_math::cbrt ( float _X )

inline

Computes the real cube root of the argument

Parameters

_X	Floating-point value

Returns: Returns the real cube root of the argument

     {
         return __dp_math_cbrtf(_X);
     }

double Concurrency::precise_math::cbrt ( double _X )

inline

Computes the real cube root of the argument

Parameters

_X	Floating-point value

Returns: Returns the real cube root of the argument

     {
         return __dp_math_cbrt(_X);
     }

float Concurrency::precise_math::cbrtf ( float _X )

inline

Computes the real cube root of the argument

Parameters

_X	Floating-point value

Returns: Returns the real cube root of the argument

     {
         return __dp_math_cbrtf(_X);
     }

float Concurrency::precise_math::ceil ( float _X )

inline

Calculates the ceiling of the argument

Parameters

_X	Floating-point value

Returns: Returns the ceiling of the argument

     {
         return __dp_math_ceilf(_X);
     }

double Concurrency::precise_math::ceil ( double _X )

inline

Calculates the ceiling of the argument

Parameters

_X	Floating-point value

Returns: Returns the ceiling of the argument

     {
         return __dp_math_ceil(_X);
     }

float Concurrency::precise_math::ceilf ( float _X )

inline

Calculates the ceiling of the argument

Parameters

_X	Floating-point value

Returns: Returns the ceiling of the argument

     {
         return __dp_math_ceilf(_X);
     }

float Concurrency::precise_math::copysign	(	float	_X,
		float	_Y
	)

inline

Produces a value with the magnitude of _X and the sign of _Y

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returns a value with the magnitude of _X and the sign of _Y

     {
         return __dp_math_copysignf(_X, _Y);
     }

double Concurrency::precise_math::copysign	(	double	_X,
		double	_Y
	)

inline

Produces a value with the magnitude of _X and the sign of _Y

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returns a value with the magnitude of _X and the sign of _Y

     {
         return __dp_math_copysign(_X, _Y);
     }

float Concurrency::precise_math::copysignf	(	float	_X,
		float	_Y
	)

inline

Produces a value with the magnitude of _X and the sign of _Y

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returns a value with the magnitude of _X and the sign of _Y

     {
         return __dp_math_copysignf(_X, _Y);
     }

float Concurrency::precise_math::cos ( float _X )

inline

Calculates the cosine of the argument

Parameters

_X	Floating-point value

Returns: Returns the cosine value of the argument

     {
         return __dp_math_cosf(_X);
     }

double Concurrency::precise_math::cos ( double _X )

inline

Calculates the cosine of the argument

Parameters

_X	Floating-point value

Returns: Returns the cosine value of the argument

     {
         return __dp_math_cos(_X);
     }

float Concurrency::precise_math::cosf ( float _X )

inline

Calculates the cosine of the argument

Parameters

_X	Floating-point value

Returns: Returns the cosine value of the argument

     {
         return __dp_math_cosf(_X);
     }

float Concurrency::precise_math::cosh ( float _X )

inline

Calculates the hyperbolic cosine value of the argument

Parameters

_X	Floating-point value

Returns: Returns the hyperbolic cosine value of the argument

     {
         return __dp_math_coshf(_X);
     }

double Concurrency::precise_math::cosh ( double _X )

inline

Calculates the hyperbolic cosine value of the argument

Parameters

_X	Floating-point value

Returns: Returns the hyperbolic cosine value of the argument

     {
         return __dp_math_cosh(_X);
     }

float Concurrency::precise_math::coshf ( float _X )

inline

Calculates the hyperbolic cosine value of the argument

Parameters

_X	Floating-point value

Returns: Returns the hyperbolic cosine value of the argument

     {
         return __dp_math_coshf(_X);
     }

float Concurrency::precise_math::cospi ( float _X )

inline

Calculates the cosine value of pi * _X

Parameters

_X	Floating-point value

Returns: Returns the cosine value of pi * _X

     {
         return __dp_math_cospif(_X);
     }

double Concurrency::precise_math::cospi ( double _X )

inline

Calculates the cosine value of pi * _X

Parameters

_X	Floating-point value

Returns: Returns the cosine value of pi * _X

     {
         return __dp_math_cospi(_X);
     }

float Concurrency::precise_math::cospif ( float _X )

inline

Calculates the cosine value of pi * _X

Parameters

_X	Floating-point value

Returns: Returns the cosine value of pi * _X

     {
         return __dp_math_cospif(_X);
     }

float Concurrency::precise_math::erf ( float _X )

inline

Computes the error function of _X

Parameters

_X	Floating-point value

Returns: Returns the error function of _X

     {
         return __dp_math_erff(_X);
     }

double Concurrency::precise_math::erf ( double _X )

inline

Computes the error function of _X

Parameters

_X	Floating-point value

Returns: Returns the error function of _X

     {
         return __dp_math_erf(_X);
     }

float Concurrency::precise_math::erfc ( float _X )

inline

Computes the complementary error function of _X

Parameters

_X	Floating-point value

Returns: Returns the complementary error function of _X

     {
         return __dp_math_erfcf(_X);
     }

double Concurrency::precise_math::erfc ( double _X )

inline

Computes the complementary error function of _X

Parameters

_X	Floating-point value

Returns: Returns the complementary error function of _X

     {
         return __dp_math_erfc(_X);
     }

float Concurrency::precise_math::erfcf ( float _X )

inline

Computes the complementary error function of _X

Parameters

_X	Floating-point value

Returns: Returns the complementary error function of _X

     {
         return __dp_math_erfcf(_X);
     }

float Concurrency::precise_math::erfcinv ( float _X )

inline

Computes the inverse complementary error function of _X

Parameters

_X	Floating-point value

Returns: Returns the inverse complementary error function of _X

     {
         return __dp_math_erfcinvf(_X);
     }

double Concurrency::precise_math::erfcinv ( double _X )

inline

Computes the inverse complementary error function of _X

Parameters

_X	Floating-point value

Returns: Returns the inverse complementary error function of _X

     {
         return __dp_math_erfcinv(_X);
     }

float Concurrency::precise_math::erfcinvf ( float _X )

inline

Computes the inverse complementary error function of _X

Parameters

_X	Floating-point value

Returns: Returns the inverse complementary error function of _X

     {
         return __dp_math_erfcinvf(_X);
     }

float Concurrency::precise_math::erff ( float _X )

inline

Computes the error function of _X

Parameters

_X	Floating-point value

Returns: Returns the error function of _X

     {
         return __dp_math_erff(_X);
     }

float Concurrency::precise_math::erfinv ( float _X )

inline

Computes the inverse error function of _X

Parameters

_X	Floating-point value

Returns: Returns the inverse error function of _X

     {
         return __dp_math_erfinvf(_X);
     }

double Concurrency::precise_math::erfinv ( double _X )

inline

Computes the inverse error function of _X

Parameters

_X	Floating-point value

Returns: Returns the inverse error function of _X

     {
         return __dp_math_erfinv(_X);
     }

float Concurrency::precise_math::erfinvf ( float _X )

inline

Computes the inverse error function of _X

Parameters

_X	Floating-point value

Returns: Returns the inverse error function of _X

     {
         return __dp_math_erfinvf(_X);
     }

float Concurrency::precise_math::exp ( float _X )

inline

Calculates the base-e exponential of the argument

Parameters

_X	Floating-point value

Returns: Returns the base-e exponential of the argument

     {
         return __dp_math_expf(_X);
     }

double Concurrency::precise_math::exp ( double _X )

inline

Calculates the base-e exponential of the argument

Parameters

_X	Floating-point value

Returns: Returns the base-e exponential of the argument

     {
         return __dp_math_exp(_X);
     }

float Concurrency::precise_math::exp10 ( float _X )

inline

Calculates the base-10 exponential of the argument

Parameters

_X	Floating-point value

Returns: Returns the base-10 exponential of the argument

     {
         return __dp_math_exp10f(_X);
     }

double Concurrency::precise_math::exp10 ( double _X )

inline

Calculates the base-10 exponential of the argument

Parameters

_X	Floating-point value

Returns: Returns the base-10 exponential of the argument

     {
         return __dp_math_exp10(_X);
     }

float Concurrency::precise_math::exp10f ( float _X )

inline

Calculates the base-10 exponential of the argument

Parameters

_X	Floating-point value

Returns: Returns the base-10 exponential of the argument

     {
         return __dp_math_exp10f(_X);
     }

float Concurrency::precise_math::exp2 ( float _X )

inline

Calculates the base-2 exponential of the argument

Parameters

_X	Floating-point value

Returns: Returns the base-2 exponential of the argument

     {
         return __dp_math_exp2f(_X);
     }

double Concurrency::precise_math::exp2 ( double _X )

inline

Calculates the base-2 exponential of the argument

Parameters

_X	Floating-point value

Returns: Returns the base-2 exponential of the argument

     {
         return __dp_math_exp2(_X);
     }

float Concurrency::precise_math::exp2f ( float _X )

inline

Calculates the base-2 exponential of the argument

Parameters

_X	Floating-point value

Returns: Returns the base-2 exponential of the argument

     {
         return __dp_math_exp2f(_X);
     }

float Concurrency::precise_math::expf ( float _X )

inline

Calculates the base-e exponential of the argument

Parameters

_X	Floating-point value

Returns: Returns the base-e exponential of the argument

     {
         return __dp_math_expf(_X);
     }

float Concurrency::precise_math::expm1 ( float _X )

inline

Calculates the base-e exponential of the argument, minus 1

Parameters

_X	Floating-point value

Returns: Returns the base-e exponential of the argument, minus 1

     {
         return __dp_math_expm1f(_X);
     }

double Concurrency::precise_math::expm1 ( double _X )

inline

Calculates the base-e exponential of the argument, minus 1

Parameters

_X	Floating-point value

Returns: Returns the base-e exponential of the argument, minus 1

     {
         return __dp_math_expm1(_X);
     }

float Concurrency::precise_math::expm1f ( float _X )

inline

Calculates the base-e exponential of the argument, minus 1

Parameters

_X	Floating-point value

Returns: Returns the base-e exponential of the argument, minus 1

     {
         return __dp_math_expm1f(_X);
     }

float Concurrency::precise_math::fabs ( float _X )

inline

Returns the absolute value of the argument

Parameters

_X	Floating-point value

Returns: Returns the absolute value of the argument

     {
         return __dp_math_fabsf(_X);
     }

double Concurrency::precise_math::fabs ( double _X )

inline

Returns the absolute value of the argument

Parameters

_X	Floating-point value

Returns: Returns the absolute value of the argument

     {
         return __dp_math_fabs(_X);
     }

float Concurrency::precise_math::fabsf ( float _X )

inline

Returns the absolute value of the argument

Parameters

_X	Floating-point value

Returns: Returns the absolute value of the argument

     {
         return __dp_math_fabsf(_X);
     }

float Concurrency::precise_math::fdim	(	float	_X,
		float	_Y
	)

inline

Determines the positive difference between the arguments

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returns _X - _Y if _X > _Y; +0, otherwise

     {
         return __dp_math_fdimf(_X, _Y);
     }

double Concurrency::precise_math::fdim	(	double	_X,
		double	_Y
	)

inline

Determines the positive difference between the arguments

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returns _X - _Y if _X > _Y; +0, otherwise

     {
         return __dp_math_fdim(_X, _Y);
     }

float Concurrency::precise_math::fdimf	(	float	_X,
		float	_Y
	)

inline

Determines the positive difference between the arguments

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returns _X - _Y if _X > _Y; +0, otherwise

     {
         return __dp_math_fdimf(_X, _Y);
     }

float Concurrency::precise_math::floor ( float _X )

inline

Calculates the floor of the argument

Parameters

_X	Floating-point value

Returns: Returns the floor of the argument

     {
         return __dp_math_floorf(_X);
     }

double Concurrency::precise_math::floor ( double _X )

inline

Calculates the floor of the argument

Parameters

_X	Floating-point value

Returns: Returns the floor of the argument

     {
         return __dp_math_floor(_X);
     }

float Concurrency::precise_math::floorf ( float _X )

inline

Calculates the floor of the argument

Parameters

_X	Floating-point value

Returns: Returns the floor of the argument

     {
         return __dp_math_floorf(_X);
     }

float Concurrency::precise_math::fma	(	float	_X,
		float	_Y,
		float	_Z
	)

inline

Compute (_X * _Y) + _Z, rounded as one ternary operation

Parameters

_X	Floating-point value
_Y	Floating-point value
_Z	Floating-point value

Returns: Returns (_X * _Y) + _Z, rounded as one ternary operation

     {
         return __dp_math_fmaf(_X, _Y, _Z);
     }

double Concurrency::precise_math::fma	(	double	_X,
		double	_Y,
		double	_Z
	)

inline

Compute (_X * _Y) + _Z, rounded as one ternary operation

Parameters

_X	Floating-point value
_Y	Floating-point value
_Z	Floating-point value

Returns: Returns (_X * _Y) + _Z, rounded as one ternary operation

     {
         return __dp_math_fma(_X, _Y, _Z);
     }

float Concurrency::precise_math::fmaf	(	float	_X,
		float	_Y,
		float	_Z
	)

inline

Compute (_X * _Y) + _Z, rounded as one ternary operation

Parameters

_X	Floating-point value
_Y	Floating-point value
_Z	Floating-point value

Returns: Returns (_X * _Y) + _Z, rounded as one ternary operation

     {
         return __dp_math_fmaf(_X, _Y, _Z);
     }

float Concurrency::precise_math::fmax	(	float	_X,
		float	_Y
	)

inline

Determine the maximum numeric value of the arguments

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Return the maximum numeric value of the arguments

     {
         return __dp_math_fmaxf(_X, _Y);
     }

double Concurrency::precise_math::fmax	(	double	_X,
		double	_Y
	)

inline

Determine the maximum numeric value of the arguments

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Return the maximum numeric value of the arguments

     {
         return __dp_math_fmax(_X, _Y);
     }

float Concurrency::precise_math::fmaxf	(	float	_X,
		float	_Y
	)

inline

Determine the maximum numeric value of the arguments

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Return the maximum numeric value of the arguments

     {
         return __dp_math_fmaxf(_X, _Y);
     }

float Concurrency::precise_math::fmin	(	float	_X,
		float	_Y
	)

inline

Determine the minimum numeric value of the arguments

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Return the minimum numeric value of the arguments

     {
         return __dp_math_fminf(_X, _Y);
     }

double Concurrency::precise_math::fmin	(	double	_X,
		double	_Y
	)

inline

Determine the minimum numeric value of the arguments

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Return the minimum numeric value of the arguments

     {
         return __dp_math_fmin(_X, _Y);
     }

float Concurrency::precise_math::fminf	(	float	_X,
		float	_Y
	)

inline

Determine the minimum numeric value of the arguments

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Return the minimum numeric value of the arguments

     {
         return __dp_math_fminf(_X, _Y);
     }

float Concurrency::precise_math::fmod	(	float	_X,
		float	_Y
	)

inline

Calculates the floating-point remainder of _X/_Y

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returns the floating-point remainder of _X/_Y

     {
         return __dp_math_fmodf(_X, _Y);
     }

double Concurrency::precise_math::fmod	(	double	_X,
		double	_Y
	)

inline

Calculates the floating-point remainder of _X/_Y

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returns the floating-point remainder of _X/_Y

     {
         return __dp_math_fmod(_X, _Y);
     }

float Concurrency::precise_math::fmodf	(	float	_X,
		float	_Y
	)

inline

Calculates the floating-point remainder of _X/_Y

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returns the floating-point remainder of _X/_Y

     {
         return __dp_math_fmodf(_X, _Y);
     }

int Concurrency::precise_math::fpclassify ( float _X )

inline

Classifies the argument value as NaN, infinite, normal, subnormal, zero

Parameters

_X	Floating-point value

Returns: Returns the value of the number classification macro appropriate to the value of the argument.

     {
         return __dp_math_fpclassifyf(_X);
     }

int Concurrency::precise_math::fpclassify ( double _X )

inline

Classifies the argument value as NaN, infinite, normal, subnormal, zero

Parameters

_X	Floating-point value

Returns: Returns the value of the number classification macro appropriate to the value of the argument.

     {
         return __dp_math_fpclassify(_X);
     }

float Concurrency::precise_math::frexp	(	float	_X,
		_Out_ int *	_Exp
	)

inline

Gets the mantissa and exponent of _X

Parameters

_X	Floating-point value
_Exp	Returns the integer exponent of _X in floating-point value

Returns: Returns the mantissa _X

     {
         return __dp_math_frexpf(_X, _Exp);
     }

double Concurrency::precise_math::frexp	(	double	_X,
		_Out_ int *	_Exp
	)

inline

Gets the mantissa and exponent of _X

Parameters

_X	Floating-point value
_Exp	Returns the integer exponent of _X in floating-point value

Returns: Returns the mantissa _X

     {
         return __dp_math_frexp(_X, _Exp);
     }

float Concurrency::precise_math::frexpf	(	float	_X,
		_Out_ int *	_Exp
	)

inline

Gets the mantissa and exponent of _X

Parameters

_X	Floating-point value
_Exp	Returns the integer exponent of _X in floating-point value

Returns: Returns the mantissa _X

     {
         return __dp_math_frexpf(_X, _Exp);
     }

float Concurrency::precise_math::hypot	(	float	_X,
		float	_Y
	)

inline

Computes the square root of the sum of the squares of _X and _Y

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returns the square root of the sum of the squares of _X and _Y

     {
         return __dp_math_hypotf(_X, _Y);
     }

double Concurrency::precise_math::hypot	(	double	_X,
		double	_Y
	)

inline

Computes the square root of the sum of the squares of _X and _Y

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returns the square root of the sum of the squares of _X and _Y

     {
         return __dp_math_hypot(_X, _Y);
     }

float Concurrency::precise_math::hypotf	(	float	_X,
		float	_Y
	)

inline

Computes the square root of the sum of the squares of _X and _Y

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returns the square root of the sum of the squares of _X and _Y

     {
         return __dp_math_hypotf(_X, _Y);
     }

int Concurrency::precise_math::ilogb ( float _X )

inline

Extract the exponent of _X as a signed int value

Parameters

_X	Floating-point value

Returns: Returns the exponent of _X as a signed int value

     {
         return __dp_math_ilogbf(_X);
     }

int Concurrency::precise_math::ilogb ( double _X )

inline

Extract the exponent of _X as a signed int value

Parameters

_X	Floating-point value

Returns: Returns the exponent of _X as a signed int value

     {
         return __dp_math_ilogb(_X);
     }

int Concurrency::precise_math::ilogbf ( float _X )

inline

Extract the exponent of _X as a signed int value

Parameters

_X	Floating-point value

Returns: Returns the exponent of _X as a signed int value

     {
         return __dp_math_ilogbf(_X);
     }

int Concurrency::precise_math::isfinite ( float _X )

inline

Determines whether the argument has a finite value

Parameters

_X	Floating-point value

Returns: Returns a nonzero value if and only if the argument has a finite value

     {
         return __dp_math_isfinitef(_X);
     }

int Concurrency::precise_math::isfinite ( double _X )

inline

Determines whether the argument has a finite value

Parameters

_X	Floating-point value

Returns: Returns a nonzero value if and only if the argument has a finite value

     {
         return __dp_math_isfinite(_X);
     }

int Concurrency::precise_math::isinf ( float _X )

inline

Determines whether the argument is an infinity

Parameters

_X	Floating-point value

Returns: Returns a nonzero value if and only if the argument has an infinite value

     {
         return __dp_math_isinff(_X);
     }

int Concurrency::precise_math::isinf ( double _X )

inline

Determines whether the argument is an infinity

Parameters

_X	Floating-point value

Returns: Returns a nonzero value if and only if the argument has an infinite value

     {
         return __dp_math_isinf(_X);
     }

int Concurrency::precise_math::isnan ( float _X )

inline

Determines whether the argument is a NaN

Parameters

_X	Floating-point value

Returns: Returns a nonzero value if and only if the argument has a NaN value

     {
         return __dp_math_isnanf(_X);
     }

int Concurrency::precise_math::isnan ( double _X )

inline

Determines whether the argument is a NaN

Parameters

_X	Floating-point value

Returns: Returns a nonzero value if and only if the argument has a NaN value

     {
         return __dp_math_isnan(_X);
     }

int Concurrency::precise_math::isnormal ( float _X )

inline

Determines whether the argument is a normal

Parameters

_X	Floating-point value

Returns: Returns a nonzero value if and only if the argument has a normal value

     {
         return __dp_math_isnormalf(_X);
     }

int Concurrency::precise_math::isnormal ( double _X )

inline

Determines whether the argument is a normal

Parameters

_X	Floating-point value

Returns: Returns a nonzero value if and only if the argument has a normal value

     {
         return __dp_math_isnormal(_X);
     }

float Concurrency::precise_math::ldexp	(	float	_X,
		int	_Exp
	)

inline

Computes a real number from the mantissa and exponent

Parameters

_X	Floating-point value, mantissa
_Exp	Integer value, exponent

Returns: Returns _X * 2^_Exp

     {
         return __dp_math_ldexpf(_X, _Exp);
     }

double Concurrency::precise_math::ldexp	(	double	_X,
		int	_Exp
	)

inline

Computes a real number from the mantissa and exponent

Parameters

_X	Floating-point value, mantissa
_Exp	Integer value, exponent

Returns: Returns _X * 2^_Exp

     {
         return __dp_math_ldexp(_X, _Exp);
     }

float Concurrency::precise_math::ldexpf	(	float	_X,
		int	_Exp
	)

inline

Computes a real number from the mantissa and exponent

Parameters

_X	Floating-point value, mantissa
_Exp	Integer value, exponent

Returns: Returns _X * 2^_Exp

     {
         return __dp_math_ldexpf(_X, _Exp);
     }

float Concurrency::precise_math::lgamma	(	float	_X,
		_Out_ int *	_Sign
	)

inline

Computes the natural logarithm of the absolute value of gamma of the argument

Parameters

_X	Floating-point value
_Sign	Returns the sign

Returns: Returns the natural logarithm of the absolute value of gamma of the argument

     {
         return __dp_math_lgammaf(_X, _Sign);
     }

double Concurrency::precise_math::lgamma	(	double	_X,
		_Out_ int *	_Sign
	)

inline

Computes the natural logarithm of the absolute value of gamma of the argument

Parameters

_X	Floating-point value
_Sign	Returns the sign

Returns: Returns the natural logarithm of the absolute value of gamma of the argument

     {
         return __dp_math_lgamma(_X, _Sign);
     }

float Concurrency::precise_math::lgammaf	(	float	_X,
		_Out_ int *	_Sign
	)

inline

Computes the natural logarithm of the absolute value of gamma of the argument

Parameters

_X	Floating-point value
_Sign	Returns the sign

Returns: Returns the natural logarithm of the absolute value of gamma of the argument

     {
         return __dp_math_lgammaf(_X, _Sign);
     }

float Concurrency::precise_math::log ( float _X )

inline

Calculates the base-e logarithm of the argument

Parameters

_X	Floating-point value

Returns: Returns the base-e logarithm of the argument

     {
         return __dp_math_logf(_X);
     }

double Concurrency::precise_math::log ( double _X )

inline

Calculates the base-e logarithm of the argument

Parameters

_X	Floating-point value

Returns: Returns the base-e logarithm of the argument

     {
         return __dp_math_log(_X);
     }

float Concurrency::precise_math::log10 ( float _X )

inline

Calculates the base-10 logarithm of the argument

Parameters

_X	Floating-point value

Returns: Returns the base-10 logarithm of the argument

     {
         return __dp_math_log10f(_X);
     }

double Concurrency::precise_math::log10 ( double _X )

inline

Calculates the base-10 logarithm of the argument

Parameters

_X	Floating-point value

Returns: Returns the base-10 logarithm of the argument

     {
         return __dp_math_log10(_X);
     }

float Concurrency::precise_math::log10f ( float _X )

inline

Calculates the base-10 logarithm of the argument

Parameters

_X	Floating-point value

Returns: Returns the base-10 logarithm of the argument

     {
         return __dp_math_log10f(_X);
     }

float Concurrency::precise_math::log1p ( float _X )

inline

Calculates the base-e logarithm of 1 plus the argument

Parameters

_X	Floating-point value

Returns: Returns the base-e logarithm of 1 plus the argument

     {
         return __dp_math_log1pf(_X);
     }

double Concurrency::precise_math::log1p ( double _X )

inline

Calculates the base-e logarithm of 1 plus the argument

Parameters

_X	Floating-point value

Returns: Returns the base-e logarithm of 1 plus the argument

     {
         return __dp_math_log1p(_X);
     }

float Concurrency::precise_math::log1pf ( float _X )

inline

Calculates the base-e logarithm of 1 plus the argument

Parameters

_X	Floating-point value

Returns: Returns the base-e logarithm of 1 plus the argument

     {
         return __dp_math_log1pf(_X);
     }

float Concurrency::precise_math::log2 ( float _X )

inline

Calculates the base-2 logarithm of the argument

Parameters

_X	Floating-point value

Returns: Returns the base-10 logarithm of the argument

     {
         return __dp_math_log2f(_X);
     }

double Concurrency::precise_math::log2 ( double _X )

inline

Calculates the base-2 logarithm of the argument

Parameters

_X	Floating-point value

Returns: Returns the base-10 logarithm of the argument

     {
         return __dp_math_log2(_X);
     }

float Concurrency::precise_math::log2f ( float _X )

inline

Calculates the base-2 logarithm of the argument

Parameters

_X	Floating-point value

Returns: Returns the base-10 logarithm of the argument

     {
         return __dp_math_log2f(_X);
     }

float Concurrency::precise_math::logb ( float _X )

inline

Extracts the exponent of _X, as a signed integer value in floating-point format

Parameters

_X	Floating-point value

Returns: Returns the signed exponent of _X

     {
         return __dp_math_logbf(_X);
     }

double Concurrency::precise_math::logb ( double _X )

inline

Extracts the exponent of _X, as a signed integer value in floating-point format

Parameters

_X	Floating-point value

Returns: Returns the signed exponent of _X

     {
         return __dp_math_logb(_X);
     }

float Concurrency::precise_math::logbf ( float _X )

inline

Extracts the exponent of _X, as a signed integer value in floating-point format

Parameters

_X	Floating-point value

Returns: Returns the signed exponent of _X

     {
         return __dp_math_logbf(_X);
     }

float Concurrency::precise_math::logf ( float _X )

inline

Calculates the base-e logarithm of the argument

Parameters

_X	Floating-point value

Returns: Returns the base-e logarithm of the argument

     {
         return __dp_math_logf(_X);
     }

float Concurrency::precise_math::modf	(	float	_X,
		_Out_ float *	_Iptr
	)

inline

Splits _X into fractional and integer parts.

Parameters

_X	Floating-point value
_Iptr	Returns the integer portion of _X in floating-point value

Returns: Returns the signed fractional portion of _X

     {
         return __dp_math_modff(_X, _Iptr);
     }

double Concurrency::precise_math::modf	(	double	_X,
		_Out_ double *	_Iptr
	)

inline

Splits _X into fractional and integer parts.

Parameters

_X	Floating-point value
_Iptr	Returns the integer portion of _X in floating-point value

Returns: Returns the signed fractional portion of _X

     {
         return __dp_math_modf(_X, _Iptr);
     }

float Concurrency::precise_math::modff	(	float	_X,
		_Out_ float *	_Iptr
	)

inline

Splits _X into fractional and integer parts.

Parameters

_X	Floating-point value
_Iptr	Returns the integer portion of _X in floating-point value

Returns: Returns the signed fractional portion of _X

     {
         return __dp_math_modff(_X, _Iptr);
     }

double Concurrency::precise_math::nan ( int _X )

inline

Returns a quiet NaN

Parameters

_X	Integer value

Returns: Returns a quiet NaN, if available, with the content indicated in _X

     {
         return __dp_math_nan(_X);
     }

float Concurrency::precise_math::nanf ( int _X )

inline

Returns a quiet NaN

Parameters

_X	Integer value

Returns: Returns a quiet NaN, if available, with the content indicated in _X

     {
         return __dp_math_nanf(_X);
     }

float Concurrency::precise_math::nearbyint ( float _X )

inline

Rounds the argument to an integer value in floating-point format, using the current rounding direction.

Parameters

_X	Floating-point value

Returns: Returns the rounded integer value.

     {
         return __dp_math_nearbyintf(_X);
     }

double Concurrency::precise_math::nearbyint ( double _X )

inline

Rounds the argument to an integer value in floating-point format, using the current rounding direction.

Parameters

_X	Floating-point value

Returns: Returns the rounded integer value.

     {
         return __dp_math_nearbyint(_X);
     }

float Concurrency::precise_math::nearbyintf ( float _X )

inline

Rounds the argument to an integer value in floating-point format, using the current rounding direction.

Parameters

_X	Floating-point value

Returns: Returns the rounded integer value.

     {
         return __dp_math_nearbyintf(_X);
     }

float Concurrency::precise_math::nextafter	(	float	_X,
		float	_Y
	)

inline

Determine the next representable value, in the type of the function, after _X in the direction of _Y

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returnsthe the next representable value, in the type of the function, after _X in the direction of _Y

     {
         return __dp_math_nextafterf(_X, _Y);
     }

double Concurrency::precise_math::nextafter	(	double	_X,
		double	_Y
	)

inline

Determine the next representable value, in the type of the function, after _X in the direction of _Y

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returnsthe the next representable value, in the type of the function, after _X in the direction of _Y

     {
         return __dp_math_nextafter(_X, _Y);
     }

float Concurrency::precise_math::nextafterf	(	float	_X,
		float	_Y
	)

inline

Determine the next representable value, in the type of the function, after _X in the direction of _Y

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returnsthe the next representable value, in the type of the function, after _X in the direction of _Y

     {
         return __dp_math_nextafterf(_X, _Y);
     }

float Concurrency::precise_math::phi ( float _X )

inline

Returns the cumulative distribution function of the argument

Parameters

_X	Floating-point value

Returns: Returns the cumulative distribution function of the argument

     {
         return __dp_math_phif(_X);
     }

double Concurrency::precise_math::phi ( double _X )

inline

Returns the cumulative distribution function of the argument

Parameters

_X	Floating-point value

Returns: Returns the cumulative distribution function of the argument

     {
         return __dp_math_phi(_X);
     }

float Concurrency::precise_math::phif ( float _X )

inline

Returns the cumulative distribution function of the argument

Parameters

_X	Floating-point value

Returns: Returns the cumulative distribution function of the argument

     {
         return __dp_math_phif(_X);
     }

float Concurrency::precise_math::pow	(	float	_X,
		float	_Y
	)

inline

Calculates _X raised to the power of _Y

Parameters

_X	Floating-point value, base
_Y	Floating-point value, exponent

Returns: Returns the value of _X raised to the power of _Y

     {
         return __dp_math_powf(_X, _Y);
     }

double Concurrency::precise_math::pow	(	double	_X,
		double	_Y
	)

inline

Calculates _X raised to the power of _Y

Parameters

_X	Floating-point value, base
_Y	Floating-point value, exponent

Returns: Returns the value of _X raised to the power of _Y

     {
         return __dp_math_pow(_X, _Y);
     }

float Concurrency::precise_math::powf	(	float	_X,
		float	_Y
	)

inline

Calculates _X raised to the power of _Y

Parameters

_X	Floating-point value, base
_Y	Floating-point value, exponent

Returns: Returns the value of _X raised to the power of _Y

     {
         return __dp_math_powf(_X, _Y);
     }

float Concurrency::precise_math::probit ( float _X )

inline

Returns the inverse cumulative distribution function of the argument

Parameters

_X	Floating-point value

Returns: Returns the inverse cumulative distribution function of the argument

     {
         return __dp_math_probitf(_X);
     }

double Concurrency::precise_math::probit ( double _X )

inline

Returns the inverse cumulative distribution function of the argument

Parameters

_X	Floating-point value

Returns: Returns the inverse cumulative distribution function of the argument

     {
         return __dp_math_probit(_X);
     }

float Concurrency::precise_math::probitf ( float _X )

inline

Returns the inverse cumulative distribution function of the argument

Parameters

_X	Floating-point value

Returns: Returns the inverse cumulative distribution function of the argument

     {
         return __dp_math_probitf(_X);
     }

float Concurrency::precise_math::rcbrt ( float _X )

inline

Returns the reciprocal of the cube root of the argument

Parameters

_X	Floating-point value

Returns: Returns the reciprocal of the cube root of the argument

     {
         return __dp_math_rcbrtf(_X);
     }

double Concurrency::precise_math::rcbrt ( double _X )

inline

Returns the reciprocal of the cube root of the argument

Parameters

_X	Floating-point value

Returns: Returns the reciprocal of the cube root of the argument

     {
         return __dp_math_rcbrt(_X);
     }

float Concurrency::precise_math::rcbrtf ( float _X )

inline

Returns the reciprocal of the cube root of the argument

Parameters

_X	Floating-point value

Returns: Returns the reciprocal of the cube root of the argument

     {
         return __dp_math_rcbrtf(_X);
     }

float Concurrency::precise_math::remainder	(	float	_X,
		float	_Y
	)

inline

Computes the remainder: _X REM _Y

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returns _X REM _Y

     {
         return __dp_math_remainderf(_X, _Y);
     }

double Concurrency::precise_math::remainder	(	double	_X,
		double	_Y
	)

inline

Computes the remainder: _X REM _Y

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returns _X REM _Y

     {
         return __dp_math_remainder(_X, _Y);
     }

float Concurrency::precise_math::remainderf	(	float	_X,
		float	_Y
	)

inline

Computes the remainder: _X REM _Y

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returns _X REM _Y

     {
         return __dp_math_remainderf(_X, _Y);
     }

float Concurrency::precise_math::remquo	(	float	_X,
		float	_Y,
		_Out_ int *	_Quo
	)

inline

Computes the same remainder as _X REM _Y. Also calculates the lower 24 bits of the integral quotient _X/_Y, and gives that value the same sign as _X/_Y. It stores this signed value in the integer pointed to by _Quo.

Parameters

_X	Floating-point value
_Y	Floating-point value
_Quo	Pointer to an integer value

Returns: Returns the remainder

     {
         return __dp_math_remquof(_X, _Y, _Quo);
     }

double Concurrency::precise_math::remquo	(	double	_X,
		double	_Y,
		_Out_ int *	_Quo
	)

inline

Computes the same remainder as _X REM _Y. Also calculates the lower 31 bits of the integral quotient _X/_Y, and gives that value the same sign as _X/_Y. It stores this signed value in the integer pointed to by _Quo.

Parameters

_X	Floating-point value
_Y	Floating-point value
_Quo	Pointer to an integer value

Returns: Returns the remainder

     {
         return __dp_math_remquo(_X, _Y, _Quo);
     }

float Concurrency::precise_math::remquof	(	float	_X,
		float	_Y,
		_Out_ int *	_Quo
	)

inline

Computes the same remainder as _X REM _Y. Also calculates the lower 24 bits of the integral quotient _X/_Y, and gives that value the same sign as _X/_Y. It stores this signed value in the integer pointed to by _Quo.

Parameters

_X	Floating-point value
_Y	Floating-point value
_Quo	Pointer to an integer value

Returns: Returns the remainder

     {
         return __dp_math_remquof(_X, _Y, _Quo);
     }

float Concurrency::precise_math::round ( float _X )

inline

Rounds _X to the nearest integer

Parameters

_X	Floating-point value

Returns: Returns the nearest integer of _X

     {
         return __dp_math_roundf(_X);
     }

double Concurrency::precise_math::round ( double _X )

inline

Rounds _X to the nearest integer

Parameters

_X	Floating-point value

Returns: Returns the nearest integer of _X

     {
         return __dp_math_round(_X);
     }

float Concurrency::precise_math::roundf ( float _X )

inline

Rounds _X to the nearest integer

Parameters

_X	Floating-point value

Returns: Returns the nearest integer of _X

     {
         return __dp_math_roundf(_X);
     }

float Concurrency::precise_math::rsqrt ( float _X )

inline

Returns the reciprocal of the square root of the argument

Parameters

_X	Floating-point value

Returns: Returns the reciprocal of the square root of the argument

     {
         return __dp_math_rsqrtf(_X);
     }

double Concurrency::precise_math::rsqrt ( double _X )

inline

Returns the reciprocal of the square root of the argument

Parameters

_X	Floating-point value

Returns: Returns the reciprocal of the square root of the argument

     {
         return __dp_math_rsqrt(_X);
     }

float Concurrency::precise_math::rsqrtf ( float _X )

inline

Returns the reciprocal of the square root of the argument

Parameters

_X	Floating-point value

Returns: Returns the reciprocal of the square root of the argument

     {
         return __dp_math_rsqrtf(_X);
     }

float Concurrency::precise_math::scalb	(	float	_X,
		float	_Y
	)

inline

Multiplies _X by FLT_RADIX to the power _Y

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returns _X * (FLT_RADIX ^ _Y)

     {
         return __dp_math_scalbf(_X, _Y);
     }

double Concurrency::precise_math::scalb	(	double	_X,
		double	_Y
	)

inline

Multiplies _X by FLT_RADIX to the power _Y

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returns _X * (FLT_RADIX ^ _Y)

     {
         return __dp_math_scalb(_X, _Y);
     }

float Concurrency::precise_math::scalbf	(	float	_X,
		float	_Y
	)

inline

Multiplies _X by FLT_RADIX to the power _Y

Parameters

_X	Floating-point value
_Y	Floating-point value

Returns: Returns _X * (FLT_RADIX ^ _Y)

     {
         return __dp_math_scalbf(_X, _Y);
     }

float Concurrency::precise_math::scalbn	(	float	_X,
		int	_Y
	)

inline

Multiplies _X by FLT_RADIX to the power _Y

Parameters

_X	Floating-point value
_Y	Integer value

Returns: Returns _X * (FLT_RADIX ^ _Y)

     {
         return __dp_math_scalbnf(_X, _Y);
     }

double Concurrency::precise_math::scalbn	(	double	_X,
		int	_Y
	)

inline

Multiplies _X by FLT_RADIX to the power _Y

Parameters

_X	Floating-point value
_Y	Integer value

Returns: Returns _X * (FLT_RADIX ^ _Y)

     {
         return __dp_math_scalbn(_X, _Y);
     }

float Concurrency::precise_math::scalbnf	(	float	_X,
		int	_Y
	)

inline

Multiplies _X by FLT_RADIX to the power _Y

Parameters

_X	Floating-point value
_Y	Integer value

Returns: Returns _X * (FLT_RADIX ^ _Y)

     {
         return __dp_math_scalbnf(_X, _Y);
     }

int Concurrency::precise_math::signbit ( float _X )

inline

Determines whether the sign of _X is negative

Parameters

_X	Floating-point value

Returns: Returns a nonzero value if and only if the sign of _X is negative

     {
         return __dp_math_signbitf(_X);
     }

int Concurrency::precise_math::signbit ( double _X )

inline

Determines whether the sign of _X is negative

Parameters

_X	Floating-point value

Returns: Returns a nonzero value if and only if the sign of _X is negative

     {
         return __dp_math_signbit(_X);
     }

int Concurrency::precise_math::signbitf ( float _X )

inline

Determines whether the sign of _X is negative

Parameters

_X	Floating-point value

Returns: Returns a nonzero value if and only if the sign of _X is negative

     {
         return __dp_math_signbitf(_X);
     }

float Concurrency::precise_math::sin ( float _X )

inline

Calculates the sine value of the argument

Parameters

_X	Floating-point value

Returns: Returns the sine value of the argument

     {
         return __dp_math_sinf(_X);
     }

double Concurrency::precise_math::sin ( double _X )

inline

Calculates the sine value of the argument

Parameters

_X	Floating-point value

Returns: Returns the sine value of the argument

     {
         return __dp_math_sin(_X);
     }

void Concurrency::precise_math::sincos	(	float	_X,
		_Out_ float *	_S,
		_Out_ float *	_C
	)

inline

Calculates sine and cosine value of _X

Parameters

_X	Floating-point value
_S	Returns the sine value of _X
_C	Returns the cosine value of _X

     {
         *_C = __dp_math_sincosf(_X, _S);
     }

void Concurrency::precise_math::sincos	(	double	_X,
		_Out_ double *	_S,
		_Out_ double *	_C
	)

inline

Calculates sine and cosine value of _X

Parameters

_X	Floating-point value
_S	Returns the sine value of _X
_C	Returns the cosine value of _X

     {
         *_C = __dp_math_sincos(_X, _S);
     }

void Concurrency::precise_math::sincosf	(	float	_X,
		_Out_ float *	_S,
		_Out_ float *	_C
	)

inline

Calculates sine and cosine value of _X

Parameters

_X	Floating-point value
_S	Returns the sine value of _X
_C	Returns the cosine value of _X

     {
         *_C = __dp_math_sincosf(_X, _S);
     }

float Concurrency::precise_math::sinf ( float _X )

inline

Calculates the sine value of the argument

Parameters

_X	Floating-point value

Returns: Returns the sine value of the argument

     {
         return __dp_math_sinf(_X);
     }

float Concurrency::precise_math::sinh ( float _X )

inline

Calculates the hyperbolic sine value of the argument

Parameters

_X	Floating-point value

Returns: Returns the hyperbolic sine value of the argument

     {
         return __dp_math_sinhf(_X);
     }

double Concurrency::precise_math::sinh ( double _X )

inline

Calculates the hyperbolic sine value of the argument

Parameters

_X	Floating-point value

Returns: Returns the hyperbolic sine value of the argument

     {
         return __dp_math_sinh(_X);
     }

float Concurrency::precise_math::sinhf ( float _X )

inline

Calculates the hyperbolic sine value of the argument

Parameters

_X	Floating-point value

Returns: Returns the hyperbolic sine value of the argument

     {
         return __dp_math_sinhf(_X);
     }

float Concurrency::precise_math::sinpi ( float _X )

inline

Calculates the sine value of pi * _X

Parameters

_X	Floating-point value

Returns: Returns the sine value of pi * _X

     {
         return __dp_math_sinpif(_X);
     }

double Concurrency::precise_math::sinpi ( double _X )

inline

Calculates the sine value of pi * _X

Parameters

_X	Floating-point value

Returns: Returns the sine value of pi * _X

     {
         return __dp_math_sinpi(_X);
     }

float Concurrency::precise_math::sinpif ( float _X )

inline

Calculates the sine value of pi * _X

Parameters

_X	Floating-point value

Returns: Returns the sine value of pi * _X

     {
         return __dp_math_sinpif(_X);
     }

float Concurrency::precise_math::sqrt ( float _X )

inline

Calculates the squre root of the argument

Parameters

_X	Floating-point value

Returns: Returns the squre root of the argument

     {
         return __dp_math_sqrtf(_X);
     }

double Concurrency::precise_math::sqrt ( double _X )

inline

Calculates the squre root of the argument

Parameters

_X	Floating-point value

Returns: Returns the squre root of the argument

     {
         return __dp_math_sqrt(_X);
     }

float Concurrency::precise_math::sqrtf ( float _X )

inline

Calculates the squre root of the argument

Parameters

_X	Floating-point value

Returns: Returns the squre root of the argument

     {
         return __dp_math_sqrtf(_X);
     }

float Concurrency::precise_math::tan ( float _X )

inline

Calculates the tangent value of the argument

Parameters

_X	Floating-point value

Returns: Returns the tangent value of the argument

     {
         return __dp_math_tanf(_X);
     }

double Concurrency::precise_math::tan ( double _X )

inline

Calculates the tangent value of the argument

Parameters

_X	Floating-point value

Returns: Returns the tangent value of the argument

     {
         return __dp_math_tan(_X);
     }

float Concurrency::precise_math::tanf ( float _X )

inline

Calculates the tangent value of the argument

Parameters

_X	Floating-point value

Returns: Returns the tangent value of the argument

     {
         return __dp_math_tanf(_X);
     }

float Concurrency::precise_math::tanh ( float _X )

inline

Calculates the hyperbolic tangent value of the argument

Parameters

_X	Floating-point value

Returns: Returns the hyperbolic tangent value of the argument

     {
         return __dp_math_tanhf(_X);
     }

double Concurrency::precise_math::tanh ( double _X )

inline

Calculates the hyperbolic tangent value of the argument

Parameters

_X	Floating-point value

Returns: Returns the hyperbolic tangent value of the argument

     {
         return __dp_math_tanh(_X);
     }

float Concurrency::precise_math::tanhf ( float _X )

inline

Calculates the hyperbolic tangent value of the argument

Parameters

_X	Floating-point value

Returns: Returns the hyperbolic tangent value of the argument

     {
         return __dp_math_tanhf(_X);
     }

float Concurrency::precise_math::tanpi ( float _X )

inline

Calculates the tangent value of pi * _X

Parameters

_X	Floating-point value

Returns: Returns the tangent value of pi * _X

     {
         return __dp_math_tanpif(_X);
     }

double Concurrency::precise_math::tanpi ( double _X )

inline

Calculates the tangent value of pi * _X

Parameters

_X	Floating-point value

Returns: Returns the tangent value of pi * _X

     {
         return __dp_math_tanpi(_X);
     }

float Concurrency::precise_math::tanpif ( float _X )

inline

Calculates the tangent value of pi * _X

Parameters

_X	Floating-point value

Returns: Returns the tangent value of pi * _X

     {
         return __dp_math_tanpif(_X);
     }

float Concurrency::precise_math::tgamma ( float _X )

inline

Computes the gamma function of _X

Parameters

_X	Floating-point value

Returns: Returns the result of gamma function of _X

     {
         return __dp_math_tgammaf(_X);
     }

double Concurrency::precise_math::tgamma ( double _X )

inline

Computes the gamma function of _X

Parameters

_X	Floating-point value

Returns: Returns the result of gamma function of _X

     {
         return __dp_math_tgamma(_X);
     }

float Concurrency::precise_math::tgammaf ( float _X )

inline

Computes the gamma function of _X

Parameters

_X	Floating-point value

Returns: Returns the result of gamma function of _X

     {
         return __dp_math_tgammaf(_X);
     }

float Concurrency::precise_math::trunc ( float _X )

inline

Truncates the argument to the integer component

Parameters

_X	Floating-point value

Returns: Returns the integer component of the argument

     {
         return __dp_math_truncf(_X);
     }

double Concurrency::precise_math::trunc ( double _X )

inline

Truncates the argument to the integer component

Parameters

_X	Floating-point value

Returns: Returns the integer component of the argument

     {
         return __dp_math_trunc(_X);
     }

float Concurrency::precise_math::truncf ( float _X )

inline

Truncates the argument to the integer component

Parameters

_X	Floating-point value

Returns: Returns the integer component of the argument

     {
         return __dp_math_truncf(_X);
     }