MATH.md

# MATH
## **Overview**
Provides math functions, such as trigonometric, exponential, logarithmic functions,and perform operations on complex numbers.
**Since:**
1.0
**Version:**
1.0
## **Summary**
## Files

File Name	Description
complex.h	Declares functions to perform operations on complex numbers.
fenv.h	Declares specific functions for performing operations for floating-point exceptions and rounding modes.
math.h	Provides common math functions.

## Data Structures

Data Structure Name	Description
fenv_t	Defines the floating-point environment.

## Macros

Macro Name and Value	Description
complex    _Complex	Indicates the type of a complex number.
FE_INVALID    1	Indicates an invalid floating-point exception. At least one parameter value is not defined in the function.
FE_DIVBYZERO    2	Indicates a pole error exception. The return value is asymptotically infinite when the divisor is zero or the input is asymptotic to zero.
FE_OVERFLOW    4	Indicates an overflow floating-point exception. The result is too large to be represented in the normal return value.
FE_UNDERFLOW    8	Indicates an underflow floating-point exception. The result is too small to be represented in the normal return value.
FE_INEXACT    16	Indicates an inexact floating-point exception.
FE_ALL_EXCEPT    31	Indicates bitwise OR of all the preceding supported floating-point exceptions.
FE_TONEAREST    0	Indicates rounding towards the nearest integer.
FE_DOWNWARD    0x800000	Indicates rounding towards negative infinity.
FE_UPWARD    0x400000	Indicates rounding towards positive infinity.
FE_TOWARDZERO    0xc00000	Indicates rounding towards zero.
FE_DFL_ENV    ((const fenv_t *) -1)	Defines the default floating-point environment.
NAN    (0.0f/0.0f)	Indicates an undefined or unrepresentable value.
INFINITY    1e5000f	Indicates an infinity.
HUGE_VALF    INFINITY	Indicates a float infinity.
HUGE_VAL    ((double)INFINITY)	Indicates a double infinity.
HUGE_VALL    ((long double)INFINITY)	Indicates a long double infinity.
MATH_ERRNO    1	Indicates an error that occurs in floating-point operations.
MATH_ERREXCEPT    2	Indicates a floating-point exception.
math_errhandling    2	Indicates the error handling mechanism employed by math functions.
FP_ILOGBNAN    (-1-0x7fffffff)	Indicates the calculation result of ilogb(NAN).
FP_ILOGB0    FP_ILOGBNAN	Indicates the calculation result of ilogb(0).
FP_NAN    0	Indicates a Not-a-Number (NaN) value.
FP_INFINITE    1	Indicates an infinity.
FP_ZERO    2	Indicates value 0.
FP_SUBNORMAL    3	Indicates a subnormal.
FP_NORMAL    4	Indicates a normal value.
isinf(x)	Checks whether the floating-point value x is an infinity.
isnan(x)	Checks whether the floating-point value x is a NaN value.
isnormal(x)	Checks whether the floating-point value x is a normal value.
isfinite(x)	Checks whether the floating-point value x is finite.
signbit(x)	Checks whether the sign of the floating-point value x is negative.
isunordered(x, y)   (isnan((x)) ? ((void)(y),1) : isnan((y)))	Checks whether floating-point value x or y is unordered.
isless(x, y)   __tg_pred_2(x, y, __isless)	Checks whether floating-point value x is less than y.
islessequal(x, y)   __tg_pred_2(x, y, __islessequal)	Checks whether floating-point value x is less than or equal to y.
islessgreater(x, y)   __tg_pred_2(x, y, __islessgreater)	Checks whether floating-point value x is either less than or greater than y.
isgreater(x, y)   __tg_pred_2(x, y, __isgreater)	Checks whether floating-point value x is greater than y.
isgreaterequal(x, y)   __tg_pred_2(x, y, __isgreaterequal)	Checks whether floating-point value x is greater than or equal to y.
MAXFLOAT    3.40282346638528859812e+38F	Maximum value of type float.
M_E    2.7182818284590452354 /* e */	Base e of natural logarithms.
M_LOG2E    1.4426950408889634074 /* log_2 e */	Logarithm to base 2 of M_E
M_LOG10E    0.43429448190325182765 /* log_10 e */	Logarithm to base 10 of M_E
M_LN2    0.69314718055994530942 /* log_e 2 */	Natural logarithm of 2
M_LN10    2.30258509299404568402 /* log_e 10 */	Natural logarithm of 10
M_PI    3.14159265358979323846 /* pi */	Ratio of a circle's circumference to its diameter.
M_PI_2    1.57079632679489661923 /* pi/2 */	Pi divided by 2
M_PI_4    0.78539816339744830962 /* pi/4 */	Pi divided by 4
M_1_PI    0.31830988618379067154 /* 1/pi */	Reciprocal of pi.
M_2_PI    0.63661977236758134308 /* 2/pi */	Two times the reciprocal of pi.
M_2_SQRTPI    1.12837916709551257390 /* 2/sqrt(pi) */	Two times the reciprocal of the square root of pi.
M_SQRT2    1.41421356237309504880 /* sqrt(2) */	Square root of 2
M_SQRT1_2    0.70710678118654752440 /* 1/sqrt(2) */	Reciprocal of the square root of 2

## Typedefs

Typedef Name	Description
fexcept_t	typedef unsigned long  Floating-point exception type.

## Functions

Function Name	Description
cacos (double complex z)	double complex  Calculates the arc cosine of the complex number z.
cacosf (float complex z)	float complex  Calculates the arc cosine of the complex number z.
cacosl (long double complex z)	long double complex  Calculates the arc cosine of the complex number z.
casin (double complex z)	double complex  Calculates the arc sine of the complex number z.
casinf (float complex z)	float complex  Calculates the arc sine of the complex number z.
casinl (long double complex z)	long double complex  Calculates the arc sine of the complex number z.
catan (double complex z)	double complex  Calculates the arc tangent of the complex number z.
catanf (float complex z)	float complex  Calculates the arc tangent of the complex number z.
catanl (long double complex z)	long double complex  Calculates the arc tangent of the complex number z.
ccos (double complex z)	double complex  Calculates the cosine of the complex number z.
ccosf (float complex z)	float complex  Calculates the cosine of the complex number z.
ccosl (long double complex z)	long double complex  Calculates the cosine of the complex number z.
csin (double complex z)	double complex  Calculates the sine of the complex number z.
csinf (float complex z)	float complex  Calculates the sine of the complex number z.
csinl (long double complex z)	long double complex  Calculates the sine of the complex number z.
ctan (double complex z)	double complex  Calculates the tangent of the complex number z.
ctanf (float complex z)	float complex  Calculates the tangent of the complex number z.
ctanl (long double complex z)	long double complex  Calculates the tangent of the complex number z.
cacosh (double complex z)	double complex  Calculates the inverse hyperbolic cosine of the complex number z.
cacoshf (float complex z)	float complex  Calculates the inverse hyperbolic cosine of the complex number z.
cacoshl (long double complex z)	long double complex  Calculates the inverse hyperbolic cosine of the complex number z.
casinh (double complex z)	double complex  Calculates the inverse hyperbolic sine of the complex number z.
casinhf (float complex z)	float complex  Calculates the inverse hyperbolic sine of the complex number z.
casinhl (long double complex z)	long double complex  Calculates the inverse hyperbolic sine of the complex number z.
catanh (double complex z)	double complex  Calculates the inverse hyperbolic tangent of the complex number z.
catanhf (float complex z)	float complex  Calculates the inverse hyperbolic tangent of the complex number z.
catanhl (long double complex z)	long double complex  Calculates the inverse hyperbolic tangent of the complex number z.
ccosh (double complex z)	double complex  Calculates the hyperbolic cosine of the complex number z.
ccoshf (float complex z)	float complex  Calculates the hyperbolic cosine of the complex number z.
ccoshl (long double complex z)	long double complex  Calculates the hyperbolic cosine of the complex number z.
csinh (double complex z)	double complex  Calculates the hyperbolic sine of the complex number z.
csinhf (float complex z)	float complex  Calculates the hyperbolic sine of the complex number z.
csinhl (long double complex z)	long double complex  Calculates the hyperbolic sine of the complex number z.
ctanh (double complex z)	double complex  Calculates the hyperbolic tangent of the complex number z.
ctanhf (float complex z)	float complex  Calculates the hyperbolic tangent of the complex number z.
ctanhl (long double complex z)	long double complex  Calculates the hyperbolic tangent of the complex number z.
cexp (double complex z)	double complex  Calculates the base-e exponential of the complex number z.
cexpf (float complex z)	float complex  Calculates the base-e exponential of the complex number z.
cexpl (long double complex z)	long double complex  Calculates the base-e exponential of the complex number z.
clog (double complex z)	double complex  Calculates the natural (base-e) logarithm of the complex number z.
clogf (float complex z)	float complex  Calculates the natural (base-e) logarithm of the complex number z.
clogl (long double complex z)	long double complex  Calculates the natural (base-e) logarithm of the complex number z.
cabs (double complex z)	double  Calculates the absolute value of the complex number z.
cabsf (float complex z)	float  Calculates the absolute value of the complex number z.
cabsl (long double complex z)	long double  Calculates the absolute value of the complex number z.
cpow (double complex x, double complex z)	double complex  Calculates the value of x raised to the z power.
cpowf (float complex x, float complex z)	float complex  Calculates the value of x raised to the z power.
cpowl (long double complex x, long double complex z)	long double complex  Calculates the value of x raised to the z power.
csqrt (double complex z)	double complex  Calculates the square root of the complex number z.
csqrtf (float complex z)	float complex  Calculates the square root of the complex number z.
csqrtl (long double complex z)	long double complex  Calculates the square root of the complex number z.
carg (double complex z)	double  Calculates the phase angle of the complex number z.
cargf (float complex z)	float  Calculates the phase angle of the complex number z.
cargl (long double complex z)	long double  Calculates the phase angle of the complex number z.
cimag (double complex z)	double  Calculates the imaginary part of the complex number z.
cimagf (float complex z)	float  Calculates the imaginary part of the complex number z.
cimagl (long double complex z)	long double  Calculates the imaginary part of the complex number z.
conj (double complex z)	double complex  Calculates the conjugate of the complex number z.
conjf (float complex z)	float complex  Calculates the conjugate of the complex number z.
conjl (long double complex z)	long double complex  Calculates the conjugate of the complex number z.
cproj (double complex z)	double complex  Calculates the projection of the complex number z onto the Riemann sphere.
cprojf (float complex z)	float complex  Calculates the projection of the complex number z onto the Riemann sphere.
cprojl (long double complex z)	long double complex  Calculates the projection of the complex number z onto the Riemann sphere.
creal (double complex z)	double  Calculates the real part of the complex number z.
crealf (float complex z)	float  Calculates the real part of the complex number z.
creall (long double complex z)	long double  Calculates the real part of the complex number z.
feclearexcept (int excepts)	int  Clears floating-point exceptions specified by excepts.
fegetexceptflag (fexcept_t *flagp, int excepts)	int  Stores the floating-point exceptions specified by excepts into the flagp variable address.
feraiseexcept (int excepts)	int  Obtains the floating-point exceptions specified by excepts.
fesetexceptflag (const fexcept_t *flagp, int excepts)	int  Sets the exception status flag by copying the floating-point exceptions stored in the flagp address to the excepts parameter.
fetestexcept (int excepts)	int  Checks whether the floating-point exceptions specified by excepts have been raised.
fegetround (void)	int  Obtains the macro corresponding to the current rounding mode.
fesetround (int rounding_mode)	int  Sets the rounding mode.
fegetenv (fenv_t *envp)	int  Stores the current floating-point environment into the object specified by envp.
feholdexcept (fenv_t *envp)	int  Stores the current floating-point environment into the object specified by envp, with all status flags cleared.
fesetenv (const fenv_t *envp)	int  Sets the current floating-point environment.
feupdateenv (const fenv_t *envp)	int  Updates the current floating-point environment from the object specified by envp.
acos (double x)	double  Calculates the arc cosine of the double value x.
acosf (float x)	float  Calculates the arc cosine of the float value x.
acosl (long double x)	long double  Calculates the arc cosine of the long double value x.
acosh (double x)	double  Calculates the inverse hyperbolic cosine of the double value x.
acoshf (float x)	float  Calculates the inverse hyperbolic cosine of float value x.
acoshl (long double x)	long double  Calculates the inverse hyperbolic cosine of the long double value x.
asin (double x)	double  Calculates the arc sine of the double value x.
asinf (float x)	float  Calculates the arc sine of the float value x.
asinl (long double x)	long double  Calculates the arc sine of the long double value x.
asinh (double x)	double  Calculates the inverse hyperbolic sine of the double value x.
asinhf (float x)	float  Calculates the inverse hyperbolic sine of the float value x.
asinhl (long double x)	long double  Calculates the inverse hyperbolic sine of the long double value x.
atan (double x)	double  Calculates the arc tangent of the double value x.
atanf (float x)	float  Calculates the arc tangent of the float value x.
atanl (long double x)	long double  Calculates the arc tangent of the long double value x.
atan2 (double y, double x)	double  Calculates the arc tangent of two double values x and y.
atan2f (float y, float x)	float  Calculates the arc tangent of two float values x and y.
atan2l (long double y, long double x)	long double  Calculates the arc tangent of two long double values x and y.
atanh (double x)	double  Calculates the inverse hyperbolic tangent of the double value x.
atanhf (float x)	float  Calculates the inverse hyperbolic tangent of the float value x.
atanhl (long double x)	long double  Calculates the inverse hyperbolic tangent of the long double value x.
cbrt (double x)	double  Calculates the cube root of the double value x.
cbrtf (float x)	float  Calculates the cube root of the float value x.
cbrtl (long double x)	long double  Calculates the cube root of the long double value x.
ceil (double x)	double  Calculates the minimum integer greater than or equal to the double value x.
ceilf (float x)	float  Calculates the minimum integer greater than or equal to the float value x.
ceill (long double x)	long double  Calculates the minimum integer greater than or equal to the long double value x.
copysign (double x, double y)	double  Generates a value by combining the magnitude of the double value x and the sign of the double value y.
copysignf (float x, float y)	float  Generates a value by combining the magnitude of the float value x and the sign of the float value y.
copysignl (long double x, long double y)	long double  Generates a value by combining the magnitude of the long double value x and the sign of the long double value y.
cos (double x)	double  Calculates the cosine of the double value x.
cosf (float x)	float  Calculates the cosine of the float value x.
cosl (long double x)	long double  Calculates the cosine of the long double value x.
cosh (double x)	double  Calculates the hyperbolic cosine of the double value x.
coshf (float x)	float  Calculates the hyperbolic cosine of the float value x.
coshl (long double x)	long double  Calculates the hyperbolic cosine of the long double value x.
erf (double x)	double  Calculates the error function of the double value x.
erff (float x)	float  Calculates the error function of the float value x.
erfl (long double x)	long double  Calculates the error function of the long double value x.
erfc (double x)	double  Calculates the complementary error function of the double value x.
erfcf (float x)	float  Calculates the complementary error function of the float value x.
erfcl (long double x)	long double  Calculates the complementary error function of the long double value x.
exp (double x)	double  Calculates the base-e exponential function of the double value x.
expf (float x)	float  Calculates the base-e exponential function of the float value x.
expl (long double x)	long double  Calculates the base-e exponential function of the long double value x.
exp2 (double x)	double  Calculates the base-2 exponential function of the double value x.
exp2f (float x)	float  Calculates the base-2 exponential function of the float value x.
exp2l (long double x)	long double  Calculates the base-2 exponential function of the long double value x.
expm1 (double x)	double  Calculates e raised to the power of the double value x minus one, that is, (e^x)-1.
expm1f (float x)	float  Calculates e raised to the power of the float value x minus one.
expm1l (long double x)	long double  Calculates e raised to the power of the long double value x minus one.
fabs (double x)	double  Calculates the absolute value of the double value x.
fabsf (float x)	float  Calculates the absolute value of the float value x.
fabsl (long double x)	long double  Calculates the absolute value of the long double value x.
fdim (double x, double y)	double  Calculates the positive difference between the double value x and y.
fdimf (float x, float y)	float  Calculates the positive difference between the float value x and y.
fdiml (long double x, long double y)	long double  Calculates the positive difference between the long double value x and y.
floor (double x)	double  Obtains the largest integer less than or equal to the double value x.
floorf (float x)	float  Obtains the largest integer less than or equal to the float value x.
floorl (long double x)	long double  Obtains the largest integer less than or equal to the long double value x.
fma (double x, double y, double z)	double  Calculates the value of x*y+z and rounds the result up.
fmaf (float x, float y, float z)	float  Calculates the value of x*y+z and rounds the result up.
fmal (long double x, long double y, long double z)	long double  Calculates the value of x*y+z and rounds the result up.
fmax (double x, double y)	double  Obtains the larger value of two double values x and y.
fmaxf (float x, float y)	float  Obtains the larger value of two float values x and y.
fmaxl (long double x, long double y)	long double  Obtains the larger value of two long double values x and y.
fmin (double x, double y)	double  Obtains the smaller value of two double values x and y.
fminf (float x, float y)	float  Obtains the smaller value of two float values x and y.
fminl (long double x, long double y)	long double  Obtains the smaller value of two long double values x and y.
fmod (double x, double y)	double  Calculates the remainder of the double value x divided by the double value y.
fmodf (float x, float y)	float  Calculates the remainder of the float value x divided by the float value y.
fmodl (long double x, long double y)	long double  Calculates the remainder of the long double value x divided by the long double value y.
frexp (double x, int *exp)	double  Decomposes the double value x into a significand and an integral exponent for 2.
frexpf (float x, int *exp)	float  Decomposes float value x into a binary significand and an integral exponent for 2.
frexpl (long double x, int *exp)	long double  Decomposes long double value x into a binary significand and an integral exponent for 2.
hypot (double x, double y)	double  Calculates the hypotenuse of a right triangle whose legs are x and y.
hypotf (float x, float y)	float  Calculates the hypotenuse of a right triangle whose legs are x and y.
hypotl (long double x, long double y)	long double  Calculates the hypotenuse of a right triangle whose legs are x and y.
ilogb (double x)	int  Obtains the integral part of the logarithm of double value x.
ilogbf (float x)	int  Obtains the integral part of the logarithm of float value x.
ilogbl (long double x)	int  Obtains the integral part of the logarithm of the long double value x.
ldexp (double x, int exp)	double  Multiplies the double value x by 2 raised to the power of exp.
ldexpf (float x, int exp)	float  Multiplies the float value x by 2 raised to the power of exp.
ldexpl (long double x, int exp)	long double  Multiplies the long double value x by 2 raised to the power of exp.
lgamma (double x)	double  Calculates the natural logarithm of the absolute value of the gamma function of the double value x.
lgammaf (float x)	float  Calculates the natural logarithm of the absolute value of the gamma function of the float value x.
lgammal (long double x)	long double  Calculates the natural logarithm of the absolute value of the gamma function of the long double value x.
llrint (double x)	long long int  Rounds double value x to the nearest integer.
llrintf (float x)	long long int  Rounds float value x to the nearest integer.
llrintl (long double x)	long long int  Rounds long double value x to the nearest integer.
llround (double x)	long long int  Rounds double value x to the nearest integer, rounding away from 0.
llroundf (float x)	long long int  Rounds float value x to the nearest integer, rounding away from 0.
llroundl (long double x)	long long int  Rounds long double value x to the nearest integer, rounding away from 0.
log (double x)	double  Calculates the natural logarithm of the double value x.
logf (float x)	float  Calculates the natural logarithm of the float value x.
logl (long double x)	long double  Calculates the natural logarithm of the long double value x.
log10 (double x)	double  Calculates the common logarithm (logarithm with base 10) of the double value x.
log10f (float x)	float  Calculates the common logarithm (logarithm with base 10) of the float value x.
log10l (long double x)	long double  Calculates the common logarithm (logarithm with base 10) of the long double value x.
log1p (double x)	double  Calculates the natural logarithm of one plus the double value x.
log1pf (float x)	float  Calculates the natural logarithm of one plus the float value x.
log1pl (long double x)	long double  Calculates the natural logarithm of one plus the long double value x.
log2 (double x)	double  Calculates the binary logarithm (logarithm with base 2) of the double value x.
log2f (float x)	float  Calculates the binary logarithm (logarithm with base 2) of the float value x.
log2l (long double x)	long double  Calculates the binary logarithm (logarithm with base 2) of the long double value x.
logb (double x)	double  Calculates the logarithm of the absolute value of the double value x.
logbf (float x)	float  Calculates the logarithm of the absolute value of the float value x.
logbl (long double x)	long double  Calculates the logarithm of the absolute value of the long double value x.
lrint (double x)	long int  Rounds the double value x to the nearest integer.
lrintf (float x)	long int  Rounds the float value x to the nearest integer.
lrintl (long double x)	long int  Rounds the long double value x to the nearest integer.
lround (double x)	long int  Rounds double value x to the nearest integer, rounding away from 0.
lroundf (float x)	long int  Rounds the float value x to the nearest integer, rounding away from 0.
lroundl (long double x)	long int  Rounds the long double value x to the nearest integer, rounding away from 0.
modf (double x, double *iptr)	double  Breaks the double value x into a signed integral and a fractional part.
modff (float x, float *iptr)	float  Breaks the float value x into a signed integral and a fractional part.
modfl (long double x, long double *iptr)	long double  Breaks the long double value x into a signed integral and a fractional part.
nan (const char *tagp)	double  Obtains a quiet NaN value of the double type.
nanf (const char *tagp)	float  Obtains a quiet NaN value of the float type.
nanl (const char *tagp)	long double  Obtains a quiet NaN value of the long double type.
nearbyint (double x)	double  Rounds the double value x to an integer in floating-point format.
nearbyintf (float x)	float  Rounds the float value x to an integer in floating-point format.
nearbyintl (long double x)	long double  Rounds the long double value x to an integer in floating-point format.
nextafter (double x, double y)	double  Obtains the next representable value following the double value x in the direction of the double value y.
nextafterf (float x, float y)	float  Obtains the next representable value following the float value x in the direction of the float value y.
nextafterl (long double x, long double y)	long double  Obtains the next representable value following the long double value x in the direction of the long double value y.
nexttoward (double x, long double y)	double  Obtains the next representable value following the double value x in the direction of the long double value y.
nexttowardf (float x, long double y)	float  Obtains the next representable value following the float value x in the direction of the long double value y.
nexttowardl (long double x, long double y)	long double  Obtains the next representable value following the long double value x in the direction of the long double value y.
pow (double x, double y)	double  Obtains the double value x raised to the power of the double value y.
powf (float x, float y)	float  Obtains the float value x raised to the power of the float value y.
powf10 (float x)	float  Calculates the xth power of 10.
powl (long double x, long double y)	long double  Obtains the long double value x raised to the power of the long double value y.
powl10 (long double x)	long double  Calculates the xth power of 10.
remainder (double x, double y)	double  Calculates the remainder of the double value x divided by the double value y.
remainderf (float x, float y)	float  Calculates the remainder of the float value x divided by the float value y.
remainderl (long double x, long double y)	long double  Calculates the remainder of the long double value x divided by the long double value y.
remquo (double x, double y, int *quo)	double  Calculates the quotient and remainder of the double value x divided by the double value y.
remquof (float x, float y, int *quo)	float  Calculates the quotient and remainder of the float value x divided by the float value y.
remquol (long double x, long double y, int *quo)	long double  Calculates the quotient and remainder of the long double value x divided by the long double value y.
rint (double x)	double  Rounds the double value x to the nearest integer.
rintf (float x)	float  Rounds the float value x to the nearest integer.
rintl (long double x)	long double  Rounds the long double value x to the nearest integer.
round (double x)	double  Rounds the double value x to the nearest integer, rounding away from 0.
roundf (float x)	float  Rounds the float value x to the nearest integer, rounding away from 0.
roundl (long double x)	long double  Rounds the long double value x to the nearest integer, rounding away from 0.
scalbln (double x, long int exp)	double  Multiplies the double value x by FLT_RADIX raised to the power of the long int value exp, that is, x*(FLT_RADIX)^exp.
scalblnf (float x, long int exp)	float  Multiplies the float value x by FLT_RADIX raised to the power of the long int value exp, that is, x*(FLT_RADIX)^exp.
scalblnl (long double x, long int exp)	long double  Multiplies the long double value x by FLT_RADIX raised to the power of the long int value exp, that is, x*(FLT_RADIX)^exp.
scalbn (double x, int exp)	double  Multiplies the double value x by FLT_RADIX raised to the power of the int value exp, that is, x*(FLT_RADIX)^exp.
scalbnf (float x, int exp)	float  Multiplies the float value x by FLT_RADIX raised to the power of the int value exp, that is, x*(FLT_RADIX)^exp.
scalbnl (long double x, int exp)	long double  Multiplies the long double value x by FLT_RADIX raised to the power of the int value exp, that is, x*(FLT_RADIX)^exp.
sin (double x)	double  Calculates the sine of the double value x.
sinf (float x)	float  Calculates the sine of the float value x.
sinl (long double x)	long double  Calculates the sine of the long double value x.
sinh (double x)	double  Calculates the hyperbolic sine of the double value x.
sinhf (float x)	float  Calculates the hyperbolic sine of the float value x.
sinhl (long double x)	long double  Calculates the hyperbolic sine of the long double value x.
sqrt (double x)	double  Calculates the square root of double value x.
sqrtf (float x)	float  Calculates the square root of the float value x.
sqrtl (long double x)	long double  Calculates the square root of the long double value x.
tan (double x)	double  Calculates the tangent of the double value x.
tanf (float x)	float  Calculates the tangent of the float value x.
tanl (long double x)	long double  Calculates the tangent of the long double value x.
tanh (double x)	double  Calculates the hyperbolic tangent of the double value x.
tanhf (float x)	float  Calculates the hyperbolic tangent of the float value x.
tanhl (long double x)	long double  Calculates the hyperbolic tangent of the long double value x.
tgamma (double x)	double  Calculates the gamma function of the double value x.
tgammaf (float x)	float  Calculates the gamma function of the float value x.
tgammal (long double x)	long double  Calculates the gamma function of the long double value x.
trunc (double x)	double  Obtains the nearest integer whose absolute value is less than or equal to the absolute value of the double value x.
truncf (float x)	float  Obtains the nearest integer whose absolute value is less than or equal to the absolute value of the float value x.
truncl (long double x)	long double  Obtains the nearest integer whose absolute value is less than or equal to the absolute value of the long double value x.
j0 (double x)	double  Calculates the Bessel function of the first kind of order 0 for the double value x.
j1 (double x)	double  Calculates the Bessel function of the first kind of order 1 for the double value x.
jn (int n, double x)	double  Calculates the Bessel function of the first kind of order n for the double value x.
y0 (double x)	double  Calculates the Bessel function of the second kind of order 0 for the double value x.
y1 (double x)	double  Calculates the Bessel function of the second kind of order 1 for the double value x.
yn (int n, double x)	double  Calculates the Bessel function of the second kind of order n for the double value x.
finite (double x)	int  Checks whether the double value x is an infinity or a NaN value.
finitef (float x)	int  Checks whether the float value x is an infinity or a NaN value.
scalb (double x, double exp)	double  Multiplies the double value x by FLT_RADIX raised to the power of the double value exp, that is, x*FLT_RADIX^exp.
scalbf (float x, float exp)	float  Multiplies the float value x by FLT_RADIX raised to the power of the float value exp, that is, x*FLT_RADIX^exp.
significand (double x)	double  Obtains the significand of the double value x scaled to the range [1,2).
significandf (float x)	float  Obtains the significand of the float value x scaled to the range [1,2).
j0f (float x)	float  Calculates the Bessel function of the first kind of order 0 for the float value x.
j1f (float x)	float  Calculates the Bessel function of the first kind of order 1 for the float value x.
jnf (int n, float x)	float  Calculates the Bessel function of the first kind of order n for the float value x.
y0f (float x)	float  Calculates the Bessel function of the second kind of order 0 for the float value x.
y1f (float x)	float  Calculates the Bessel function of the second kind of order 1 for the float value x.
ynf (int n, float x)	float  Calculates the Bessel function of the second kind of order n for the float value x.
lgammal_r (long double x, int *signp)	long double  Calculates the natural logarithm of the absolute value of the gamma function of the double value x.
sincos (double x, double *sin, double *cos)	void  Calculates the sine and cosine of the double value x.
sincosf (float x, float *sin, float *cos)	void  Calculates the sine and cosine of the float value x.
sincosl (long double x, long double *sin, long double *cos)	void  Calculates the sine and cosine of the long double value x.
exp10 (double x)	double  Calculates the base-10 exponential function of the double value x.
exp10f (float x)	float  Calculates the base-10 exponential function of the float value x.
exp10l (long double x)	long double  Calculates the base-10 exponential function of the long double value x.
pow10 (double x)	double  Calculates the value of 10 raised to the power x, which is a double value.
pow10f (float x)	float  Calculates the value of 10 raised to the power x, which is a float value.
pow10l (long double x)	long double  Calculates the value of 10 raised to the power x, which is a long double value.

## **Details**
## **Macro Definition Documentation**
## isfinite
```
#define isfinite( x)
```
```
Values:( \
sizeof(x) == sizeof(float) ? (__FLOAT_BITS(x) & 0x7fffffff) < 0x7f800000 : \
sizeof(x) == sizeof(double) ? (__DOUBLE_BITS(x) & -1ULL>>1) < 0x7ffULL<<52 : \
__fpclassifyl(x) > [FP_INFINITE](MATH.md#ga4f64bcc64f8b84dd9daf5a4e56abf0ca))
```
**Description:**
Checks whether the floating-point value **x** is finite.
A finite value is any value that is neither an infinity nor a NaN value.
**Parameters:**

Name	Description
x	Indicates the floating-point value x to check.

**Returns:**
Returns **1** if **x** is finite; returns **0** otherwise.
## isgreater
```
#define isgreater( x,  y )   __tg_pred_2(x, y, __isgreater)
```
**Description:**
Checks whether floating-point value **x** is greater than **y**.
**Parameters:**

Name	Description
x	Indicates the floating-point value x to check.
y	Indicates the floating-point value y to check.

**Attention:**
If either or both of **x** and **y** are a NaN value, an exception occurs. This function requires hardware support.
**Returns:**
Returns **1** if **x** is greater than **y**; returns **0** otherwise.
## isgreaterequal
```
#define isgreaterequal( x,  y )   __tg_pred_2(x, y, __isgreaterequal)
```
**Description:**
Checks whether floating-point value **x** is greater than or equal to **y**.
**Parameters:**

Name	Description
x	Indicates the floating-point value x to check.
y	Indicates the floating-point value y to check.

**Attention:**
If either or both of **x** and **y** are a NaN value, an exception occurs. This function requires hardware support.
**Returns:**
Returns **1** if **x** is greater than or equal to **y**; returns **0** otherwise.
## isinf
```
#define isinf( x)
```
```
Values:( \
sizeof(x) == sizeof(float) ? (__FLOAT_BITS(x) & 0x7fffffff) == 0x7f800000 : \
sizeof(x) == sizeof(double) ? (__DOUBLE_BITS(x) & -1ULL>>1) == 0x7ffULL<<52 : \
__fpclassifyl(x) == [FP_INFINITE](MATH.md#ga4f64bcc64f8b84dd9daf5a4e56abf0ca))
```
**Description:**
Checks whether the floating-point value **x** is an infinity.
**Parameters:**

Name	Description
x	Indicates the floating-point value x to check.

**Returns:**
Returns **1** if **x** is an infinity; returns **0** otherwise.
## isless
```
#define isless( x,  y )   __tg_pred_2(x, y, __isless)
```
**Description:**
Checks whether floating-point value **x** is less than **y**.
**Parameters:**

Name	Description
x	Indicates the floating-point value x to check.
y	Indicates the floating-point value y to check.

**Attention:**
If either or both of **x** and **y** are a NaN value, an exception occurs. This function requires hardware support.
**Returns:**
Returns **1** if **x** is less than **y**; returns **0** otherwise.
## islessequal
```
#define islessequal( x,  y )   __tg_pred_2(x, y, __islessequal)
```
**Description:**
Checks whether floating-point value **x** is less than or equal to **y**.
**Parameters:**

Name	Description
x	Indicates the floating-point value x to check.
y	Indicates the floating-point value y to check.

**Attention:**
If either or both of **x** and **y** are a NaN value, an exception occurs. This function requires hardware support.
**Returns:**
Returns **1** if **x** is less than or equal to **y**; returns **0** otherwise.
## islessgreater
```
#define islessgreater( x,  y )   __tg_pred_2(x, y, __islessgreater)
```
**Description:**
Checks whether floating-point value **x** is either less than or greater than **y**.
**Parameters:**

Name	Description
x	Indicates the floating-point value x to check.
y	Indicates the floating-point value y to check.

**Attention:**
If either or both of **x** and **y** are a NaN value, an exception occurs. This function requires hardware support.
**Returns:**
Returns **1** if **x** is either less than or greater than **y**; returns **0** otherwise.
## isnan
```
#define isnan( x)
```
```
Values:( \
sizeof(x) == sizeof(float) ? (__FLOAT_BITS(x) & 0x7fffffff) > 0x7f800000 : \
sizeof(x) == sizeof(double) ? (__DOUBLE_BITS(x) & -1ULL>>1) > 0x7ffULL<<52 : \
__fpclassifyl(x) == [FP_NAN](MATH.md#ga1d481cc6e6a8ff729147ed46e61a4c9f))
```
**Description:**
Checks whether the floating-point value **x** is a NaN value.
**Parameters:**

Name	Description
x	Indicates the floating-point value x to check.

**Returns:**
Returns a non-zero value if **x** is a NaN value; returns **0** otherwise.
## isnormal
```
#define isnormal( x)
```
```
Values:( \
sizeof(x) == sizeof(float) ? ((__FLOAT_BITS(x)+0x00800000) & 0x7fffffff) >= 0x01000000 : \
sizeof(x) == sizeof(double) ? ((__DOUBLE_BITS(x)+(1ULL<<52)) & -1ULL>>1) >= 1ULL<<53 : \
__fpclassifyl(x) == [FP_NORMAL](MATH.md#gab9e29bb9e853934c4ba647c840b7e5de))
```
**Description:**
Checks whether the floating-point value **x** is a normal value.
A normal value refers to any value that is not an infinity, a NaN value, or **0**.
**Parameters:**

Name	Description
x	Indicates the floating-point value x to check.

**Returns:**
Returns a non-zero value if **x** is a normal value; returns **0** otherwise.
## isunordered
```
#define isunordered( x,  y )   ([isnan](MATH.md#ga2e1baae9134e580910322362dc23290e)((x)) ? ((void)(y),1) : [isnan](MATH.md#ga2e1baae9134e580910322362dc23290e)((y)))
```
**Description:**
Checks whether floating-point value **x** or **y** is unordered.
An unordered value refers to a NaN value.
**Parameters:**

Name	Description
x	Indicates the floating-point value x to check.
y	Indicates the floating-point value y to check.

**Returns:**
Returns **1** if either **x** or **y** is unordered; returns **0** otherwise.
## signbit
```
#define signbit( x)
```
```
Values:( \
sizeof(x) == sizeof(float) ? (int)(__FLOAT_BITS(x)>>31) : \
sizeof(x) == sizeof(double) ? (int)(__DOUBLE_BITS(x)>>63) : \
__signbitl(x) )
```
**Description:**
Checks whether the sign of the floating-point value **x** is negative.
**Parameters:**

Name	Description
x	Indicates the floating-point value x to check.

**Returns:**
Returns a non-zero value if the sign of **x** is negative; returns **0** otherwise.
## **Function Documentation**
## acos\(\)
```
double acos (double x)
```
**Description:**
Calculates the arc cosine of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value whose arc cosine is to be calculated.

**Returns:**
Returns the arc cosine of **x** in radians, ranging from 0 to [M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3). If **x** is a NaN value, this function returns a NaN value. If **x** is **+1**, this function returns **+0**. If **x** is a positive or negative infinity, this function returns a NaN value and reports a domain error. If **x** is out of the range \[-1, 1\], this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## acosf\(\)
```
float acosf (float x)
```
**Description:**
Calculates the arc cosine of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value whose arc cosine is to be calculated.

**Returns:**
Returns the arc cosine of **x** in radians, ranging from 0 to [M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3). If **x** is a NaN value, this function returns a NaN value. If **x** is **+1**, this function returns **+0**. If **x** is a positive or negative infinity, this function returns a NaN value and reports a domain error. If **x** is out of the range \[-1, 1\], this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## acosh\(\)
```
double acosh (double x)
```
**Description:**
Calculates the inverse hyperbolic cosine of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value whose inverse hyperbolic cosine is to be calculated.

**Returns:**
Returns the inverse hyperbolic cosine of **x**. If **x** is a NaN value, this function returns a NaN value. If **x** is **+1**, this function returns **+0**. If **x** is a positive infinity, this function returns a positive infinity. If **x** is less than **1**, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## acoshf\(\)
```
float acoshf (float x)
```
**Description:**
Calculates the inverse hyperbolic cosine of float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value whose inverse hyperbolic cosine is to be calculated.

**Returns:**
Returns the inverse hyperbolic cosine of **x**. If **x** is a NaN value, this function returns a NaN value. If **x** is **+1**, this function returns **+0**. If **x** is a positive infinity, this function returns a positive infinity. If **x** is less than **1**, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## acoshl\(\)
```
long double acoshl (long double x)
```
**Description:**
Calculates the inverse hyperbolic cosine of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value whose inverse hyperbolic cosine is to be calculated.

**Returns:**
Returns the inverse hyperbolic cosine of **x**. If **x** is a NaN value, this function returns a NaN value. If **x** is **+1**, this function returns **+0**. If **x** is a positive infinity, this function returns a positive infinity. If **x** is less than **1**, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## acosl\(\)
```
long double acosl (long double x)
```
**Description:**
Calculates the arc cosine of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value whose arc cosine is to be calculated.

**Returns:**
Returns the arc cosine of **x** in radians, ranging from 0 to [M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3). If **x** is a NaN value, this function returns a NaN value. If **x** is **+1**, this function returns **+0**. If **x** is a positive or negative infinity, this function returns a NaN value and reports a domain error. If **x** is out of the range \[-1, 1\], this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## asin\(\)
```
double asin (double x)
```
**Description:**
Calculates the arc sine of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value whose arc sine is to be calculated.

**Returns:**
Returns the arc sine of **x** in radians, ranging from -[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f) to [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f). If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**. If **x** is out of the range \[-1, 1\], this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## asinf\(\)
```
float asinf (float x)
```
**Description:**
Calculates the arc sine of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value whose arc sine is to be calculated.

**Returns:**
Returns the arc sine of **x** in radians, ranging from -[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f) to [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f). If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**. If **x** is out of the range \[-1, 1\], this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## asinh\(\)
```
double asinh (double x)
```
**Description:**
Calculates the inverse hyperbolic sine of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value whose inverse hyperbolic sine is to be calculated.

**Returns:**
Returns the inverse hyperbolic sine of **x**. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**. If **x** is a positive or negative infinity, this function returns a positive or negative infinity.
## asinhf\(\)
```
float asinhf (float x)
```
**Description:**
Calculates the inverse hyperbolic sine of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value whose inverse hyperbolic sine is to be calculated.

**Returns:**
Returns the inverse hyperbolic sine of **x**. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**. If **x** is a positive or negative infinity, this function returns a positive or negative infinity.
## asinhl\(\)
```
long double asinhl (long double x)
```
**Description:**
Calculates the inverse hyperbolic sine of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value whose inverse hyperbolic sine is to be calculated.

**Returns:**
Returns the inverse hyperbolic sine of **x**. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**. If **x** is a positive or negative infinity, this function returns a positive or negative infinity.
## asinl\(\)
```
long double asinl (long double x)
```
**Description:**
Calculates the arc sine of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value whose arc sine is to be calculated.

**Returns:**
Returns the arc sine of **x** in radians, ranging from -[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f) to [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f). If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**. If **x** is out of the range \[-1, 1\], this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## atan\(\)
```
double atan (double x)
```
**Description:**
Calculates the arc tangent of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value whose arc tangent is to be calculated.

**Returns:**
Returns the principal value of the arc tangent of **x** in radians, ranging from -[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f) to [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f). If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**, respectively. If **x** is a positive or negative infinity, this function returns [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f).
## atan2\(\)
```
double atan2 (double y, double x )
```
**Description:**
Calculates the arc tangent of two double values **x** and **y**.
**Parameters:**

Name	Description
y	Indicates the double value y for calculating the arc tangent.
x	Indicates the double value x for calculating the arc tangent.

**Returns:**
Returns the principal value of the arc tangent of y/x in radians, ranging from **-[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)** to **[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)**. If **y** is **+0** or **-0**, and **x** is less than **0**, this function returns **+[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)** or **-[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)**, respectively. If **y** is **+0** or **-0**, and **x** is greater than **0**, this function returns **+0** or **-0**, respectively. If **y** is less than **0** and **x** is either **+0** or **-0**, this function returns **-[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)**. If **y** is greater than **0** and **x** is either **+0** or **-0**, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)**. If **x** or **y** is a NaN value, this function returns a NaN value. If **y** is **+0** or **-0**, and **x** is **-0**, this function returns **+[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)** or **-[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)**, respectively. If **y** is **+0** or **-0**, and **x** is **+0**, this function returns **+0** or **-0**, respectively. If **y** is a finite value greater than or less than **0**, and **x** is a negative infinity, this function returns **+[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)** or **-[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)**, respectively. If **y** is a finite value greater than or less than **0**, and **x** is a positive infinity, this function returns **+0** or **-0**, respectively. If **y** is a positive or negative infinity, and **x** is a finite value, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)** or **-[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)**, respectively. If **y** is a positive or negative infinity, and **x** is a negative infinity, this function returns **+3\*[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)** or **-3\*[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)**, respectively. If **y** is a positive or negative infinity, and **x** is a positive infinity, this function returns **+[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)** or **-[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)**, respectively.
## atan2f\(\)
```
float atan2f (float y, float x )
```
**Description:**
Calculates the arc tangent of two float values **x** and **y**.
**Parameters:**

Name	Description
y	Indicates the float value y for calculating the arc tangent.
x	Indicates the float value x for calculating the arc tangent.

**Returns:**
Returns the principal value of the arc tangent of y/x in radians, ranging from **-[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)** to **[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)**. If **y** is **+0** or **-0**, and **x** is less than **0**, this function returns **+[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)** or **-[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)**, respectively. If **y** is **+0** or **-0**, and **x** is greater than **0**, this function returns **+0** or **-0**, respectively. If **y** is less than **0** and **x** is either **+0** or **-0**, this function returns **-[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)**. If **y** is greater than **0** and **x** is either **+0** or **-0**, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)**. If **x** or **y** is a NaN value, this function returns a NaN value. If **y** is **+0** or **-0**, and **x** is **-0**, this function returns **+[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)** or **-[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)**, respectively. If **y** is **+0** or **-0**, and **x** is **+0**, this function returns **+0** or **-0**, respectively. If **y** is a finite value greater than or less than **0**, and **x** is a negative infinity, this function returns **+[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)** or **-[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)**, respectively. If **y** is a finite value greater than or less than **0**, and **x** is a positive infinity, this function returns **+0** or **-0**, respectively. If **y** is a positive or negative infinity, and **x** is a finite value, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)** or **-[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)**, respectively. If **y** is a positive or negative infinity, and **x** is a negative infinity, this function returns **+3\*[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)** or **-3\*[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)**, respectively. If **y** is a positive or negative infinity, and **x** is a positive infinity, this function returns **+[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)** or **-[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)**, respectively.
## atan2l\(\)
```
long double atan2l (long double y, long double x )
```
**Description:**
Calculates the arc tangent of two long double values **x** and **y**.
**Parameters:**

Name	Description
y	Indicates the long double value y for calculating the arc tangent.
x	Indicates the long double value x for calculating the arc tangent.

**Returns:**
Returns the principal value of the arc tangent of y/x in radians, ranging from **-[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)** to **[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)**. If **y** is **+0** or **-0**, and **x** is less than **0**, this function returns **+[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)** or **-[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)**, respectively. If **y** is **+0** or **-0**, and **x** is greater than **0**, this function returns **+0** or **-0**, respectively. If **y** is less than **0** and **x** is either **+0** or **-0**, this function returns **-[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)**. If **y** is greater than **0** and **x** is either **+0** or **-0**, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)**. If **x** or **y** is a NaN value, this function returns a NaN value. If **y** is **+0** or **-0**, and **x** is **-0**, this function returns **+[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)** or **-[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)**, respectively. If **y** is **+0** or **-0**, and **x** is **+0**, this function returns **+0** or **-0**, respectively. If **y** is a finite value greater than or less than **0**, and **x** is a negative infinity, this function returns **+[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)** or **-[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)**, respectively. If **y** is a finite value greater than or less than **0**, and **x** is a positive infinity, this function returns **+0** or **-0**, respectively. If **y** is a positive or negative infinity, and **x** is a finite value, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)** or **-[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)**, respectively. If **y** is a positive or negative infinity, and **x** is a negative infinity, this function returns **+3\*[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)** or **-3\*[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)**, respectively. If **y** is a positive or negative infinity, and **x** is a positive infinity, this function returns **+[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)** or **-[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)**, respectively.
## atanf\(\)
```
float atanf (float x)
```
**Description:**
Calculates the arc tangent of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value whose arc tangent is to be calculated.

**Returns:**
Returns the principal value of the arc tangent of **x** in radians, ranging from -[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f) to [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f). If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**, respectively. If **x** is a positive or negative infinity, this function returns [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f) or -[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f), respectively.
## atanh\(\)
```
double atanh (double x)
```
**Description:**
Calculates the inverse hyperbolic tangent of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value whose inverse hyperbolic tangent is to be calculated.

**Returns:**
Returns the inverse hyperbolic tangent of **x**. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**, respectively. If **x** is **+1** or **-1**, this function returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971), reports a pole error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If the absolute value of **x** is greater than **1**, this function returns a NaN value, reports a domain error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception.
## atanhf\(\)
```
float atanhf (float x)
```
**Description:**
Calculates the inverse hyperbolic tangent of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value whose inverse hyperbolic tangent is to be calculated.

**Returns:**
Returns the inverse hyperbolic tangent of **x**. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**, respectively. If **x** is **+1** or **-1**, this function returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971), reports a pole error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If the absolute value of **x** is greater than **1**, this function returns a NaN value, reports a domain error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception.
## atanhl\(\)
```
long double atanhl (long double x)
```
**Description:**
Calculates the inverse hyperbolic tangent of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value whose inverse hyperbolic tangent is to be calculated.

**Returns:**
Returns the inverse hyperbolic tangent of **x**. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**, respectively. If **x** is **+1** or **-1**, this function returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971), reports a pole error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If the absolute value of **x** is greater than **1**, this function returns a NaN value, reports a domain error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception.
## atanl\(\)
```
long double atanl (long double x)
```
**Description:**
Calculates the arc tangent of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value whose arc tangent is to be calculated.

**Returns:**
Returns the principal value of the arc tangent of **x** in radians, ranging from -[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f) to [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f). If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**, respectively. If **x** is a positive or negative infinity, this function returns [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f) or -[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f), respectively.
## cabs\(\)
```
double cabs (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the absolute value of the complex number **z**.
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose absolute value is to be obtained.

**Attention:**
If an error occurs or **z** is a positive or negative infinity or [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), the returned value is calculated based on the formula [hypot](MATH.md#ga6d6a905f61d535f8454190433b8c0ea5)\([cimag](MATH.md#ga6c3d7c875ae93700b0a2a32db24b37d3)\(z\) + [creal](MATH.md#ga24b1a511efdb973354d81646c5c3bb81)\(z\)\).
**Returns:**
Returns the absolute value of **z** if the operation is successful.
## cabsf\(\)
```
float cabsf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the absolute value of the complex number **z**.
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose absolute value is to be obtained.

**Attention:**
If an error occurs or **z** is a positive or negative infinity or [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), the returned value is calculated based on the formula [hypot](MATH.md#ga6d6a905f61d535f8454190433b8c0ea5)\([cimag](MATH.md#ga6c3d7c875ae93700b0a2a32db24b37d3)\(z\) + [creal](MATH.md#ga24b1a511efdb973354d81646c5c3bb81)\(z\)\).
**Returns:**
Returns the absolute value of **z** if the operation is successful.
## cabsl\(\)
```
long double cabsl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the absolute value of the complex number **z**.
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose absolute value is to be obtained.

**Attention:**
If an error occurs or **z** is a positive or negative infinity or [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), the returned value is calculated based on the formula [hypot](MATH.md#ga6d6a905f61d535f8454190433b8c0ea5)\([cimag](MATH.md#ga6c3d7c875ae93700b0a2a32db24b37d3)\(z\) + [creal](MATH.md#ga24b1a511efdb973354d81646c5c3bb81)\(z\)\).
**Returns:**
Returns the absolute value of **z** if the operation is successful.
## cacos\(\)
```
double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) cacos (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the arc cosine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose arc cosine is to be obtained.

**Returns:**
Returns the arc cosine of **z** if the operation is successful. If **x** is **+0** or **-0** and **y** is **0**, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f) - 0i**. If **x** is **+0** or **-0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is not an infinity and **y** is an infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f) - [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)i**. If **x** is neither an infinity nor **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is a positive finite value, this function returns **[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3) - [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)i**. If **x** is a negative infinity and **y** is a positive infinity, this function returns **3\*[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22) - [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)i**. If **x** and **y** are both positive infinity, this function returns **[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22) - [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)i**. If **x** is a positive or negative infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) +\(-\) [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)i** \(the sign bit of the imaginary part of the returned value is uncertain\). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not an infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) - [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)i**. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## cacosf\(\)
```
float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) cacosf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the arc cosine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose arc cosine is to be obtained.

**Returns:**
Returns the arc cosine of **z** if the operation is successful. If **x** is **+0** or **-0** and **y** is **0**, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f) - 0i**. If **x** is **+0** or **-0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is not an infinity and **y** is an infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)-[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)i**. If **x** is neither an infinity nor **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is a positive finite value, this function returns **[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3) - [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)i**. If **x** is a negative infinity and **y** is a positive infinity, this function returns **3\*[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22) - [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)i**. If **x** and **y** are both positive infinity, this function returns **[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22) - [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)i**. If **x** is a positive or negative infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) +\(-\) [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)i** \(the sign bit of the imaginary part of the returned value is uncertain\). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not an infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) - [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)i**. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## cacosh\(\)
```
double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) cacosh (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the inverse hyperbolic cosine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose inverse hyperbolic cosine is to be obtained.

**Returns:**
Returns the inverse hyperbolic cosine of **z** if the operation is successful. If **x** is **0** and **y** is **0**, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) +\(-\) [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i** \(the sign bit of the imaginary part of the returned value is uncertain\). If **x** is not an infinity and **y** is a positive infinity, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is neither an infinity nor **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is a positive finite value, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)i**. If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)**. If **x** is a negative infinity and **y** is a positive infinity, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + 3\*[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)i**. If **x** is an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not an infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## cacoshf\(\)
```
float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) cacoshf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the inverse hyperbolic cosine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose inverse hyperbolic cosine is to be obtained.

**Returns:**
Returns the inverse hyperbolic cosine of **z** if the operation is successful. If **x** is **0** and **y** is **0**, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) +\(-\) [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i** \(the sign bit of the imaginary part of the returned value is uncertain\). If **x** is not an infinity and **y** is a positive infinity, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is neither an infinity nor **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is a positive finite value, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)i**. If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)**. If **x** is a negative infinity and **y** is a positive infinity, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + 3\*[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)i**. If **x** is an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not an infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## cacoshl\(\)
```
long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) cacoshl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the inverse hyperbolic cosine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose inverse hyperbolic cosine is to be obtained.

**Returns:**
Returns the inverse hyperbolic cosine of **z** if the operation is successful. If **x** is **0** and **y** is **0**, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) +\(-\) [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i** \(the sign bit of the imaginary part of the returned value is uncertain\). If **x** is not an infinity and **y** is a positive infinity, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is neither an infinity nor **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is a positive finite value, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)i**. If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)**. If **x** is a negative infinity and **y** is a positive infinity, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + 3\*[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)i**. If **x** is an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not an infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## cacosl\(\)
```
long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) cacosl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the arc cosine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose arc cosine is to be obtained.

**Returns:**
Returns the arc cosine of **z** if the operation is successful. If **x** is **+0** or **-0** and **y** is **0**, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f) - 0i**. If **x** is **+0** or **-0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is not an infinity and **y** is an infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)-[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)i**. If **x** is neither an infinity nor **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is a positive finite value, this function returns **[M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3) - [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)i**. If **x** is a negative infinity and **y** is a positive infinity, this function returns **3\*[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22) - [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)i**. If **x** and **y** are both positive infinity, this function returns **[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22) - [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)i**. If **x** is a positive or negative infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) +\(-\) [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)i** \(the sign bit of the imaginary part of the returned value is uncertain\). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not an infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) - [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)i**. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## carg\(\)
```
double carg (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the phase angle of the complex number **z**.
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose phase angle is to be obtained.

**Attention:**
If an error occurs or **z** is a positive or negative infinity or [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), the returned value is calculated based on the formula [atan2](MATH.md#ga349377202ca14f79eb335b1a421fe4d8)\([cimag](MATH.md#ga6c3d7c875ae93700b0a2a32db24b37d3)\(z\) + [creal](MATH.md#ga24b1a511efdb973354d81646c5c3bb81)\(z\)\).
**Returns:**
Returns the phase angle of **z** if the operation is successful.
## cargf\(\)
```
float cargf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the phase angle of the complex number **z**.
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose phase angle is to be obtained.

**Attention:**
If an error occurs or **z** is a positive or negative infinity or [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), the returned value is calculated based on the formula [atan2](MATH.md#ga349377202ca14f79eb335b1a421fe4d8)\([cimag](MATH.md#ga6c3d7c875ae93700b0a2a32db24b37d3)\(z\) + [creal](MATH.md#ga24b1a511efdb973354d81646c5c3bb81)\(z\)\).
**Returns:**
Returns the phase angle of **z** if the operation is successful.
## cargl\(\)
```
long double cargl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the phase angle of the complex number **z**.
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose hyperbolic sine is to be obtained.

**Attention:**
If an error occurs or **z** is a positive or negative infinity or [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), the returned value is calculated based on the formula [atan2](MATH.md#ga349377202ca14f79eb335b1a421fe4d8)\([cimag](MATH.md#ga6c3d7c875ae93700b0a2a32db24b37d3)\(z\) + [creal](MATH.md#ga24b1a511efdb973354d81646c5c3bb81)\(z\)\).
**Returns:**
Returns the phase angle of **z** if the operation is successful.
## casin\(\)
```
double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) casin (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the arc sine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose arc sine is to be obtained.

**Returns:**
Returns the arc sine of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is a positive finite value and **y** is a positive infinity, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is not an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)**. If **x** and **y** are both positive infinity, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)i**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **+\(-\)[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## casinf\(\)
```
float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) casinf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the arc sine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose arc sine is to be obtained.

**Returns:**
Returns the arc sine of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is a positive finite value and **y** is a positive infinity, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is not an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)**. If **x** and **y** are both positive infinity, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)i**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **+\(-\)[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## casinh\(\)
```
double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) casinh (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the inverse hyperbolic sine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose inverse hyperbolic sine is to be obtained.

**Returns:**
Returns the inverse hyperbolic sine of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is a positive finite value and **y** is a positive infinity, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is not an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)**. If **x** and **y** are both positive infinity, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)i**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **+\(-\)[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## casinhf\(\)
```
float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) casinhf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the inverse hyperbolic sine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose inverse hyperbolic sine is to be obtained.

**Returns:**
Returns the inverse hyperbolic sine of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is a positive finite value and **y** is a positive infinity, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is not an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)**. If **x** and **y** are both positive infinity, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)i**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **+\(-\)[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## casinhl\(\)
```
long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) casinhl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the inverse hyperbolic sine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose inverse hyperbolic sine is to be obtained.

**Returns:**
Returns the inverse hyperbolic sine of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is a positive finite value and **y** is a positive infinity, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is not an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)**. If **x** and **y** are both positive infinity, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)i**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **+\(-\)[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## casinl\(\)
```
long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) casinl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the arc sine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose arc sine is to be obtained.

**Returns:**
Returns the arc sine of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is a positive finite value and **y** is a positive infinity, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is not an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)**. If **x** and **y** are both positive infinity, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)i**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **+\(-\)[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## catan\(\)
```
double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) catan (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the arc tangent of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose arc tangent is to be obtained.

**Returns:**
Returns the arc tangent of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is **1** and **y** is **0**, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)** and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception. If **x** is a positive finite value and **y** is a positive infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is neither an infinity nor **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is a positive finite value, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** and **y** are both positive infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not an infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## catanf\(\)
```
float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) catanf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the arc tangent of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose arc tangent is to be obtained.

**Returns:**
Returns the arc tangent of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is **1** and **y** is **0**, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)** and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception. If **x** is a positive finite value and **y** is a positive infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is neither an infinity nor **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is a positive finite value, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** and **y** are both positive infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not an infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## catanh\(\)
```
double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) catanh (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the inverse hyperbolic tangent of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose inverse hyperbolic tangent is to be obtained.

**Returns:**
Returns the inverse hyperbolic tangent of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is **1** and **y** is **0**, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)** and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception. If **x** is a positive finite value and **y** is a positive infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is neither an infinity nor **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is a positive finite value, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** and **y** are both positive infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not an infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## catanhf\(\)
```
float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) catanhf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the inverse hyperbolic tangent of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose inverse hyperbolic tangent is to be obtained.

**Returns:**
Returns the inverse hyperbolic tangent of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is **1** and **y** is **0**, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)** and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception. If **x** is a positive finite value and **y** is a positive infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is neither an infinity nor **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is a positive finite value, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** and **y** are both positive infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not an infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## catanhl\(\)
```
long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) catanhl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the inverse hyperbolic tangent of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose inverse hyperbolic tangent is to be obtained.

**Returns:**
Returns the inverse hyperbolic tangent of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is **1** and **y** is **0**, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)** and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception. If **x** is a positive finite value and **y** is a positive infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is neither an infinity nor **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is a positive finite value, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** and **y** are both positive infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not an infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## catanl\(\)
```
long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) catanl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the arc tangent of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose arc tangent is to be obtained.

**Returns:**
Returns the arc tangent of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is **1** and **y** is **0**, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)** and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception. If **x** is a positive finite value and **y** is a positive infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is neither an infinity nor **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is a positive finite value, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** and **y** are both positive infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not an infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## cbrt\(\)
```
double cbrt (double x)
```
**Description:**
Calculates the cube root of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value whose cube root is to be calculated.

**Returns:**
Returns the cube root if the operation is successful; returns the passed **x** if **x** is **+0**, **-0**, a positive or negative infinity, or a NaN value.
## cbrtf\(\)
```
float cbrtf (float x)
```
**Description:**
Calculates the cube root of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value whose cube root is to be calculated.

**Returns:**
Returns the cube root if the operation is successful; returns the passed **x** if **x** is **+0**, **-0**, a positive or negative infinity, or a NaN value.
## cbrtl\(\)
```
long double cbrtl (long double x)
```
**Description:**
Calculates the cube root of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value whose cube root is to be calculated.

**Returns:**
Returns the cube root if the operation is successful; returns the passed **x** if **x** is **+0**, **-0**, a positive or negative infinity, or a NaN value.
## ccos\(\)
```
double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) ccos (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the cosine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose cosine is to be obtained.

**Returns:**
Returns the cosine of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **1**. If **x** is **0** and **y** is a positive infinity, this function returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971). If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is a negative infinity and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is a positive infinity, this function returns **+\(-\)[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\) and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is neither an infinity nor **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive or negative infinity, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is neither an infinity nor **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## ccosf\(\)
```
float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) ccosf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the cosine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose cosine is to be obtained.

**Returns:**
Returns the cosine of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **1**. If **x** is **0** and **y** is a positive infinity, this function returns [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359). If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is a negative infinity and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is a positive infinity, this function returns **+\(-\)[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\) and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is neither an infinity nor **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive or negative infinity, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is neither an infinity nor **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## ccosh\(\)
```
double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) ccosh (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the hyperbolic cosine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose hyperbolic cosine is to be obtained.

**Returns:**
Returns the hyperbolic cosine of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **1**. If **x** is **0** and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is neither an infinity nor **0** and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is **0**, this function returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971). If **x** is a positive infinity and **y** is a positive infinity, this function returns **+\(-\)[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\) and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive or negative infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is neither an infinity nor **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## ccoshf\(\)
```
float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) ccoshf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the hyperbolic cosine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose hyperbolic cosine is to be obtained.

**Returns:**
Returns the hyperbolic cosine of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **1**. If **x** is **0** and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is neither an infinity nor **0** and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is **0**, this function returns [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359). If **x** is a positive infinity and **y** is a positive infinity, this function returns **+\(-\)[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\) and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive or negative infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is neither an infinity nor **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## ccoshl\(\)
```
long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) ccoshl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the hyperbolic cosine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose hyperbolic cosine is to be obtained.

**Returns:**
Returns the hyperbolic cosine of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **1**. If **x** is **0** and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is neither an infinity nor **0** and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is **0**, this function returns [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182). If **x** is a positive infinity and **y** is a positive infinity, this function returns **+\(-\)[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\) and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive or negative infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is neither an infinity nor **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## ccosl\(\)
```
long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) ccosl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the cosine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose cosine is to be obtained.

**Returns:**
Returns the cosine of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **1**. If **x** is **0** and **y** is a positive infinity, this function returns [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182). If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is a negative infinity and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is a positive infinity, this function returns **+\(-\)[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\) and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is neither an infinity nor **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive or negative infinity, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is neither an infinity nor **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## ceil\(\)
```
double ceil (double x)
```
**Description:**
Calculates the minimum integer greater than or equal to the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value x to compare with.

**Returns:**
Returns the minimum integer greater than or equal to **x** if the operation is successful; returns the passed **x** if **x** is an integer, **+0**, **-0**, a NaN value, or an infinity.
## ceilf\(\)
```
float ceilf (float x)
```
**Description:**
Calculates the minimum integer greater than or equal to the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value x to compare with.

**Returns:**
Returns the minimum integer greater than or equal to **x** if the operation is successful; returns the passed **x** if **x** is an integer, **+0**, **-0**, a NaN value, or an infinity.
## ceill\(\)
```
long double ceill (long double x)
```
**Description:**
Calculates the minimum integer greater than or equal to the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value x to compare with.

**Returns:**
Returns the minimum integer greater than or equal to **x** if the operation is successful; returns the passed **x** if **x** is an integer, **+0**, **-0**, a NaN value, or an infinity.
## cexp\(\)
```
double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) cexp (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the base-e exponential of the complex number **z**.
The mathematical formula is e^z. z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose base-e exponential is to be obtained.

**Returns:**
Returns the base-e exponential of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **1**. If **x** is not an infinity and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is not an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is **0**, this function returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971). If **x** is a negative infinity and **y** is an infinity or [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **0**. If **x** is a positive infinity and **y** is neither an infinity nor **0**, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)\*\([cos](MATH.md#ga5e7b53a694b3cf0f2d7debd444140fbd)\(y\) + i[sin](MATH.md#gaad4af25633b071b0e2cdb8ebd87eca77)\(y\)\)**. If **x** and **y** are both positive infinity, this function returns **+\(-\)[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\) and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **+\(-\)[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## cexpf\(\)
```
float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) cexpf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the base-e exponential of the complex number **z**.
The mathematical formula is e^z. z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose base-e exponential is to be obtained.

**Returns:**
Returns the base-e exponential of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **1**. If **x** is not an infinity and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is not an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is **0**, this function returns [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359). If **x** is a negative infinity and **y** is an infinity or [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **0**. If **x** is a positive infinity and **y** is neither an infinity nor **0**, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)\*\([cos](MATH.md#ga5e7b53a694b3cf0f2d7debd444140fbd)\(y\) + i[sin](MATH.md#gaad4af25633b071b0e2cdb8ebd87eca77)\(y\)\)**. If **x** and **y** are both positive infinity, this function returns **+\(-\)[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\) and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **+\(-\) [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## cexpl\(\)
```
long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) cexpl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the base-e exponential of the complex number **z**.
The mathematical formula is e^z. z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose base-e exponential is to be obtained.

**Returns:**
Returns the base-e exponential of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **1**. If **x** is not an infinity and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is not an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is **0**, this function returns [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182). If **x** is a negative infinity and **y** is an infinity or [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **0**. If **x** is a positive infinity and **y** is neither an infinity nor **0**, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)\*\([cos](MATH.md#ga5e7b53a694b3cf0f2d7debd444140fbd)\(y\) + i[sin](MATH.md#gaad4af25633b071b0e2cdb8ebd87eca77)\(y\)\)**. If **x** and **y** are both positive infinity, this function returns **+\(-\)[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\) and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **+\(-\)[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## cimag\(\)
```
double cimag (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the imaginary part of the complex number **z**.

**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose imaginary part is to be obtained.

**Returns:**
Returns the imaginary part of **z** if the operation is successful.
## cimagf\(\)
```
float cimagf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the imaginary part of the complex number **z**.

**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose imaginary part is to be obtained.

**Returns:**
Returns the imaginary part of **z** if the operation is successful.
## cimagl\(\)
```
long double cimagl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the imaginary part of the complex number **z**.

**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose imaginary part is to be obtained.

**Returns:**
Returns the imaginary part of **z** if the operation is successful.
## clog\(\)
```
double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) clog (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the natural \(base-e\) logarithm of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose natural (base-e) logarithm is to be obtained.

**Returns:**
Returns the natural \(base-e\) logarithm of **z** if the operation is successful. If **x** is **-0** and **y** is **+0**, this function returns **-[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)i** and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception. If **x** and **y** are both **+0**, this function returns **-[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + 0i** and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception. If **x** is not an infinity and **y** is a positive infinity, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is not an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is a positive finite value, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)i**. If **x** is a negative infinity and **y** is a positive infinity, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + 3\*[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)i**. If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + 0i**. If **x** and **y** are both positive infinity, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)i**. If **x** is an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not an infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## clogf\(\)
```
float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) clogf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the natural \(base-e\) logarithm of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose natural (base-e) logarithm is to be obtained.

**Returns:**
Returns the natural \(base-e\) logarithm of **z** if the operation is successful. If **x** is **-0** and **y** is **+0**, this function returns **-[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)i** and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception. If **x** and **y** are both **+0**, this function returns **-[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + 0i** and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception. If **x** is not an infinity and **y** is a positive infinity, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is not an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is a positive finite value, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)i**. If **x** is a negative infinity and **y** is a positive infinity, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + 3\*[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)i**. If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + 0i**. If **x** and **y** are both positive infinity, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)i**. If **x** is an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not an infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## clogl\(\)
```
long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) clogl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the natural \(base-e\) logarithm of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose natural (base-e) logarithm is to be obtained.

**Returns:**
Returns the natural \(base-e\) logarithm of **z** if the operation is successful. If **x** is **-0** and **y** is **+0**, this function returns **-[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)i** and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception. If **x** and **y** are both **+0**, this function returns **-[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + 0i** and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception. If **x** is not an infinity and **y** is a positive infinity, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [M\_PI\_2](MATH.md#ga958e4508ed28ee5cc04249144312c15f)i**. If **x** is not an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is a positive finite value, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [M\_PI](MATH.md#gae71449b1cc6e6250b91f539153a7a0d3)i**. If **x** is a negative infinity and **y** is a positive infinity, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + 3\*[M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)i**. If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + 0i**. If **x** and **y** are both positive infinity, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [M\_PI\_4](MATH.md#gaeb24420b096a677f3a2dc5a72b36bf22)i**. If **x** is an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not an infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## conj\(\)
```
double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) conj (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the conjugate of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose conjugate is to be obtained.

**Returns:**
Returns the conjugate of **z**, which is equal to x - yi.
## conjf\(\)
```
float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) conjf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the conjugate of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose conjugate is to be obtained.

**Returns:**
Returns the conjugate of **z**, which is equal to x - yi.
## conjl\(\)
```
long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) conjl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the conjugate of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose conjugate is to be obtained.

**Returns:**
Returns the conjugate of **z**, which is equal to x - yi.
## copysign\(\)
```
double copysign (double x, double y )
```
**Description:**
Generates a value by combining the magnitude of the double value **x** and the sign of the double value **y**.
For example, if **x** is **42.0** and **y** is **-1.0**, value **-42.0** will be generated.
**Parameters:**

Name	Description
x	Indicates the double value x whose magnitude will be used.
y	Indicates the double value y whose sign will be used.

**Returns:**
Returns the generated value if the operation is successful; returns a NaN value with the sign of **y** if **x** is a NaN value.
## copysignf\(\)
```
float copysignf (float x, float y )
```
**Description:**
Generates a value by combining the magnitude of the float value **x** and the sign of the float value **y**.
For example, if **x** is **42.0** and **y** is **-1.0**, value **-42.0** will be generated.
**Parameters:**

Name	Description
x	Indicates the float value x whose magnitude will be used.
y	Indicates the float value y whose sign will be used.

**Returns:**
Returns the generated value if the operation is successful; returns a NaN value with the sign of **y** if **x** is a NaN value.
## copysignl\(\)
```
long double copysignl (long double x, long double y )
```
**Description:**
Generates a value by combining the magnitude of the long double value **x** and the sign of the long double value **y**.
For example, if **x** is **42.0** and **y** is **-1.0**, value **-42.0** will be generated.
**Parameters:**

Name	Description
x	Indicates the long double value x whose magnitude will be used.
y	Indicates the long double value y whose magnitude will be used.

**Returns:**
Returns the generated value if the operation is successful; returns a NaN value with the sign of **y** if **x** is a NaN value.
## cos\(\)
```
double cos (double x)
```
**Description:**
Calculates the cosine of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the cosine of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive or negative infinity, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## cosf\(\)
```
float cosf (float x)
```
**Description:**
Calculates the cosine of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the cosine of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive or negative infinity, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## cosh\(\)
```
double cosh (double x)
```
**Description:**
Calculates the hyperbolic cosine of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the hyperbolic cosine of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **1**. If **x** is a positive or negative infinity, this function returns a positive infinity. If an overflow range error occurs, this function returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971), sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception.
## coshf\(\)
```
float coshf (float x)
```
**Description:**
Calculates the hyperbolic cosine of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the hyperbolic cosine of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **1**. If **x** is a positive or negative infinity, this function returns a positive infinity. If an overflow range error occurs, this function returns [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359), sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception.
## coshl\(\)
```
long double coshl (long double x)
```
**Description:**
Calculates the hyperbolic cosine of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Returns:**
Returns the hyperbolic cosine of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **1**. If **x** is a positive or negative infinity, this function returns a positive infinity. If an overflow range error occurs, this function returns [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182), sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception.
## cosl\(\)
```
long double cosl (long double x)
```
**Description:**
Calculates the cosine of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Returns:**
Returns the cosine of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive or negative infinity, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## cpow\(\)
```
double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) cpow (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) x, double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z )
```
**Description:**
Calculates the value of **x** raised to the **z** power.
The mathematical formula is x^z.
**Parameters:**

Name	Description
x	Indicates the base (a double complex number).
z	Indicates the exponent (a double complex number).

**Attention:**
If an error occurs or **x** or **z** is a positive or negative infinity or [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), the returned value is calculated based on the formula [cexp](MATH.md#gab9c654c52efefb54d06d52aa1a1c1827)\(z\*[clog](MATH.md#gaa39c3557d8db10c19571bc0b63fd5529)\(x\)\).
**Returns:**
Returns the value of **x** raised to the **z** power if the operation is successful.
## cpowf\(\)
```
float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) cpowf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) x, float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z )
```
**Description:**
Calculates the value of **x** raised to the **z** power.
The mathematical formula is x^z.
**Parameters:**

Name	Description
x	Indicates the base (a float complex number).
z	Indicates the exponent (a float complex number).

**Attention:**
If an error occurs or **x** or **z** is a positive or negative infinity or [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), the returned value is calculated based on the formula [cexp](MATH.md#gab9c654c52efefb54d06d52aa1a1c1827)\(z\*[clog](MATH.md#gaa39c3557d8db10c19571bc0b63fd5529)\(x\)\).
**Returns:**
Returns the value of **x** raised to the **z** power if the operation is successful.
## cpowl\(\)
```
long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) cpowl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) x, long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z )
```
**Description:**
Calculates the value of **x** raised to the **z** power.
The mathematical formula is x^z.
**Parameters:**

Name	Description
x	Indicates the base (a long double complex number).
z	Indicates the exponent (a long double complex number).

**Attention:**
If an error occurs or **x** or **z** is a positive or negative infinity or [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), the returned value is calculated based on the formula [cexp](MATH.md#gab9c654c52efefb54d06d52aa1a1c1827)\(z\*[clog](MATH.md#gaa39c3557d8db10c19571bc0b63fd5529)\(x\)\).
**Returns:**
Returns the value of **x** raised to the **z** power if the operation is successful.
## cproj\(\)
```
double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) cproj (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the projection of the complex number **z** onto the Riemann sphere.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose projection onto the Riemann sphere is to be obtained.

**Returns:**
Returns the projection of **z** onto the Riemann sphere if the operation is successful. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is an infinity, this function returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971). If **x** is an infinity, this function returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + i\*[copysign](MATH.md#gad8d1296592a3e783acdd0de21ff58e2e)\(0.0, [cimag](MATH.md#ga6c3d7c875ae93700b0a2a32db24b37d3)\(z\)\).
## cprojf\(\)
```
float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) cprojf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the projection of the complex number **z** onto the Riemann sphere.
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose projection onto the Riemann sphere is to be obtained.

**Returns:**
Returns the projection of **z** onto the Riemann sphere if the operation is successful. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is an infinity, this function returns [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359). If **x** is an infinity, this function returns [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + i\*[copysign](MATH.md#gad8d1296592a3e783acdd0de21ff58e2e)\(0.0, [cimag](MATH.md#ga6c3d7c875ae93700b0a2a32db24b37d3)\(z\)\).
## cprojl\(\)
```
long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) cprojl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the projection of the complex number **z** onto the Riemann sphere.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose projection onto the Riemann sphere is to be obtained.

**Returns:**
Returns the projection of **z** onto the Riemann sphere if the operation is successful. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is an infinity, this function returns [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182). If **x** is an infinity, this function returns [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + i\*[copysign](MATH.md#gad8d1296592a3e783acdd0de21ff58e2e)\(0.0, [cimag](MATH.md#ga6c3d7c875ae93700b0a2a32db24b37d3)\(z\)\).
## creal\(\)
```
double creal (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the real part of the complex number **z**.
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose real part is to be obtained.

**Returns:**
Returns the real part of **z** if the operation is successful.
## crealf\(\)
```
float crealf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the real part of the complex number **z**.
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose real part is to be obtained.

**Returns:**
Returns the real part of **z** if the operation is successful.
## creall\(\)
```
long double creall (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the real part of the complex number **z**.
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose real part is to be obtained.

**Returns:**
Returns the real part of **z** if the operation is successful.
## csin\(\)
```
double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) csin (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the sine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose sine is to be obtained.

**Returns:**
Returns the sine of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is **0** and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is a positive finite value and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive finite value and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is **0**, this function returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971). If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)\*\([cos](MATH.md#ga5e7b53a694b3cf0f2d7debd444140fbd)\(y\) + i[sin](MATH.md#gaad4af25633b071b0e2cdb8ebd87eca77)\(y\)\)**. If **x** and **y** are both positive infinity, this function returns **+\(-\)[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\) and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **+\(-\)[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## csinf\(\)
```
float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) csinf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the sine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose sine is to be obtained.

**Returns:**
Returns the sine of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is **0** and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is a positive finite value and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive finite value and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is **0**, this function returns [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359). If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)\*\([cos](MATH.md#ga5e7b53a694b3cf0f2d7debd444140fbd)\(y\) + i[sin](MATH.md#gaad4af25633b071b0e2cdb8ebd87eca77)\(y\)\)**. If **x** and **y** are both positive infinity, this function returns **+\(-\)[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\) and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **+\(-\) [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## csinh\(\)
```
double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) csinh (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the hyperbolic sine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose hyperbolic sine is to be obtained.

**Returns:**
Returns the hyperbolic sine of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is **0** and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is a positive finite value and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive finite value and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is **0**, this function returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971). If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)\*\([cos](MATH.md#ga5e7b53a694b3cf0f2d7debd444140fbd)\(y\) + i[sin](MATH.md#gaad4af25633b071b0e2cdb8ebd87eca77)\(y\)\)**. If **x** and **y** are both positive infinity, this function returns **+\(-\)[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\) and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **+\(-\)[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## csinhf\(\)
```
float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) csinhf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the hyperbolic sine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose hyperbolic sine is to be obtained.

**Returns:**
Returns the hyperbolic sine of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is **0** and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is a positive finite value and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive finite value and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is **0**, this function returns [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359). If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)\*\([cos](MATH.md#ga5e7b53a694b3cf0f2d7debd444140fbd)\(y\) + i[sin](MATH.md#gaad4af25633b071b0e2cdb8ebd87eca77)\(y\)\)**. If **x** and **y** are both positive infinity, this function returns **+\(-\)[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\) and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **+\(-\) [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## csinhl\(\)
```
long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) csinhl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the hyperbolic sine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose hyperbolic sine is to be obtained.

**Returns:**
Returns the hyperbolic sine of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is **0** and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is a positive finite value and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive finite value and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is **0**, this function returns [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182). If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)\*\([cos](MATH.md#ga5e7b53a694b3cf0f2d7debd444140fbd)\(y\) + i[sin](MATH.md#gaad4af25633b071b0e2cdb8ebd87eca77)\(y\)\)**. If **x** and **y** are both positive infinity, this function returns **+\(-\)[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\) and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **+\(-\)[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## csinl\(\)
```
long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) csinl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the sine of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose sine is to be obtained.

**Returns:**
Returns the sine of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is **0** and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is **0** and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is a positive finite value and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive finite value and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is **0**, this function returns [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182). If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)\*\([cos](MATH.md#ga5e7b53a694b3cf0f2d7debd444140fbd)\(y\) + i[sin](MATH.md#gaad4af25633b071b0e2cdb8ebd87eca77)\(y\)\)**. If **x** and **y** are both positive infinity, this function returns **+\(-\)[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\) and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **+\(-\)[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** \(the sign bit of the real part of the returned value is uncertain\). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## csqrt\(\)
```
double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) csqrt (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the square root of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose square root is to be obtained.

**Returns:**
Returns the square root of **z** if the operation is successful. If **x** is **+0** or **-0** and **y** is **+0**, this function returns **+0 + 0i**. If **x** is neither an infinity nor [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)i**. If **x** is a finite value or [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is a positive finite value, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)i**. If **x** is a negative infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) +\(-\) [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)i** \(the sign bit of the imaginary part of the returned value is uncertain\). If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + 0i**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is any value, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## csqrtf\(\)
```
float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) csqrtf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the square root of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose square root is to be obtained.

**Returns:**
Returns the square root of **z** if the operation is successful. If **x** is **+0** or **-0** and **y** is **+0**, this function returns **+0 + 0i**. If **x** is neither an infinity nor [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)i**. If **x** is a finite value or [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is a positive finite value, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)i**. If **x** is a negative infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) +\(-\) [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)i** \(the sign bit of the imaginary part of the returned value is uncertain\). If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + 0i**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is any value, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## csqrtl\(\)
```
long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) csqrtl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the square root of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose square root is to be obtained.

**Returns:**
Returns the square root of **z** if the operation is successful. If **x** is **+0** or **-0** and **y** is **+0**, this function returns **+0 + 0i**. If **x** is neither an infinity nor [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is a positive infinity, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)i**. If **x** is a finite value or [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative infinity and **y** is a positive finite value, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)i**. If **x** is a negative infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) +\(-\) [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)i** \(the sign bit of the imaginary part of the returned value is uncertain\). If **x** is a positive infinity and **y** is a positive finite value, this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) + 0i**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)+[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is any value, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## ctan\(\)
```
double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) ctan (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the tangent of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose tangent is to be obtained.

**Returns:**
Returns the tangent of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is not an infinity and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is not an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is a positive finite value, this function returns **1**. If **x** and **y** are both positive infinity, this function returns **1**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **1**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## ctanf\(\)
```
float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) ctanf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the tangent of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose tangent is to be obtained.

**Returns:**
Returns the tangent of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is not an infinity and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is not an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is a positive finite value, this function returns **1**. If **x** and **y** are both positive infinity, this function returns **1**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **1**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## ctanh\(\)
```
double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) ctanh (double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the hyperbolic tangent of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a double value) whose hyperbolic tangent is to be obtained.

**Returns:**
Returns the hyperbolic tangent of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is not an infinity and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is not an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is a positive finite value, this function returns **1**. If **x** and **y** are both positive infinity, this function returns **1**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **1**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## ctanhf\(\)
```
float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) ctanhf (float [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the hyperbolic tangent of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a float value) whose hyperbolic tangent is to be obtained.

**Returns:**
Returns the hyperbolic tangent of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is not an infinity and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is not an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is a positive finite value, this function returns **1**. If **x** and **y** are both positive infinity, this function returns **1**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **1**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## ctanhl\(\)
```
long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) ctanhl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the hyperbolic tangent of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose hyperbolic tangent is to be obtained.

**Returns:**
Returns the hyperbolic tangent of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is not an infinity and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is not an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is a positive finite value, this function returns **1**. If **x** and **y** are both positive infinity, this function returns **1**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **1**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## ctanl\(\)
```
long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) ctanl (long double [complex](MATH.md#ga0fa4878c968311979d497ccc322e0b9b) z)
```
**Description:**
Calculates the tangent of the complex number **z**.
z = x + yi, where i = [sqrt](MATH.md#gab87521a75ef827a85807f89a6c10629a)\(-1\)
**Parameters:**

Name	Description
z	Indicates the complex number (a long double value) whose tangent is to be obtained.

**Returns:**
Returns the tangent of **z** if the operation is successful. If **x** and **y** are both **0**, this function returns **0**. If **x** is not an infinity and **y** is a positive infinity, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is not an infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and may throw the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a positive infinity and **y** is a positive finite value, this function returns **1**. If **x** and **y** are both positive infinity, this function returns **1**. If **x** is a positive infinity and **y** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **1**. If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is **0**, this function returns [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc). If **x** is [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) and **y** is not **0**, this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i** and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** and **y** are both [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc), this function returns **[NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc) + [NAN](MATH.md#ga8abfcc76130f3f991d124dd22d7e69bc)i**.
## erf\(\)
```
double erf (double x)
```
**Description:**
Calculates the error function of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the error function if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**, respectively. If **x** is a positive or negative infinity, this function returns **+1** or **-1**, respectively. If an underflow range error occurs, this function returns **2\*x/sqrt\(pi\)** and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception.
## erfc\(\)
```
double erfc (double x)
```
**Description:**
Calculates the complementary error function of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the complementary error function if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **1**. If **x** is a positive infinity, this function returns **+0**. If **x** is a negative infinity, this function returns **+2**. If an underflow range error occurs and an unrepresentable value is generated, this function returns **0.0**. If an underflow range error occurs and a representable value is generated, this function returns **0** and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception.
## erfcf\(\)
```
float erfcf (float x)
```
**Description:**
Calculates the complementary error function of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the complementary error function if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **1**. If **x** is a positive infinity, this function returns **+0**. If **x** is a negative infinity, this function returns **+2**. If an underflow range error occurs and an unrepresentable value is generated, this function returns **0.0**. If an underflow range error occurs and a representable value is generated, this function returns **0** and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception.
## erfcl\(\)
```
long double erfcl (long double x)
```
**Description:**
Calculates the complementary error function of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Returns:**
Returns the complementary error function if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **1**. If **x** is a positive infinity, this function returns **+0**. If **x** is a negative infinity, this function returns **+2**. If an underflow range error occurs and an unrepresentable value is generated, this function returns **0.0**. If an underflow range error occurs and a representable value is generated, this function returns **0** and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception.
## erff\(\)
```
float erff (float x)
```
**Description:**
Calculates the error function of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the error function if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**, respectively. If **x** is a positive or negative infinity, this function returns **+1** or **-1**, respectively. If an underflow range error occurs, this function returns **2\*x/sqrt\(pi\)** and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception.
## erfl\(\)
```
long double erfl (long double x)
```
**Description:**
Calculates the error function of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Returns:**
Returns the error function if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**, respectively. If **x** is a positive or negative infinity, this function returns **+1** or **-1**, respectively. If an underflow range error occurs, this function returns **2\*x/sqrt\(pi\)** and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception.
## exp\(\)
```
double exp (double x)
```
**Description:**
Calculates the base-e exponential function of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the base-e exponential function of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is a negative infinity, this function returns **+0**. If an underflow range error occurs, this function returns **0**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception. If an overflow range error occurs, this function returns **+[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception.
## exp10\(\)
```
double exp10 (double x)
```
**Description:**
Calculates the base-10 exponential function of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value x used as the exponent.

**Returns:**
Returns the base-10 exponential function of **x** if the operation is successful.
## exp10f\(\)
```
float exp10f (float x)
```
**Description:**
Calculates the base-10 exponential function of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value x used as the exponent.

**Returns:**
Returns the base-10 exponential function of **x** if the operation is successful.
## exp10l\(\)
```
long double exp10l (long double x)
```
**Description:**
Calculates the base-10 exponential function of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value x used as the exponent.

**Returns:**
Returns the base-10 exponential function of **x** if the operation is successful.
## exp2\(\)
```
double exp2 (double x)
```
**Description:**
Calculates the base-2 exponential function of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the base-2 exponential function of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is a negative infinity, this function returns **+0**. If an underflow range error occurs, this function returns **0**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception. If an overflow range error occurs, this function returns **+[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception.
## exp2f\(\)
```
float exp2f (float x)
```
**Description:**
Calculates the base-2 exponential function of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the base-2 exponential function of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is a negative infinity, this function returns **+0**. If an underflow range error occurs, this function returns **0**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception. If an overflow range error occurs, this function returns **+[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception.
## exp2l\(\)
```
long double exp2l (long double x)
```
**Description:**
Calculates the base-2 exponential function of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Returns:**
Returns the base-2 exponential function of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is a negative infinity, this function returns **+0**. If an underflow range error occurs, this function returns **0**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception. If an overflow range error occurs, this function returns **+[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception.
## expf\(\)
```
float expf (float x)
```
**Description:**
Calculates the base-e exponential function of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the base-e exponential function of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is a negative infinity, this function returns **+0**. If an underflow range error occurs, this function returns **0**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception. If an overflow range error occurs, this function returns **+[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception.
## expl\(\)
```
long double expl (long double x)
```
**Description:**
Calculates the base-e exponential function of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Returns:**
Returns the base-e exponential function of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is a negative infinity, this function returns **+0**. If an underflow range error occurs, this function returns **0**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception. If an overflow range error occurs, this function returns **+[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception.
## expm1\(\)
```
double expm1 (double x)
```
**Description:**
Calculates e raised to the power of the double value **x** minus one, that is, \(e^x\)-1.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns e raised to the power of **x** minus one if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**, respectively. If **x** is a positive infinity, this function returns a positive infinity. If **x** is a negative infinity, this function returns **-1**. If an overflow range error occurs, this function returns **+[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception.
## expm1f\(\)
```
float expm1f (float x)
```
**Description:**
Calculates e raised to the power of the float value **x** minus one.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns e raised to the power of **x** minus one if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**, respectively. If **x** is a positive infinity, this function returns a positive infinity. If **x** is a negative infinity, this function returns **-1**. If an overflow range error occurs, this function returns **+[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception.
## expm1l\(\)
```
long double expm1l (long double x)
```
**Description:**
Calculates e raised to the power of the long double value **x** minus one.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Returns:**
Returns e raised to the power of **x** minus one if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**, respectively. If **x** is a positive infinity, this function returns a positive infinity. If **x** is a negative infinity, this function returns **-1**. If an overflow range error occurs, this function returns **+[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception.
## fabs\(\)
```
double fabs (double x)
```
**Description:**
Calculates the absolute value of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the absolute value of **x** if the operation is successful; returns a NaN value if **x** is a NaN value; returns **+0** if **x** is **-0**; returns a positive infinity if **x** is a positive or negative infinity.
## fabsf\(\)
```
float fabsf (float x)
```
**Description:**
Calculates the absolute value of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the absolute value of **x** if the operation is successful; returns a NaN value if **x** is a NaN value; returns **+0** if **x** is **-0**; returns a positive infinity if **x** is a positive or negative infinity.
## fabsl\(\)
```
long double fabsl (long double x)
```
**Description:**
Calculates the absolute value of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Returns:**
Returns the absolute value of **x** if the operation is successful; returns a NaN value if **x** is a NaN value; returns **+0** if **x** is **-0**; returns a positive infinity if **x** is a positive or negative infinity.
## fdim\(\)
```
double fdim (double x, double y )
```
**Description:**
Calculates the positive difference between the double value **x** and **y**.
**Parameters:**

Name	Description
x	Indicates the double value x.
y	Indicates the double value y.

**Returns:**
Returns the positive difference between **x** and **y**.
## fdimf\(\)
```
float fdimf (float x, float y )
```
**Description:**
Calculates the positive difference between the float value **x** and **y**.
**Parameters:**

Name	Description
x	Indicates the float value x.
y	Indicates the float value y.

**Returns:**
Returns the positive difference between **x** and **y**.
## fdiml\(\)
```
long double fdiml (long double x, long double y )
```
**Description:**
Calculates the positive difference between the long double value **x** and **y**.
**Parameters:**

Name	Description
x	Indicates the long double value x.
y	Indicates the long double value y.

**Returns:**
Returns the positive difference between **x** and **y**.
## feclearexcept\(\)
```
int feclearexcept (int excepts)
```
**Description:**
Clears floating-point exceptions specified by **excepts**.
**Parameters:**

Name	Description
excepts	Indicates the floating-point exceptions to clear.

**Returns:**
Returns **0** if the operation is successful; returns a non-zero value otherwise.
## fegetenv\(\)
```
int fegetenv ([fenv_t](fenv_t.md) * envp)
```
**Description:**
Stores the current floating-point environment into the object specified by **envp**.
The floating-point environment contains the current control modes and status flags of floating-point operations.
**Parameters:**

Name	Description
envp	Indicates the pointer to the floating-point environment.

**Returns:**
Returns **0** if the operation is successful; returns a non-zero value otherwise.
## fegetexceptflag\(\)
```
int fegetexceptflag ([fexcept_t](MATH.md#ga3eec78fdb9921de3f7254105f546c624) * flagp, int excepts )
```
**Description:**
Stores the floating-point exceptions specified by **excepts** into the **flagp** variable address.
**Parameters:**

Name	Description
flagp	Indicates the pointer to the floating-point exceptions.
excepts	Indicates the current floating-point exceptions to store.

**Returns:**
Returns **0** if the operation is successful; returns a non-zero value otherwise.
## fegetround\(\)
```
int fegetround (void )
```
**Description:**
Obtains the macro corresponding to the current rounding mode.
The rounding mode can be [FE\_TONEAREST](MATH.md#ga5b5383719a63f98b7c95cc2feccaa1a7), [FE\_UPWARD](MATH.md#ga5aa71a164a4b4d7780570d97058890f1), [FE\_DOWNWARD](MATH.md#ga5e011a345a41ad4622da05932e83536f), or [FE\_TOWARDZERO](MATH.md#gac171099e006285a9e8be5683be71591c).
**Returns:**
Returns the macro corresponding to the current rounding mode.
## feholdexcept\(\)
```
int feholdexcept ([fenv_t](fenv_t.md) * envp)
```
**Description:**
Stores the current floating-point environment into the object specified by **envp**, with all status flags cleared.
**Parameters:**

Name	Description
envp	Indicates the pointer to the floating-point environment.

**Attention:**
This function clears all exception status flags and sets the environment to the non-stop mode \(to continue the execution of the exceptions\), if any.
**Returns:**
Returns **0** if the operation is successful; returns a non-zero value otherwise.
## feraiseexcept\(\)
```
int feraiseexcept (int excepts)
```
**Description:**
Obtains the floating-point exceptions specified by **excepts**.
**Parameters:**

Name	Description
excepts	Indicates the floating-point exceptions to obtain.

**Returns:**
Returns **0** if the operation is successful; returns a non-zero value otherwise.
## fesetenv\(\)
```
int fesetenv (const [fenv_t](fenv_t.md) * envp)
```
**Description:**
Sets the current floating-point environment.
This function restores the floating-point environment from the object specified by **envp**. The floating-point environment contains the current control modes and status flags of floating-point operations.
**Parameters:**

Name	Description
envp	Indicates the pointer to the floating-point environment.

**Attention:**
The object specified by **envp** must be valid.
**Returns:**
Returns **0** if the operation is successful; returns a non-zero value otherwise.
## fesetexceptflag\(\)
```
int fesetexceptflag (const [fexcept_t](MATH.md#ga3eec78fdb9921de3f7254105f546c624) * flagp, int excepts )
```
**Description:**
Sets the exception status flag by copying the floating-point exceptions stored in the **flagp** address to the **excepts** parameter.
**Parameters:**

Name	Description
flagp	Indicates the pointer to the floating-point exceptions.
excepts	Indicates the current floating-point exceptions to store.

**Attention:**
Before using this function, ensure that you have successfully called [fegetexceptflag](MATH.md#gadc77aa0943782d65cd89a7ad931efccd).
**Returns:**
Returns **0** if the operation is successful; returns a non-zero value otherwise.
## fesetround\(\)
```
int fesetround (int rounding_mode)
```
**Description:**
Sets the rounding mode.
The rounding mode can be [FE\_TONEAREST](MATH.md#ga5b5383719a63f98b7c95cc2feccaa1a7), [FE\_UPWARD](MATH.md#ga5aa71a164a4b4d7780570d97058890f1), [FE\_DOWNWARD](MATH.md#ga5e011a345a41ad4622da05932e83536f), or [FE\_TOWARDZERO](MATH.md#gac171099e006285a9e8be5683be71591c).
**Parameters:**

Name	Description
rounding_mode	Indicates the rounding mode to set.

**Returns:**
Returns **0** if the operation is successful; returns a non-zero value otherwise.
## fetestexcept\(\)
```
int fetestexcept (int excepts)
```
**Description:**
Checks whether the floating-point exceptions specified by **excepts** have been raised.
For example, if the value of **excepts** is **[FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) | [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae)**, this function checks whether the current floating-point operation has thrown an overflow exception or is invalid.
**Parameters:**

Name	Description
excepts	Indicates the floating-point exceptions.

**Returns:**
Returns the macros describing the specified exceptions if they have been raised; returns **0** if the specified exceptions do not exist.
## feupdateenv\(\)
```
int feupdateenv (const [fenv_t](fenv_t.md) * envp)
```
**Description:**
Updates the current floating-point environment from the object specified by **envp**.
**Parameters:**

Name	Description
envp	Indicates the pointer to the floating-point environment.

**Attention:**
The object specified by **envp** must be valid.
**Returns:**
Returns **0** if the operation is successful; returns a non-zero value otherwise.
## finite\(\)
```
int finite (double x)
```
**Description:**
Checks whether the double value **x** is an infinity or a NaN value.
**Parameters:**

Name	Description
x	Indicates the double value to check.

**Returns:**
Returns **0** if **x** is an infinity or a NaN value; returns **1** otherwise.
## finitef\(\)
```
int finitef (float x)
```
**Description:**
Checks whether the float value **x** is an infinity or a NaN value.
**Parameters:**

Name	Description
x	Indicates the float value to check.

**Returns:**
Returns **0** if **x** is an infinity or a NaN value; returns **1** otherwise.
## floor\(\)
```
double floor (double x)
```
**Description:**
Obtains the largest integer less than or equal to the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value x to compare with.

**Returns:**
Returns the largest integer less than or equal to **x**.
## floorf\(\)
```
float floorf (float x)
```
**Description:**
Obtains the largest integer less than or equal to the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value x to compare with.

**Returns:**
Returns the largest integer less than or equal to **x**.
## floorl\(\)
```
long double floorl (long double x)
```
**Description:**
Obtains the largest integer less than or equal to the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value x to compare with.

**Returns:**
Returns the largest integer less than or equal to **x**.
## fma\(\)
```
double fma (double x, double y, double z )
```
**Description:**
Calculates the value of **x\*y+z** and rounds the result up.
**Parameters:**

Name	Description
x	Indicates the double value x.
y	Indicates the double value y.
z	Indicates the double value z.

**Attention:**
The rounding mode is the same as that set in the system.
**Returns:**
Returns the calculation result.
## fmaf\(\)
```
float fmaf (float x, float y, float z )
```
**Description:**
Calculates the value of **x\*y+z** and rounds the result up.
**Parameters:**

Name	Description
x	Indicates the float value x.
y	Indicates the float value y.
z	Indicates the float value z.

**Attention:**
The rounding mode is the same as that set in the system.
**Returns:**
Returns the calculation result.
## fmal\(\)
```
long double fmal (long double x, long double y, long double z )
```
**Description:**
Calculates the value of **x\*y+z** and rounds the result up.
**Parameters:**

Name	Description
x	Indicates the long double value x.
y	Indicates the long double value y.
z	Indicates the long double value z.

**Attention:**
The rounding mode is the same as that set in the system.
**Returns:**
Returns the calculation result.
## fmax\(\)
```
double fmax (double x, double y )
```
**Description:**
Obtains the larger value of two double values **x** and **y**.
**Parameters:**

Name	Description
x	Indicates the double value x.
y	Indicates the double value y.

**Returns:**
Returns the larger value.
## fmaxf\(\)
```
float fmaxf (float x, float y )
```
**Description:**
Obtains the larger value of two float values **x** and **y**.
**Parameters:**

Name	Description
x	Indicates the float value x.
y	Indicates the float value y.

**Returns:**
Returns the larger value.
## fmaxl\(\)
```
long double fmaxl (long double x, long double y )
```
**Description:**
Obtains the larger value of two long double values **x** and **y**.
**Parameters:**

Name	Description
x	Indicates the long double value x.
y	Indicates the long double value y.

**Returns:**
Returns the larger value.
## fmin\(\)
```
double fmin (double x, double y )
```
**Description:**
Obtains the smaller value of two double values **x** and **y**.
**Parameters:**

Name	Description
x	Indicates the double value x.
y	Indicates the double value y.

**Returns:**
Returns the smaller value.
## fminf\(\)
```
float fminf (float x, float y )
```
**Description:**
Obtains the smaller value of two float values **x** and **y**.
**Parameters:**

Name	Description
x	Indicates the float value x.
y	Indicates the float value y.

**Returns:**
Returns the smaller value.
## fminl\(\)
```
long double fminl (long double x, long double y )
```
**Description:**
Obtains the smaller value of two long double values **x** and **y**.
**Parameters:**

Name	Description
x	Indicates the long double value x.
y	Indicates the long double value y.

**Returns:**
Returns the smaller value.
## fmod\(\)
```
double fmod (double x, double y )
```
**Description:**
Calculates the remainder of the double value **x** divided by the double value **y**.

**Parameters:**

Name	Description
x	Indicates the double value x, which is used as the numerator.
y	Indicates the double value y, which is used as the denominator.

**Returns:**
Returns the remainder.
## fmodf\(\)
```
float fmodf (float x, float y )
```
**Description:**
Calculates the remainder of the float value **x** divided by the float value **y**.
**Parameters:**

Name	Description
x	Indicates the float value x, which is used as the numerator.
y	Indicates the float value y, which is used as the denominator.

**Returns:**
Returns the remainder.
## fmodl\(\)
```
long double fmodl (long double x, long double y )
```
**Description:**
Calculates the remainder of the long double value **x** divided by the long double value **y**.
**Parameters:**

Name	Description
x	Indicates the long double value x, which is used as the numerator.
y	Indicates the long double value y, which is used as the denominator.

**Returns:**
Returns the remainder.
## frexp\(\)
```
double frexp (double x, int * exp )
```
**Description:**
Decomposes the double value **x** into a significand and an integral exponent for 2.
The absolute value of the significand ranges from 0.5 \(included\) to 1 \(excluded\). x = significand \* 2^exponent
**Parameters:**

Name	Description
x	Indicates the double value x to decompose.
exp	Indicates the pointer to the exponent.

**Returns:**
Returns the binary significand of **x** if the operation is successful; returns **0** if **x** is **0** \(**exp** is also **0**\); returns a NaN value if **x** is a NaN value \(**exp** is not specified\); returns a positive or negative infinity if **x** is a positive or negative infinity, respectively \(**exp** is not specified\).
## frexpf\(\)
```
float frexpf (float x, int * exp )
```
**Description:**
Decomposes float value **x** into a binary significand and an integral exponent for 2.
The absolute value of the significand ranges from 0.5 \(included\) to 1 \(excluded\). x = significand \* 2^exponent
**Parameters:**

Name	Description
x	Indicates the float value to decompose.
exp	Indicates the pointer to an integer where the exponent is stored.

**Returns:**
Returns the binary significand of **x** if the operation is successful; returns **0** if **x** is **0** \(**exp** is also **0**\); returns a NaN value if **x** is a NaN value \(**exp** is not specified\); returns a positive or negative infinity if **x** is a positive or negative infinity \(**exp** is not specified\).
## frexpl\(\)
```
long double frexpl (long double x, int * exp )
```
**Description:**
Decomposes long double value **x** into a binary significand and an integral exponent for 2.
The absolute value of the significand ranges from 0.5 \(included\) to 1 \(excluded\). x = significand \* 2^exponent
**Parameters:**

Name	Description
x	Indicates the long double value to decompose.
exp	Indicates the pointer to an integer where the exponent is stored.

**Returns:**
Returns the binary significand of **x** if the operation is successful; returns **0** if **x** is **0** \(**exp** is also **0**\); returns a NaN value if **x** is a NaN value \(**exp** is not specified\); returns a positive or negative infinity if **x** is a positive or negative infinity \(**exp** is not specified\).
## hypot\(\)
```
double hypot (double x, double y )
```
**Description:**
Calculates the hypotenuse of a right triangle whose legs are **x** and **y**.
**Parameters:**

Name	Description
x	Indicates the length of one side of the right triangle, represented using a double value.
y	Indicates the length of the other side of the right triangle, represented using a double value.

**Returns:**
Returns the hypotenuse of the right triangle.
## hypotf\(\)
```
float hypotf (float x, float y )
```
**Description:**
Calculates the hypotenuse of a right triangle whose legs are **x** and **y**.
**Parameters:**

Name	Description
x	Indicates the length of one side of the right triangle, represented using a float value.
y	Indicates the length of the other side of the right triangle, represented using a float value.

**Returns:**
Returns the hypotenuse of the right triangle.
## hypotl\(\)
```
long double hypotl (long double x, long double y )
```
**Description:**
Calculates the hypotenuse of a right triangle whose legs are **x** and **y**.
**Parameters:**

Name	Description
x	Indicates the length of one side of the right triangle, represented using a long double value.
y	Indicates the length of the other side of the right triangle, represented using a long double value.

**Returns:**
Returns the hypotenuse of the right triangle.
## ilogb\(\)
```
int ilogb (double x)
```
**Description:**
Obtains the integral part of the logarithm of double value **x**.
**FLT\_RADIX** is used as the base for the logarithm.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the integral part of the logarithm of **x** if the operation is successful. If **x** is **0**, this function returns [FP\_ILOGB0](MATH.md#ga9ec0e31304d15c42262b2c4a3b58443c) and reports a domain error. If **x** is a NaN value, this function returns [FP\_ILOGBNAN](MATH.md#ga01e2e5be97c739a5bdcbc619b44f9742) and reports a domain error. If **x** is positive or negative infinity, this function returns [INT\_MAX](UTILS.md#ga9ec306f36d50c7375e74f0d1c55a3a67) and reports a domain error.
## ilogbf\(\)
```
int ilogbf (float x)
```
**Description:**
Obtains the integral part of the logarithm of float value **x**.
**FLT\_RADIX** is used as the base for the logarithm.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the integral part of the logarithm of **x** if the operation is successful. If **x** is **0**, this function returns [FP\_ILOGB0](MATH.md#ga9ec0e31304d15c42262b2c4a3b58443c) and reports a domain error. If **x** is a NaN value, this function returns [FP\_ILOGBNAN](MATH.md#ga01e2e5be97c739a5bdcbc619b44f9742) and reports a domain error. If **x** is positive or negative infinity, this function returns [INT\_MAX](UTILS.md#ga9ec306f36d50c7375e74f0d1c55a3a67) and reports a domain error.
## ilogbl\(\)
```
int ilogbl (long double x)
```
**Description:**
Obtains the integral part of the logarithm of the long double value **x**.
**FLT\_RADIX** is used as the base for the logarithm.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Returns:**
Returns the integral part of the logarithm of **x** if the operation is successful. If **x** is **0**, this function returns [FP\_ILOGB0](MATH.md#ga9ec0e31304d15c42262b2c4a3b58443c) and reports a domain error. If **x** is a NaN value, this function returns [FP\_ILOGBNAN](MATH.md#ga01e2e5be97c739a5bdcbc619b44f9742) and reports a domain error. If **x** is positive or negative infinity, this function returns [INT\_MAX](UTILS.md#ga9ec306f36d50c7375e74f0d1c55a3a67) and reports a domain error.
## j0\(\)
```
double j0 (double x)
```
**Description:**
Calculates the Bessel function of the first kind of order **0** for the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the Bessel function of the first kind of order **0** for **x** if the operation is successful; returns a NaN value if **x** is a NaN value; returns **0** and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca) if **x** is too large or an overflow range error occurs.
## j0f\(\)
```
float j0f (float x)
```
**Description:**
Calculates the Bessel function of the first kind of order **0** for the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the calculation result if the operation is successful; returns a NaN value if **x** is a NaN value; returns **0** and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca) if **x** is too large or an overflow range error occurs.
## j1\(\)
```
double j1 (double x)
```
**Description:**
Calculates the Bessel function of the first kind of order **1** for the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the Bessel function of the first kind of order **1** for **x** if the operation is successful; returns a NaN value if **x** is a NaN value; returns **0** and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca) if **x** is too large or an overflow range error occurs.
## j1f\(\)
```
float j1f (float x)
```
**Description:**
Calculates the Bessel function of the first kind of order **1** for the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the calculation result if the operation is successful; returns a NaN value if **x** is a NaN value; returns **0** and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca) if **x** is too large or an overflow range error occurs.
## jn\(\)
```
double jn (int n, double x )
```
**Description:**
Calculates the Bessel function of the first kind of order **n** for the double value **x**.
**Parameters:**

Name	Description
n	Indicates the order of the Bessel function of the first kind.
x	Indicates the double value.

**Returns:**
Returns the Bessel function of the first kind of order **n** for **x** if the operation is successful; returns a NaN value if **x** is a NaN value; returns **0** and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca) if **x** is too large or an overflow range error occurs.
## jnf\(\)
```
float jnf (int n, float x )
```
**Description:**
Calculates the Bessel function of the first kind of order **n** for the float value **x**.
**Parameters:**

Name	Description
n	Indicates the order of the Bessel function of the first kind.
x	Indicates the float value.

**Returns:**
Returns the calculation result if the operation is successful; returns a NaN value if **x** is a NaN value; returns **0** and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca) if **x** is too large or an overflow range error occurs.
## ldexp\(\)
```
double ldexp (double x, int exp )
```
**Description:**
Multiplies the double value **x** by 2 raised to the power of **exp**.
The calculation formula is x\*2^exp.
**Parameters:**

Name	Description
x	Indicates the double value.
exp	Indicates the exponent.

**Returns:**
Returns the calculation result.
## ldexpf\(\)
```
float ldexpf (float x, int exp )
```
**Description:**
Multiplies the float value **x** by 2 raised to the power of **exp**.
The calculation formula is x\*2^exp.
**Parameters:**

Name	Description
x	Indicates the float value.
exp	Indicates the exponent.

**Returns:**
Returns the calculation result.
## ldexpl\(\)
```
long double ldexpl (long double x, int exp )
```
**Description:**
Multiplies the long double value **x** by 2 raised to the power of **exp**.
The calculation formula is x\*2^exp.
**Parameters:**

Name	Description
x	Indicates the long double value.
exp	Indicates the exponent.

**Returns:**
Returns the calculation result.
## lgamma\(\)
```
double lgamma (double x)
```
**Description:**
Calculates the natural logarithm of the absolute value of the gamma function of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the calculation result if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **1** or **2**, this function returns **+0**. If **x** is a positive or negative infinity, this function returns a positive infinity. If **x** is **0** or a negative value, this function returns one of +[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971), reports a pole error, and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca)\). If an overflow range error occurs, this function returns one of [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) \* and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca).
## lgammaf\(\)
```
float lgammaf (float x)
```
**Description:**
Calculates the natural logarithm of the absolute value of the gamma function of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the calculation result if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **1** or **2**, this function returns **+0**. If **x** is a positive or negative infinity, this function returns a positive infinity. If **x** is **0** or a negative value, this function returns one of +[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359), reports a pole error, and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca). If an overflow range error occurs, this function returns one of [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca).
## lgammal\(\)
```
long double lgammal (long double x)
```
**Description:**
Calculates the natural logarithm of the absolute value of the gamma function of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Returns:**
Returns the calculation result if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **1** or **2**, this function returns **+0**. If **x** is a positive or negative infinity, this function returns a positive infinity. If **x** is **0** or a negative value, this function returns one of +[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182), reports a pole error, and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca). If an overflow range error occurs, this function returns one of [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca).
## lgammal\_r\(\)
```
long double lgammal_r (long double x, int * signp )
```
**Description:**
Calculates the natural logarithm of the absolute value of the gamma function of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.
signp	return value of sign.

**Returns:**
Returns the calculation result if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **1** or **2**, this function returns **+0**. If **x** is a positive or negative infinity, this function returns a positive infinity. If **x** is **0** or a negative value, this function returns one of +[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971), reports a pole error, and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca)\). If an overflow range error occurs, this function returns one of [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) \* and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca).
## llrint\(\)
```
long long int llrint (double x)
```
**Description:**
Rounds double value **x** to the nearest integer.
**Parameters:**

Name	Description
x	Indicates the double value to round.

**Attention:**
The type of **x**, rounding mode, and rounding direction are specified by [fegetround](MATH.md#gaf43d2de25e6d5e3b65b1d1f32c01b3c8).
**Returns:**
Returns the nearest integer if the operation is successful; returns an unspecified value if **x** is a NaN value or an infinity, or the rounded value is outside the specified range, in which case a domain error or overflow range error occurs.
## llrintf\(\)
```
long long int llrintf (float x)
```
**Description:**
Rounds float value **x** to the nearest integer.
**Parameters:**

Name	Description
x	Indicates the float value.

**Attention:**
The type of **x**, rounding mode, and rounding direction are specified by [fegetround](MATH.md#gaf43d2de25e6d5e3b65b1d1f32c01b3c8).
**Returns:**
Returns the nearest integer if the operation is successful; returns an unspecified value if **x** is a NaN value or an infinity, or the rounded value is outside the specified range, in which case a domain error or overflow range error occurs.
## llrintl\(\)
```
long long int llrintl (long double x)
```
**Description:**
Rounds long double value **x** to the nearest integer.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Attention:**
The type of **x**, rounding mode, and rounding direction are specified by [fegetround](MATH.md#gaf43d2de25e6d5e3b65b1d1f32c01b3c8).
**Returns:**
Returns the nearest integer if the operation is successful; returns an unspecified value if **x** is a NaN value or an infinity, or the rounded value is outside the specified range, in which case a domain error or overflow range error occurs.
## llround\(\)
```
long long int llround (double x)
```
**Description:**
Rounds double value **x** to the nearest integer, rounding away from **0**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Attention:**
Halfway values are rounded away from **0**.
**Returns:**
Returns the nearest integer if the operation is successful; returns an unspecified value if **x** is a NaN value or an infinity, or the rounded value is outside the specified range, in which case a domain error or overflow range error occurs.
## llroundf\(\)
```
long long int llroundf (float x)
```
**Description:**
Rounds float value **x** to the nearest integer, rounding away from **0**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Attention:**
Halfway values are rounded away from **0**.
**Returns:**
Returns the nearest integer if the operation is successful; returns an unspecified value if **x** is a NaN value or an infinity, or the rounded value is outside the specified range, in which case a domain error or overflow range error occurs.
## llroundl\(\)
```
long long int llroundl (long double x)
```
**Description:**
Rounds long double value **x** to the nearest integer, rounding away from **0**.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Attention:**
Halfway values are rounded away from **0**.
**Returns:**
Returns the nearest integer if the operation is successful; returns an unspecified value if **x** is a NaN value or an infinity, or the rounded value is outside the specified range, in which case a domain error or overflow range error occurs.
## log\(\)
```
double log (double x)
```
**Description:**
Calculates the natural logarithm of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the natural logarithm of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is **0**, this function returns **-[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)**, reports a pole error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative value \(including a negative infinity\), this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception.
## log10\(\)
```
double log10 (double x)
```
**Description:**
Calculates the common logarithm \(logarithm with base 10\) of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the natural logarithm of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is **0**, this function returns **-[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)**, reports a pole error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative value \(including a negative infinity\), this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception.
## log10f\(\)
```
float log10f (float x)
```
**Description:**
Calculates the common logarithm \(logarithm with base 10\) of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the natural logarithm of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is **0**, this function returns **-[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)**, reports a pole error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative value \(including a negative infinity\), this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception.
## log10l\(\)
```
long double log10l (long double x)
```
**Description:**
Calculates the common logarithm \(logarithm with base 10\) of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Returns:**
Returns the natural logarithm of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is **0**, this function returns **-[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)**, reports a pole error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative value \(including a negative infinity\), this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception.
## log1p\(\)
```
double log1p (double x)
```
**Description:**
Calculates the natural logarithm of one plus the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the natural logarithm of one plus **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is **-1**, this function returns **-[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)**, reports a pole error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is less than **-1** \(including a negative infinity\), this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception.
## log1pf\(\)
```
float log1pf (float x)
```
**Description:**
Calculates the natural logarithm of one plus the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the natural logarithm of one plus **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is **-1**, this function returns **-[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)**, reports a pole error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is less than **-1** \(including a negative infinity\), this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception.
## log1pl\(\)
```
long double log1pl (long double x)
```
**Description:**
Calculates the natural logarithm of one plus the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Returns:**
Returns the natural logarithm of one plus **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is **-1**, this function returns **-[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)**, reports a pole error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is less than **-1** \(including a negative infinity\), this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception.
## log2\(\)
```
double log2 (double x)
```
**Description:**
Calculates the binary logarithm \(logarithm with base 2\) of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the binary logarithm of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is **0**, this function returns **-[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)**, reports a pole error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative value \(including a negative infinity\), this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception.
## log2f\(\)
```
float log2f (float x)
```
**Description:**
Calculates the binary logarithm \(logarithm with base 2\) of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the binary logarithm of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is **0**, this function returns **-[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)**, reports a pole error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative value \(including a negative infinity\), this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception.
## log2l\(\)
```
long double log2l (long double x)
```
**Description:**
Calculates the binary logarithm \(logarithm with base 2\) of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Returns:**
Returns the binary \(base-2\) logarithm of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is **0**, this function returns **-[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)**, reports a pole error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative value \(including a negative infinity\), this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception.
## logb\(\)
```
double logb (double x)
```
**Description:**
Calculates the logarithm of the absolute value of the double value **x**.
**FLT\_RADIX** is used as the base for the logarithm.
**Parameters:**

Name	Description
x	Indicates the double value.

**Attention:**
Set **FLT\_RADIX** to **2** in the **float.h** file.
**Returns:**
Returns the logarithm of the absolute value of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive or negative infinity, this function returns a positive or negative infinity. If **x** is **0**, this function returns **-[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)**, reports a pole error, and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception.
## logbf\(\)
```
float logbf (float x)
```
**Description:**
Calculates the logarithm of the absolute value of the float value **x**.
**FLT\_RADIX** is used as the base for the logarithm.
**Parameters:**

Name	Description
x	Indicates the float value.

**Attention:**
Set **FLT\_RADIX** to **2** in the **float.h** file.
**Returns:**
Returns the logarithm of the absolute value of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive or negative infinity, this function returns a positive or negative infinity. If **x** is **0**, this function returns **-[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)**, reports a pole error, and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception.
## logbl\(\)
```
long double logbl (long double x)
```
**Description:**
Calculates the logarithm of the absolute value of the long double value **x**.
**FLT\_RADIX** is used as the base for the logarithm.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Attention:**
Set **FLT\_RADIX** to **2** in the **float.h** file.
**Returns:**
Returns the logarithm of the absolute value of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive or negative infinity, this function returns a positive or negative infinity. If **x** is **0**, this function returns **-[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)**, reports a pole error, and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception.
## logf\(\)
```
float logf (float x)
```
**Description:**
Calculates the natural logarithm of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the natural logarithm of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is **0**, this function returns **-[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)**, reports a pole error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative value \(including a negative infinity\), this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception.
## logl\(\)
```
long double logl (long double x)
```
**Description:**
Calculates the natural logarithm of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Returns:**
Returns the natural logarithm of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is **0**, this function returns **-[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)**, reports a pole error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is a negative value \(including a negative infinity\), this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception.
## lrint\(\)
```
long int lrint (double x)
```
**Description:**
Rounds the double value **x** to the nearest integer.
**Parameters:**

Name	Description
x	Indicates the double value to round.

**Attention:**
The type of **x**, rounding mode, and rounding direction are specified by [fegetround](MATH.md#gaf43d2de25e6d5e3b65b1d1f32c01b3c8).
**Returns:**
Returns the nearest integer if the operation is successful; returns an unspecified value if **x** is a NaN value or an infinity, or the rounded value is outside the specified range, in which case a domain error or overflow range error occurs.
## lrintf\(\)
```
long int lrintf (float x)
```
**Description:**
Rounds the float value **x** to the nearest integer.
**Parameters:**

Name	Description
x	Indicates the float value to round.

**Attention:**
The type of **x**, rounding mode, and rounding direction are specified by [fegetround](MATH.md#gaf43d2de25e6d5e3b65b1d1f32c01b3c8).
**Returns:**
Returns the nearest integer if the operation is successful; returns an unspecified value if **x** is a NaN value or an infinity, or the rounded value is outside the specified range, in which case a domain error or overflow range error occurs.
## lrintl\(\)
```
long int lrintl (long double x)
```
**Description:**
Rounds the long double value **x** to the nearest integer.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Attention:**
The type of **x**, rounding mode, and rounding direction are specified by [fegetround](MATH.md#gaf43d2de25e6d5e3b65b1d1f32c01b3c8).
**Returns:**
Returns the nearest integer if the operation is successful; returns an unspecified value if **x** is a NaN value or an infinity, or the rounded value is outside the specified range, in which case a domain error or overflow range error occurs.
## lround\(\)
```
long int lround (double x)
```
**Description:**
Rounds double value **x** to the nearest integer, rounding away from **0**.
**Parameters:**

Name	Description
x	Indicates the double value to round.

**Attention:**
Halfway values are rounded away from **0**.
**Returns:**
Returns the nearest integer if the operation is successful; returns an unspecified value if **x** is a NaN value or an infinity, or the rounded value is outside the specified range, in which case a domain error or overflow range error occurs.
## lroundf\(\)
```
long int lroundf (float x)
```
**Description:**
Rounds the float value **x** to the nearest integer, rounding away from **0**.
**Parameters:**

Name	Description
x	Indicates the float value to round.

**Attention:**
Halfway values are rounded away from **0**.
**Returns:**
Returns the nearest integer if the operation is successful; returns an unspecified value if **x** is a NaN value or an infinity, or the rounded value is outside the specified range, in which case a domain error or overflow range error occurs.
## lroundl\(\)
```
long int lroundl (long double x)
```
**Description:**
Rounds the long double value **x** to the nearest integer, rounding away from **0**.
**Parameters:**

Name	Description
x	Indicates the long double value to round.

**Attention:**
Halfway values are rounded away from **0**.
**Returns:**
Returns the nearest integer if the operation is successful; returns an unspecified value if **x** is a NaN value or an infinity, or the rounded value is outside the specified range, in which case a domain error or overflow range error occurs.
## modf\(\)
```
double modf (double x, double * iptr )
```
**Description:**
Breaks the double value **x** into a signed integral and a fractional part.
**Parameters:**

Name	Description
x	Indicates the double value x.
iptr	Indicates the pointer to the object where the signed integral part is stored.

**Returns:**
Returns the fractional part of **x**.
## modff\(\)
```
float modff (float x, float * iptr )
```
**Description:**
Breaks the float value **x** into a signed integral and a fractional part.
**Parameters:**

Name	Description
x	Indicates the float value x.
iptr	Indicates the pointer to the object where the signed integral part is stored.

**Returns:**
Returns the fractional part of **x**.
## modfl\(\)
```
long double modfl (long double x, long double * iptr )
```
**Description:**
Breaks the long double value **x** into a signed integral and a fractional part.
**Parameters:**

Name	Description
x	Indicates the long double value x.
iptr	Indicates the pointer to the object where the signed integral part is stored.

**Returns:**
Returns the fractional part of **x**.
## nan\(\)
```
double nan (const char * tagp)
```
**Description:**
Obtains a quiet NaN value of the double type.
This function checks whether the input parameter is a NaN value and converts it to the double type.
**Parameters:**

Name	Description
tagp	Indicates the pointer to a character constant.

**Returns:**
Returns a quiet NaN value if the operation is successful; returns a NaN value otherwise.
## nanf\(\)
```
float nanf (const char * tagp)
```
**Description:**
Obtains a quiet NaN value of the float type.
This function checks whether the input parameter is a NaN value and converts it to the float type.
**Parameters:**

Name	Description
tagp	Indicates the pointer to a character constant.

**Returns:**
Returns a quiet NaN value if the operation is successful; returns a NaN value otherwise.
## nanl\(\)
```
long double nanl (const char * tagp)
```
**Description:**
Obtains a quiet NaN value of the long double type.
This function checks whether the input parameter is a NaN value and converts it to the long double type.
**Parameters:**

Name	Description
tagp	Indicates the pointer to a character constant.

**Returns:**
Returns a quiet NaN value if the operation is successful; returns a NaN value otherwise.
## nearbyint\(\)
```
double nearbyint (double x)
```
**Description:**
Rounds the double value **x** to an integer in floating-point format.
**Parameters:**

Name	Description
x	Indicates the double value x.

**Attention:**
The rounding mode is specified by [fegetround](MATH.md#gaf43d2de25e6d5e3b65b1d1f32c01b3c8).
**Returns:**
Returns the rounded value.
## nearbyintf\(\)
```
float nearbyintf (float x)
```
**Description:**
Rounds the float value **x** to an integer in floating-point format.
**Parameters:**

Name	Description
x	Indicates the float value x.

**Attention:**
The rounding mode is specified by [fegetround](MATH.md#gaf43d2de25e6d5e3b65b1d1f32c01b3c8).
**Returns:**
Returns the rounded value.
## nearbyintl\(\)
```
long double nearbyintl (long double x)
```
**Description:**
Rounds the long double value **x** to an integer in floating-point format.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Attention:**
The rounding mode is specified by [fegetround](MATH.md#gaf43d2de25e6d5e3b65b1d1f32c01b3c8).
**Returns:**
Returns the rounded value.
## nextafter\(\)
```
double nextafter (double x, double y )
```
**Description:**
Obtains the next representable value following the double value **x** in the direction of the double value **y**.
**Parameters:**

Name	Description
x	Indicates the double value x.
y	Indicates the double value y.

**Attention:**
If **y** is less than **x**, this function returns the maximum representable value less than **x**.
**Returns:**
Returns the next representable value after **x** in the direction of **y** if the operation is successful; returns the passed **y** if **x** is equal to **y**; returns a NaN value if **x** is a NaN value; returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) and reports an overflow range error if **x** is a finite value.
## nextafterf\(\)
```
float nextafterf (float x, float y )
```
**Description:**
Obtains the next representable value following the float value **x** in the direction of the float value **y**.
**Parameters:**

Name	Description
x	Indicates the float value x.
y	Indicates the float value y.

**Attention:**
If **y** is less than **x**, this function returns the maximum representable value less than **x**.
**Returns:**
Returns the next representable value following **x** in the direction of **y** if the operation is successful; returns the passed **y** if **x** is equal to **y**; returns a NaN value if **x** is a NaN value; returns [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) and reports an overflow range error if **x** is a finite value.
## nextafterl\(\)
```
long double nextafterl (long double x, long double y )
```
**Description:**
Obtains the next representable value following the long double value **x** in the direction of the long double value **y**.
**Parameters:**

Name	Description
x	Indicates the long double value x.
y	Indicates the long double value y.

**Attention:**
If **y** is less than **x**, this function returns the maximum representable value less than **x**.
**Returns:**
Returns the next representable value after **x** in the direction of **y** if the operation is successful; returns the passed **y** if **x** is equal to **y**; returns a NaN value if **x** is a NaN value; returns [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) and reports an overflow range error if **x** is a finite value.
## nexttoward\(\)
```
double nexttoward (double x, long double y )
```
**Description:**
Obtains the next representable value following the double value **x** in the direction of the long double value **y**.
**Parameters:**

Name	Description
x	Indicates the double value x.
y	Indicates the long double value y.

**Attention:**
If **y** is less than **x**, this function returns the maximum representable value less than **x**.
**Returns:**
Returns the next representable value following **x** in the direction of **y** if the operation is successful; returns the passed **y** if **x** is equal to **y**; returns a NaN value if **x** is a NaN value; returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) and reports an overflow range error if **x** is a finite value.
## nexttowardf\(\)
```
float nexttowardf (float x, long double y )
```
**Description:**
Obtains the next representable value following the float value **x** in the direction of the long double value **y**.
**Parameters:**

Name	Description
x	Indicates the float value x.
y	Indicates the long double value y.

**Attention:**
If **y** is less than **x**, this function returns the maximum representable value less than **x**.
**Returns:**
Returns the next representable value after **x** in the direction of **y** if the operation is successful; returns the passed **y** if **x** is equal to **y**; returns a NaN value if **x** is a NaN value; returns [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) and reports an overflow range error if **x** is a finite value.
## nexttowardl\(\)
```
long double nexttowardl (long double x, long double y )
```
**Description:**
Obtains the next representable value following the long double value **x** in the direction of the long double value **y**.
**Parameters:**

Name	Description
x	Indicates the long double value x.
y	Indicates the long double value y.

**Attention:**
If **y** is less than **x**, this function returns the maximum representable value less than **x**.
**Returns:**
Returns the next representable value following **x** in the direction of **y** if the operation is successful; returns the passed **y** if **x** is equal to **y**; returns a NaN value if **x** is a NaN value; returns [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) and reports an overflow range error if **x** is a finite value.
## pow\(\)
```
double pow (double x, double y )
```
**Description:**
Obtains the double value **x** raised to the power of the double value **y**.
**Parameters:**

Name	Description
x	Indicates the double value x, which is used as the base.
y	Indicates the double value y, which is used as the exponent.

**Returns:**
Returns the calculation result if the operation is successful. If **x** or **y** is a NaN value, this returns a NaN value, except as specified below. If **x** is **+1** \(even if **y** is a NaN value\), this function returns **1.0**. If **y** is **0** \(even if **x** is a NaN value\), this function returns **1.0**. If **x** is **+0** or **-0**, and **y** is an odd integer greater than **0**, this function returns **+0** or **-0**. If **x** is **0** and **y** is greater than **0** and not an odd integer, this function returns **+0**. If **x** is **-1** and **y** is a positive or negative infinity, this function returns **1.0**. If the absolute value of **x** is less than **1** and **y** is a negative infinity, this function returns a positive infinity. If the absolute value of **x** is greater than **1** and **y** is a negative infinity, this function returns **+0**. If the absolute value of **x** is less than **1** and **y** is a positive infinity, this function returns **+0**. If the absolute value of **x** is greater than **1** and **y** is a positive infinity, this function returns a positive infinity. If **x** is a negative infinity and **y** is an odd integer less than **0**, this function returns **-0**. If **x** is a negative infinity and **y** is less than **0** and not an odd integer, this function returns **+0**. If **x** is a negative infinity and **y** is an odd integer greater than **0**, this function returns a negative infinity. If **x** is a negative infinity and **y** is greater than **0** and not an odd integer, this function returns a positive infinity. If **x** is a positive infinity and **y** is less than **0**, this function returns **+0**. If **x** is a positive infinity and **y** is greater than **0**, this function returns a positive infinity. If **x** is a negative value and **y** is a finite non-integer, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is **+0** or **-0** and **y** is a negative odd integer, this function returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971), reports a pole error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception. If **x** is **+0** or **-0** and **y** is a negative non-odd integer, this function returns **+[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)**, reports a pole error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception. If an overflow range error occurs, this function returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971), sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception. If an underflow range error occurs, this function returns **0.0**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception.
## pow10\(\)
```
double pow10 (double x)
```
**Description:**
Calculates the value of 10 raised to the power **x**, which is a double value.
**Parameters:**

Name	Description
x	Indicates the double value x.

**Returns:**
Returns the value of 10 raised to the power **x** if the operation is successful.
## pow10f\(\)
```
float pow10f (float x)
```
**Description:**
Calculates the value of 10 raised to the power **x**, which is a float value.
**Parameters:**

Name	Description
x	Indicates the float value x.

**Returns:**
Returns the value of 10 raised to the power **x** if the operation is successful.
## pow10l\(\)
```
long double pow10l (long double x)
```
**Description:**
Calculates the value of 10 raised to the power **x**, which is a long double value.
**Parameters:**

Name	Description
x	Indicates the long double value x.

**Returns:**
Returns the value of 10 raised to the power **x** if the operation is successful.
## powf\(\)
```
float powf (float x, float y )
```
**Description:**
Obtains the float value **x** raised to the power of the float value **y**.
**Parameters:**

Name	Description
x	Indicates the float value x, which is used as the base.
y	Indicates the float value y, which is used as the exponent.

**Returns:**
Returns the calculation result if the operation is successful. If **x** or **y** is a NaN value, this returns a NaN value, except as specified below. If **x** is **+1** \(even if **y** is a NaN value\), this function returns **1.0**. If **y** is **0** \(even if **x** is a NaN value\), this function returns **1.0**. If **x** is **+0** or **-0**, and **y** is an odd integer greater than **0**, this function returns **+0** or **-0**. If **x** is **0** and **y** is greater than **0** and not an odd integer, this function returns **+0**. If **x** is **-1** and **y** is a positive or negative infinity, this function returns **1.0**. If the absolute value of **x** is less than **1** and **y** is a negative infinity, this function returns a positive infinity. If the absolute value of **x** is greater than **1** and **y** is a negative infinity, this function returns **+0**. If the absolute value of **x** is less than **1** and **y** is a positive infinity, this function returns **+0**. If the absolute value of **x** is greater than **1** and **y** is a positive infinity, this function returns a positive infinity. If **x** is a negative infinity and **y** is an odd integer less than **0**, this function returns **-0**. If **x** is a negative infinity and **y** is less than **0** and not an odd integer, this function returns **+0**. If **x** is a negative infinity and **y** is an odd integer greater than **0**, this function returns a negative infinity. If **x** is a negative infinity and **y** is greater than **0** and not an odd integer, this function returns a positive infinity. If **x** is a positive infinity and **y** is less than **0**, this function returns **+0**. If **x** is a positive infinity and **y** is greater than **0**, this function returns a positive infinity. If **x** is a negative value and **y** is a finite non-integer, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is **+0** or **-0** and **y** is a negative odd integer, this function returns [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359), reports a pole error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception. If **x** is **+0** or **-0** and **y** is a negative non-odd integer, this function returns **+[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)**, reports a pole error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception. If an overflow range error occurs, this function returns [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359), sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception. If an underflow range error occurs, this function returns **0.0**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception.
## powf10\(\)
```
float powf10 (float x)
```
**Description:**
Calculates the xth power of 10.
**Parameters:**

Name	Description
x	Indicates the float value x, which is used as the exponent.

**Returns:**
Returns the calculation result if the operation is successful. If y is 0 \(even if x is a NaN value\), this function returns 1.0. If an overflow range error occurs, this function returns [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359), sets errno to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception. If an underflow range error occurs, this function returns 0.0, sets errno to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception.
## powl\(\)
```
long double powl (long double x, long double y )
```
**Description:**
Obtains the long double value **x** raised to the power of the long double value **y**.

**Parameters:**

Name	Description
x	Indicates the long double value x, which is used as the base.
y	Indicates the long double value y, which is used as the exponent.

**Returns:**
Returns the calculation result if the operation is successful. If **x** or **y** is a NaN value, this returns a NaN value, except as specified below. If **x** is **+1** \(even if **y** is a NaN value\), this function returns **1.0**. If **y** is **0** \(even if **x** is a NaN value\), this function returns **1.0**. If **x** is **+0** or **-0**, and **y** is an odd integer greater than **0**, this function returns **+0** or **-0**. If **x** is **0** and **y** is greater than **0** and not an odd integer, this function returns **+0**. If **x** is **-1** and **y** is a positive or negative infinity, this function returns **1.0**. If the absolute value of **x** is less than **1** and **y** is a negative infinity, this function returns a positive infinity. If the absolute value of **x** is greater than **1** and **y** is a negative infinity, this function returns **+0**. If the absolute value of **x** is less than **1** and **y** is a positive infinity, this function returns **+0**. If the absolute value of **x** is greater than **1** and **y** is a positive infinity, this function returns a positive infinity. If **x** is a negative infinity and **y** is an odd integer less than **0**, this function returns **-0**. If **x** is a negative infinity and **y** is less than **0** and not an odd integer, this function returns **+0**. If **x** is a negative infinity and **y** is an odd integer greater than **0**, this function returns a negative infinity. If **x** is a negative infinity and **y** is greater than **0** and not an odd integer, this function returns a positive infinity. If **x** is a positive infinity and **y** is less than **0**, this function returns **+0**. If **x** is a positive infinity and **y** is greater than **0**, this function returns a positive infinity. If **x** is a negative value and **y** is a finite non-integer, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is **+0** or **-0** and **y** is a negative odd integer, this function returns [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182), reports a pole error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception. If **x** is **+0** or **-0** and **y** is a negative non-odd integer, this function returns **+[HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182)**, reports a pole error, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_DIVBYZERO](MATH.md#gab1317930189d1a14841893fb4bd9b5a0) exception. If an overflow range error occurs, this function returns [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182), sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception. If an underflow range error occurs, this function returns **0.0**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception.
## powl10\(\)
```
long double powl10 (long double x)
```
**Description:**
Calculates the xth power of 10.
**Parameters:**

Name	Description
x	Indicates the long double value x, which is used as the exponent.

**Returns:**
Returns the calculation result if the operation is successful. If x is 0, this function returns 1.0. If an overflow range error occurs, this function returns [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182), sets errno to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception. If an underflow range error occurs, this function returns 0.0, sets errno to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception.
## remainder\(\)
```
double remainder (double x, double y )
```
**Description:**
Calculates the remainder of the double value **x** divided by the double value **y**.
**Parameters:**

Name	Description
x	Indicates the double value x, which is used as the numerator.
y	Indicates the double value y, which is used as the denominator.

**Attention:**
The return value is **x-n\*y**, where **n** is the value of **x**/**y**, rounded toward the nearest integer \(with halfway values rounded toward the even number\). For example, if the decimal part of **x**/**y** is **0.5**, the value is rounded to an even number and **0** is returned.
**Returns:**
Returns the remainder if the operation is successful. If **x** or **y** is a NaN value, this function returns a NaN value. If **x** is an infinity and **y** is not a NaN value, this function returns a NaN value, reports a domain error, and throws the **FE\_INVAID** exception. If **y** is **0** and **x** is not a NaN value, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the **FE\_INVAID** exception.
## remainderf\(\)
```
float remainderf (float x, float y )
```
**Description:**
Calculates the remainder of the float value **x** divided by the float value **y**.
**Parameters:**

Name	Description
x	Indicates the float value x, which is used as the numerator.
y	Indicates the float value y, which is used as the denominator.

**Attention:**
The return value is **x-n\*y**, where **n** is the value of **x**/**y**, rounded toward the nearest integer \(with halfway values rounded toward the even number\). For example, if the decimal part of **x**/**y** is **0.5**, the value is rounded to an even number and **0** is returned.
**Returns:**
Returns the remainder if the operation is successful. If **x** or **y** is a NaN value, this function returns a NaN value. If **x** is an infinity and **y** is not a NaN value, this function returns a NaN value, reports a domain error, and throws the **FE\_INVAID** exception. If **y** is **0** and **x** is not a NaN value, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the **FE\_INVAID** exception.
## remainderl\(\)
```
long double remainderl (long double x, long double y )
```
**Description:**
Calculates the remainder of the long double value **x** divided by the long double value **y**.
**Parameters:**

Name	Description
x	Indicates the long double value x, which is used as the numerator.
y	Indicates the long double value y, which is used as the denominator.

**Attention:**
The return value is **x-n\*y**, where **n** is the value of **x**/**y**, rounded toward the nearest integer \(with halfway values rounded toward the even number\). For example, if the decimal part of **x**/**y** is **0.5**, the value is rounded to an even number and **0** is returned.
**Returns:**
Returns the remainder if the operation is successful. If **x** or **y** is a NaN value, this function returns a NaN value. If **x** is an infinity and **y** is not a NaN value, this function returns a NaN value, reports a domain error, and throws the **FE\_INVAID** exception. If **y** is **0** and **x** is not a NaN value, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the **FE\_INVAID** exception.
## remquo\(\)
```
double remquo (double x, double y, int * quo )
```
**Description:**
Calculates the quotient and remainder of the double value **x** divided by the double value **y**.
The return value is **x-n\*y**, where **n** is the value of **x**/**y**, rounded toward the nearest integer \(with halfway values rounded toward the even number\). For example, if the decimal part of **x**/**y** is **0.5**, the value is rounded to an even number and **0** is returned. **n** is converted into a signed binary number, and the sign and the least significant three bits of the binary number are combined and stored to the pointer specified by **quo**. For example, if **x** is **29.0** and **y** is **3.0**, the return value is **-1.0** and **n** is **10**. **n** is converted into a signed binary number **00001010**. Therefore, **2** is stored to the pointer specified by **quo**.
**Parameters:**

Name	Description
x	Indicates the double value x, which is used as the numerator.
y	Indicates the double value y, which is used as the denominator.
quo	Indicates the pointer that stores the quotient.

**Returns:**
Returns the remainder if the operation is successful. If **x** or **y** is a NaN value, this function returns a NaN value. If **x** is an infinity and **y** is not a NaN value, this function returns a NaN value, reports a domain error, and throws the **FE\_INVAID** exception. If **y** is **0** and **x** is not a NaN value, this function returns a NaN value, reports a domain error, and throws the **FE\_INVAID** exception.
## remquof\(\)
```
float remquof (float x, float y, int * quo )
```
**Description:**
Calculates the quotient and remainder of the float value **x** divided by the float value **y**.
The return value is **x-n\*y**, where **n** is the value of **x**/**y**, rounded toward the nearest integer \(with halfway values rounded toward the even number\). For example, if the decimal part of **x**/**y** is **0.5**, the value is rounded to an even number and **0** is returned. **n** is converted into a signed binary number, and the sign and the least significant three bits of the binary number are combined and stored to the pointer specified by **quo**. For example, if **x** is **29.0** and **y** is **3.0**, the return value is **-1.0** and **n** is **10**. **n** is converted into a signed binary number **00001010**. Therefore, **2** is stored to the pointer specified by **quo**.
**Parameters:**

Name	Description
x	Indicates the float value x, which is used as the numerator.
y	Indicates the float value y, which is used as the denominator.
quo	Indicates the pointer that stores the quotient.

**Returns:**
Returns the remainder if the operation is successful. If **x** or **y** is a NaN value, this function returns a NaN value. If **x** is an infinity and **y** is not a NaN value, this function returns a NaN value, reports a domain error, and throws the **FE\_INVAID** exception. If **y** is **0** and **x** is not a NaN value, this function returns a NaN value, reports a domain error, and throws the **FE\_INVAID** exception.
## remquol\(\)
```
long double remquol (long double x, long double y, int * quo )
```
**Description:**
Calculates the quotient and remainder of the long double value **x** divided by the long double value **y**.
The return value is **x-n\*y**, where **n** is the value of **x**/**y**, rounded toward the nearest integer \(with halfway values rounded toward the even number\). For example, if the decimal part of **x**/**y** is **0.5**, the value is rounded to an even number and **0** is returned. **n** is converted into a signed binary number, and the sign and the least significant three bits of the binary number are combined and stored to the pointer specified by **quo**. For example, if **x** is **29.0** and **y** is **3.0**, the return value is **-1.0** and **n** is **10**. **n** is converted into a signed binary number **00001010**. Therefore, **2** is stored to the pointer specified by **quo**.
**Parameters:**

Name	Description
x	Indicates the long double value x, which is used as the numerator.
y	Indicates the long double value y, which is used as the denominator.
quo	Indicates the pointer that stores the quotient.

**Returns:**
Returns the remainder if the operation is successful. If **x** or **y** is a NaN value, this function returns a NaN value. If **x** is an infinity and **y** is not a NaN value, this function returns a NaN value, reports a domain error, and throws the **FE\_INVAID** exception. If **y** is **0** and **x** is not a NaN value, this function returns a NaN value, reports a domain error, and throws the **FE\_INVAID** exception.
## rint\(\)
```
double rint (double x)
```
**Description:**
Rounds the double value **x** to the nearest integer.
**Parameters:**

Name	Description
x	Indicates the double value.

**Attention:**
POSIX.1-2001 records overflow range errors. If there are two nearest integers, the even integer is returned. For example, if **x** is **0.5**, **0** is returned.
**Returns:**
Returns the nearest integer if the operation is successful; returns the passed **x** if **x** is an integer, **+0**, **-0**, a NaN value, or an infinity.
## rintf\(\)
```
float rintf (float x)
```
**Description:**
Rounds the float value **x** to the nearest integer.
**Parameters:**

Name	Description
x	Indicates the float value.

**Attention:**
POSIX.1-2001 records overflow range errors. If there are two nearest integers, the even integer is returned. For example, if **x** is **0.5**, **0** is returned.
**Returns:**
Returns the nearest integer if the operation is successful; returns the passed **x** if **x** is an integer, **+0**, **-0**, a NaN value, or an infinity.
## rintl\(\)
```
long double rintl (long double x)
```
**Description:**
Rounds the long double value **x** to the nearest integer.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Attention:**
POSIX.1-2001 records overflow range errors. If there are two nearest integers, the even integer is returned. For example, if **x** is **0.5**, **0** is returned.
**Returns:**
Returns the nearest integer if the operation is successful; returns the passed **x** if **x** is an integer, **+0**, **-0**, a NaN value, or an infinity.
## round\(\)
```
double round (double x)
```
**Description:**
Rounds the double value **x** to the nearest integer, rounding away from **0**.
**Parameters:**

Name	Description
x	Indicates the double value x.

**Attention:**
Halfway values are rounded away from **0**. For example, if **x** is **0.5**, the rounded value is **1**; if **x** is **-0.5**, the rounded value is **-1**.
**Returns:**
Returns the nearest integer if the operation is successful; returns the passed **x** if **x** is an integer, **+0**, **-0**, a NaN value, or an infinity.
## roundf\(\)
```
float roundf (float x)
```
**Description:**
Rounds the float value **x** to the nearest integer, rounding away from **0**.
**Parameters:**

Name	Description
x	Indicates the float value x.

**Attention:**
Halfway values are rounded away from **0**. For example, if **x** is **0.5**, the rounded value is **1**; if **x** is **-0.5**, the rounded value is **-1**.
**Returns:**
Returns the nearest integer if the operation is successful; returns the passed **x** if **x** is an integer, **+0**, **-0**, a NaN value, or an infinity.
## roundl\(\)
```
long double roundl (long double x)
```
**Description:**
Rounds the long double value **x** to the nearest integer, rounding away from **0**.
**Parameters:**

Name	Description
x	Indicates the long double value x.

**Attention:**
Halfway values are rounded away from **0**. For example, if **x** is **0.5**, the rounded value is **1**; if **x** is **-0.5**, the rounded value is **-1**.
**Returns:**
Returns the nearest integer if the operation is successful; returns the passed **x** if **x** is an integer, **+0**, **-0**, a NaN value, or an infinity.
## scalb\(\)
```
double scalb (double x, double exp )
```
**Description:**
Multiplies the double value **x** by **FLT\_RADIX** raised to the power of the double value **exp**, that is, x\***FLT\_RADIX**^exp.
**Parameters:**

Name	Description
x	Indicates the double value x.
exp	Indicates the double value used as the exponent.

**Attention:**
**FLT\_RADIX** is defined in **float.h** and is generally **2**.
**Returns:**
Returns the calculation result if the operation is successful. If **x** or **exp** is a NaN value, this function returns a NaN value. If **x** is a positive or negative infinity, and **exp** is not a negative infinity, this function returns a positive or negative infinity. If **x** is **+0** or **-0**, and **exp** is not a positive infinity, this function returns **+0** or **-0**. If **x** is **0** and **exp** is a positive infinity, this function returns a NaN value, reports a domain error, and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is an infinity and **exp** is a negative infinity, this function returns a NaN value, reports a domain error, and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If an overflow range error occurs, this function returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) with the sign of **x** and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception. If an underflow range error occurs, this function returns **0** and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception.
## scalbf\(\)
```
float scalbf (float x, float exp )
```
**Description:**
Multiplies the float value **x** by **FLT\_RADIX** raised to the power of the float value **exp**, that is, x\***FLT\_RADIX**^exp.
**Parameters:**

Name	Description
x	Indicates the float value x.
exp	Indicates the float value used as the exponent.

**Attention:**
**FLT\_RADIX** is defined in **float.h** and is generally **2**.
**Returns:**
Returns the calculation result if the operation is successful. If **x** or **exp** is a NaN value, this function returns a NaN value. If **x** is a positive or negative infinity, and **exp** is not a negative infinity, this function returns a positive or negative infinity. If **x** is **+0** or **-0**, and **exp** is not a positive infinity, this function returns **+0** or **-0**. If **x** is **0** and **exp** is a positive infinity, this function returns a NaN value, reports a domain error, and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is an infinity and **exp** is a negative infinity, this function returns a NaN value, reports a domain error, and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If an overflow range error occurs, this function returns [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) with the sign of **x** and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception. If an underflow range error occurs, this function returns **0** and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception.
## scalbln\(\)
```
double scalbln (double x, long int exp )
```
**Description:**
Multiplies the double value **x** by **FLT\_RADIX** raised to the power of the long int value **exp**, that is, **x\*\(**FLT\_RADIX**\)^exp**.
**Parameters:**

Name	Description
x	Indicates the double value x.
exp	Indicates the double value used as the exponent.

**Attention:**
**FLT\_RADIX** is defined in **float.h** and is generally **2**.
**Returns:**
Returns the calculation result if the operation is successful. If **x** or **exp** is a NaN value, this function returns a NaN value. If **x** is a positive or negative infinity, and **exp** is not a negative infinity, this function returns a positive or negative infinity. If **x** is **+0** or **-0**, and **exp** is not a positive infinity, this function returns **+0** or **-0**. If **x** is **0** and **exp** is a positive infinity, this function returns a NaN value, reports a domain error, and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is an infinity and **exp** is a negative infinity, this function returns a NaN value, reports a domain error, and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If an overflow range error occurs, this function returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) with the sign of **x** and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception. If an underflow range error occurs, this function returns **0** and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception.
## scalblnf\(\)
```
float scalblnf (float x, long int exp )
```
**Description:**
Multiplies the float value **x** by **FLT\_RADIX** raised to the power of the long int value **exp**, that is, **x\*\(**FLT\_RADIX**\)^exp**.
**Parameters:**

Name	Description
x	Indicates the float value x.
exp	Indicates the float value used as the exponent.

**Attention:**
**FLT\_RADIX** is defined in **float.h** and is generally **2**.
**Returns:**
Returns the calculation result if the operation is successful. If **x** or **exp** is a NaN value, this function returns a NaN value. If **x** is a positive or negative infinity, and **exp** is not a negative infinity, this function returns a positive or negative infinity. If **x** is **+0** or **-0**, and **exp** is not a positive infinity, this function returns **+0** or **-0**. If **x** is **0** and **exp** is a positive infinity, this function returns a NaN value, reports a domain error, and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is an infinity and **exp** is a negative infinity, this function returns a NaN value, reports a domain error, and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If an overflow range error occurs, this function returns [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) with the sign of **x** and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception. If an underflow range error occurs, this function returns **0** and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception.
## scalblnl\(\)
```
long double scalblnl (long double x, long int exp )
```
**Description:**
Multiplies the long double value **x** by **FLT\_RADIX** raised to the power of the long int value **exp**, that is, **x\*\(**FLT\_RADIX**\)^exp**.
**Parameters:**

Name	Description
x	Indicates the long double value x.
exp	Indicates the long double value used as the exponent.

**Attention:**
**FLT\_RADIX** is defined in **float.h** and is generally **2**.
**Returns:**
Returns the calculation result if the operation is successful. If **x** or **exp** is a NaN value, this function returns a NaN value. If **x** is a positive or negative infinity, and **exp** is not a negative infinity, this function returns a positive or negative infinity. If **x** is **+0** or **-0**, and **exp** is not a positive infinity, this function returns **+0** or **-0**. If **x** is **0** and **exp** is a positive infinity, this function returns a NaN value, reports a domain error, and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is an infinity and **exp** is a negative infinity, this function returns a NaN value, reports a domain error, and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If an overflow range error occurs, this function returns [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) with the sign of **x** and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception.
## scalbn\(\)
```
double scalbn (double x, int exp )
```
**Description:**
Multiplies the double value **x** by **FLT\_RADIX** raised to the power of the int value **exp**, that is, **x\*\(**FLT\_RADIX**\)^exp**.
**Parameters:**

Name	Description
x	Indicates the double value x.
exp	Indicates the double value used as the exponent.

**Attention:**
**FLT\_RADIX** is defined in **float.h** and is generally **2**.
**Returns:**
Returns the calculation result if the operation is successful. If **x** or **exp** is a NaN value, this function returns a NaN value. If **x** is a positive or negative infinity, and **exp** is not a negative infinity, this function returns a positive or negative infinity. If **x** is **+0** or **-0**, and **exp** is not a positive infinity, this function returns **+0** or **-0**. If **x** is **0** and **exp** is a positive infinity, this function returns a NaN value, reports a domain error, and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is an infinity and **exp** is a negative infinity, this function returns a NaN value, reports a domain error, and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If an overflow range error occurs, this function returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) with the sign of **x** and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception. If an underflow range error occurs, this function returns **0** and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception.
## scalbnf\(\)
```
float scalbnf (float x, int exp )
```
**Description:**
Multiplies the float value **x** by **FLT\_RADIX** raised to the power of the int value **exp**, that is, **x\*\(**FLT\_RADIX**\)^exp**.
**Parameters:**

Name	Description
x	Indicates the float value x.
exp	Indicates the float value used as the exponent.

**Attention:**
**FLT\_RADIX** is defined in **float.h** and is generally **2**.
**Returns:**
Returns the calculation result if the operation is successful. If **x** or **exp** is a NaN value, this function returns a NaN value. If **x** is a positive or negative infinity, and **exp** is not a negative infinity, this function returns a positive or negative infinity. If **x** is **+0** or **-0**, and **exp** is not a positive infinity, this function returns **+0** or **-0**. If **x** is **0** and **exp** is a positive infinity, this function returns a NaN value, reports a domain error, and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is an infinity and **exp** is a negative infinity, this function returns a NaN value, reports a domain error, and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If an overflow range error occurs, this function returns [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) with the sign of **x** and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception. If an underflow range error occurs, this function returns **0** and throws the [FE\_UNDERFLOW](MATH.md#ga57b80dfe7d5ce60c3c76e517fce89ffe) exception.
## scalbnl\(\)
```
long double scalbnl (long double x, int exp )
```
**Description:**
Multiplies the long double value **x** by **FLT\_RADIX** raised to the power of the int value **exp**, that is, **x\*\(**FLT\_RADIX**\)^exp**.
**Parameters:**

Name	Description
x	Indicates the long double value x.
exp	Indicates the long double value used as the exponent.

**Attention:**
**FLT\_RADIX** is defined in **float.h** and is generally **2**.
**Returns:**
Returns the calculation result if the operation is successful. If **x** or **exp** is a NaN value, this function returns a NaN value. If **x** is a positive or negative infinity, and **exp** is not a negative infinity, this function returns a positive or negative infinity. If **x** is **+0** or **-0**, and **exp** is not a positive infinity, this function returns **+0** or **-0**. If **x** is **0** and **exp** is a positive infinity, this function returns a NaN value, reports a domain error, and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If **x** is an infinity and **exp** is a negative infinity, this function returns a NaN value, reports a domain error, and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception. If an overflow range error occurs, this function returns [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) with the sign of **x** and throws the [FE\_OVERFLOW](MATH.md#gad373306add36e7227d9c9620b6962323) exception.
## significand\(\)
```
double significand (double x)
```
**Description:**
Obtains the significand of the double value **x** scaled to the range \[1,2\).
The calculation formula is x\*2^-[ilogb](MATH.md#ga600dd249210d15af31b9a29c2d09d255)\(x\). This function is mainly used in certain standardized tests for IEEE 754 conformance.
**Parameters:**

Name	Description
x	Indicates the double value x.

**Returns:**
Returns the significand of **x** if the operation is successful.
## significandf\(\)
```
float significandf (float x)
```
**Description:**
Obtains the significand of the float value **x** scaled to the range \[1,2\).
The calculation formula is x\*2^-[ilogb](MATH.md#ga600dd249210d15af31b9a29c2d09d255)\(x\). This function is mainly used in certain standardized tests for IEEE 754 conformance.
**Parameters:**

Name	Description
x	Indicates the float value x.

**Returns:**
Returns the significand of **x** if the operation is successful.
## sin\(\)
```
double sin (double x)
```
**Description:**
Calculates the sine of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the sine of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive or negative infinity, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## sincos\(\)
```
void sincos (double x, double * sin, double * cos )
```
**Description:**
Calculates the sine and cosine of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value whose sine and cosine are to be calculated.
sin	Indicates the pointer to the obtained sine.
cos	Indicates the pointer to the obtained cosine.

**Attention:**
A domain error occurs if **x** is an infinity. In this case, the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception is thrown, and **sin** and **cos** are both NaN values. If **x** is a NaN value, **sin** and **cos** are both NaN values.
## sincosf\(\)
```
void sincosf (float x, float * sin, float * cos )
```
**Description:**
Calculates the sine and cosine of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the double value whose sine and cosine are to be calculated.
sin	Indicates the pointer to the obtained sine.
cos	Indicates the pointer to the obtained cosine.

**Attention:**
A domain error occurs if **x** is an infinity. In this case, the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception is thrown, and **sin** and **cos** are both NaN values. If **x** is a NaN value, **sin** and **cos** are both NaN values.
## sincosl\(\)
```
void sincosl (long double x, long double * sin, long double * cos )
```
**Description:**
Calculates the sine and cosine of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value whose sine and cosine are to be calculated.
sin	Indicates the pointer to the obtained sine.
cos	Indicates the pointer to the obtained cosine.

**Attention:**
A domain error occurs if **x** is an infinity. In this case, the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception is thrown, and **sin** and **cos** are both NaN values. If **x** is a NaN value, **sin** and **cos** are both NaN values.
## sinf\(\)
```
float sinf (float x)
```
**Description:**
Calculates the sine of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the sine of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive or negative infinity, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## sinh\(\)
```
double sinh (double x)
```
**Description:**
Calculates the hyperbolic sine of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the hyperbolic sine of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**, respectively. If **x** is a positive or negative infinity, this function returns a positive or negative infinity. If an overflow range error occurs, this function returns [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) with the sign of **x**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## sinhf\(\)
```
float sinhf (float x)
```
**Description:**
Calculates the hyperbolic sine of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the hyperbolic sine of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**, respectively. If **x** is a positive or negative infinity, this function returns a positive or negative infinity. If an overflow range error occurs, this function returns [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) with the sign of **x**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## sinhl\(\)
```
long double sinhl (long double x)
```
**Description:**
Calculates the hyperbolic sine of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Returns:**
Returns the hyperbolic sine of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **+0** or **-0**, this function returns **+0** or **-0**, respectively. If **x** is a positive or negative infinity, this function returns a positive or negative infinity. If an overflow range error occurs, this function returns [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) with the sign of **x**, sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## sinl\(\)
```
long double sinl (long double x)
```
**Description:**
Calculates the sine of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Returns:**
Returns the sine of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive or negative infinity, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## sqrt\(\)
```
double sqrt (double x)
```
**Description:**
Calculates the square root of double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the square root of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **0**, this function returns **0**. If **x** is less than **-0**, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## sqrtf\(\)
```
float sqrtf (float x)
```
**Description:**
Calculates the square root of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the square root of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **0**, this function returns **0**. If **x** is less than **-0**, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## sqrtl\(\)
```
long double sqrtl (long double x)
```
**Description:**
Calculates the square root of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Returns:**
Returns the square root of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **0**, this function returns **0**. If **x** is less than **-0**, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## tan\(\)
```
double tan (double x)
```
**Description:**
Calculates the tangent of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value, which represents an angle in radians.

**Returns:**
Returns the tangent of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **0**, this function returns **0**. If **x** is less than **-0**, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## tanf\(\)
```
float tanf (float x)
```
**Description:**
Calculates the tangent of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value, which represents an angle in radians.

**Returns:**
Returns the tangent of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **0**, this function returns **0**. If **x** is less than **-0**, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## tanh\(\)
```
double tanh (double x)
```
**Description:**
Calculates the hyperbolic tangent of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the hyperbolic tangent of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **0**, this function returns **0**. If **x** is less than **-0**, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## tanhf\(\)
```
float tanhf (float x)
```
**Description:**
Calculates the hyperbolic tangent of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the hyperbolic tangent of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **0**, this function returns **0**. If **x** is less than **-0**, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## tanhl\(\)
```
long double tanhl (long double x)
```
**Description:**
Calculates the hyperbolic tangent of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Returns:**
Returns the hyperbolic tangent of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **0**, this function returns **0**. If **x** is less than **-0**, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## tanl\(\)
```
long double tanl (long double x)
```
**Description:**
Calculates the tangent of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value, which represents an angle in radians.

**Returns:**
Returns the tangent of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **0**, this function returns **0**. If **x** is less than **-0**, this function returns a NaN value, reports a domain error, sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70), and throws the [FE\_INVALID](MATH.md#ga638c8489adb1fac7204b07ece42998ae) exception.
## tgamma\(\)
```
double tgamma (double x)
```
**Description:**
Calculates the gamma function of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the gamma function of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is a negative integer or negative infinity, this function returns a NaN value, reports a domain error, and sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70). If an underflow range error occurs, this function returns **+0**. If **x** is **+0** or **-0**, this function returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) with the sign of **x**, reports a pole error, and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca). If an overflow range error occurs, this function returns [HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971) and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca).
## tgammaf\(\)
```
float tgammaf (float x)
```
**Description:**
Calculates the gamma function of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the gamma function of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is a negative integer or negative infinity, this function returns a NaN value, reports a domain error, and sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70). If an underflow range error occurs, this function returns **+0**. If **x** is **+0** or **-0**, this function returns [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) with the sign of **x**, reports a pole error, and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca). If an overflow range error occurs, this function returns [HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359) and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca).
## tgammal\(\)
```
long double tgammal (long double x)
```
**Description:**
Calculates the gamma function of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value.

**Returns:**
Returns the gamma function of **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is a positive infinity, this function returns a positive infinity. If **x** is a negative integer or negative infinity, this function returns a NaN value, reports a domain error, and sets **errno** to [EDOM](UTILS.md#ga5fe247e079b591a68e0fdbf7caec5b70). If an underflow range error occurs, this function returns **+0**. If **x** is **+0** or **-0**, this function returns [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) with the sign of **x**, reports a pole error, and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca). If an overflow range error occurs, this function returns [HUGE\_VALL](MATH.md#gab8b359c356d4311bf5d4ae6c03f43182) and sets **errno** to [ERANGE](UTILS.md#gaa1591a4f3a86360108de5b9ba34980ca).
## trunc\(\)
```
double trunc (double x)
```
**Description:**
Obtains the nearest integer whose absolute value is less than or equal to the absolute value of the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value x.

**Returns:**
Returns the nearest integer whose absolute value is less than or equal to the absolute value of **x**.
## truncf\(\)
```
float truncf (float x)
```
**Description:**
Obtains the nearest integer whose absolute value is less than or equal to the absolute value of the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value x.

**Returns:**
Returns the nearest integer whose absolute value is less than or equal to the absolute value of **x**.
## truncl\(\)
```
long double truncl (long double x)
```
**Description:**
Obtains the nearest integer whose absolute value is less than or equal to the absolute value of the long double value **x**.
**Parameters:**

Name	Description
x	Indicates the long double value x.

**Returns:**
Returns the nearest integer whose absolute value is less than or equal to the absolute value of **x**.
## y0\(\)
```
double y0 (double x)
```
**Description:**
Calculates the Bessel function of the second kind of order **0** for the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the Bessel function of the second kind of order **0** for **x** if the operation is successful . If **x** is a NaN value, this function returns a NaN value. If **x** is **0.0**, this function returns **-[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)** and reports a pole error. If **x** is a negative value, this function returns **-[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)** and reports a range error. If an overflow range error occurs, this function returns **0.0**.
## y0f\(\)
```
float y0f (float x)
```
**Description:**
Calculates the Bessel function of the second kind of order **0** for the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the calculation result if the operation is successful; returns a NaN value if **x** is a NaN value; returns **-[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)** and reports a pole error if **x** is **0.0**; returns **-[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)** and reports a domain error if **x** is a negative value; returns **0.0** if an overflow range error occurs.
## y1\(\)
```
double y1 (double x)
```
**Description:**
Calculates the Bessel function of the second kind of order **1** for the double value **x**.
**Parameters:**

Name	Description
x	Indicates the double value.

**Returns:**
Returns the Bessel function of the second kind of order **1** for **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **0.0**, this function returns **-[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)** and reports a pole error. If **x** is a negative value, this function returns **-[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)** and reports a range error. If an overflow range error occurs, this function returns **0.0**.
## y1f\(\)
```
float y1f (float x)
```
**Description:**
Calculates the Bessel function of the second kind of order **1** for the float value **x**.
**Parameters:**

Name	Description
x	Indicates the float value.

**Returns:**
Returns the calculation result if the operation is successful; returns a NaN value if **x** is a NaN value; returns **-[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)** and reports a pole error if **x** is **0.0**; returns **-[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)** and reports a domain error if **x** is a negative value; returns **0.0** if an overflow range error occurs.
## yn\(\)
```
double yn (int n, double x )
```
**Description:**
Calculates the Bessel function of the second kind of order **n** for the double value **x**.
**Parameters:**

Name	Description
n	Indicates the order of the Bessel function of the first kind.
x	Indicates the double value.

**Returns:**
Returns the Bessel function of the second kind of order **n** for **x** if the operation is successful. If **x** is a NaN value, this function returns a NaN value. If **x** is **0.0**, this function returns **-[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)** and reports a pole error. If **x** is a negative value, this function returns **-[HUGE\_VAL](MATH.md#gaf2164b2db92d8a0ed3838ad5c28db971)** and reports a range error. If an overflow range error occurs, this function returns **0.0**.
## ynf\(\)
```
float ynf (int n, float x )
```
**Description:**
Calculates the Bessel function of the second kind of order **n** for the float value **x**.
**Parameters:**

Name	Description
n	Indicates the order of the Bessel function of the second kind.
x	Indicates the float value.

**Returns:**
Returns the calculation result if the operation is successful; returns a NaN value if **x** is a NaN value; returns **-[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)** and reports a pole error if **x** is **0.0**; returns **-[HUGE\_VALF](MATH.md#gacd69981d54c27fe0ff514645dbfc6359)** and reports a domain error if **x** is a negative value; returns **0.0** if an overflow range error occurs.