avr_math - <math.h>: Mathematics

       Generated automatically by Doxygen for AVR-LibC from the source code.

AVR-LibC                                          Version 2.2.1                                   avr_math(3avr)

       #include <math.h>

       This header file declares basic mathematics constants and functions.

       Notes:

           • Math functions do not raise exceptions and do not change the errno variable. Therefore the majority
             of them are declared with const attribute, for better optimization by GCC.

           • 64-bit  floating-point  arithmetic  is only available in avr-gcc v10 and up. The size of the double
             and long double type can be selected at compile-time with  options  like  -mdouble=64  and  -mlong-
             double=32. Whether such options are available, and their default values, depend on how the compiler
             has been configured.

           • The  implementation  of 64-bit floating-point arithmetic has some shortcomings and limitations, see
             the avr-gcc Wiki for details.

           • In order to access the float functions, in avr-gcc v4.6 and older it is usually  also  required  to
             link with -lm. In avr-gcc v4.7 and up, -lm is added automatically to all linker invocations.

doubleacos(doublex)[extern]
       The  acos()  function  computes  the principal value of the arc cosine of x. The returned value is in the
       range [0, pi] radians or NaN.

   floatacosf(floatx)[extern]
       The acosf() function computes the principal value of the arc cosine of x. The returned value  is  in  the
       range [0, pi] radians. A domain error occurs for arguments not in the range [1, +1].

   longdoubleacosl(longdoublex)[extern]
       The  acosl()  function  computes the principal value of the arc cosine of x. The returned value is in the
       range [0, pi] radians or NaN.

   doubleasin(doublex)[extern]
       The asin() function computes the principal value of the arc sine of x. The returned value is in the range
       [pi/2, pi/2] radians or NaN.

   floatasinf(floatx)[extern]
       The asinf() function computes the principal value of the arc sine of x. The  returned  value  is  in  the
       range [pi/2, pi/2] radians. A domain error occurs for arguments not in the range [1, +1].

   longdoubleasinl(longdoublex)[extern]
       The  asinl()  function  computes  the  principal value of the arc sine of x. The returned value is in the
       range [pi/2, pi/2] radians or NaN.

   doubleatan(doublex)[extern]
       The atan() function computes the principal value of the arc tangent of x. The returned value  is  in  the
       range [pi/2, pi/2] radians.

   doubleatan2(doubley,doublex)[extern]
       The  atan2()  function  computes the principal value of the arc tangent of y/x, using the signs of both
       arguments to determine the quadrant of the return value. The returned value is in  the  range  [pi,  +pi]
       radians.

   floatatan2f(floaty,floatx)[extern]
       The  atan2f()  function computes the principal value of the arc tangent of y/x, using the signs of both
       arguments to determine the quadrant of the return value. The returned value is in  the  range  [pi,  +pi]
       radians.

   longdoubleatan2l(longdoubley,longdoublex)[extern]
       The  atan2l()  function computes the principal value of the arc tangent of y/x, using the signs of both
       arguments to determine the quadrant of the return value. The returned value is in  the  range  [pi,  +pi]
       radians.

   floatatanf(floatx)[extern]
       The  atanf()  function computes the principal value of the arc tangent of x. The returned value is in the
       range [pi/2, pi/2] radians.

   longdoubleatanl(longdoublex)[extern]
       The atanl() function computes the principal value of the arc tangent of x. The returned value is  in  the
       range [pi/2, pi/2] radians.

   doublecbrt(doublex)[extern]
       The cbrt() function returns the cube root of x.

   floatcbrtf(floatx)[extern]
       The cbrtf() function returns the cube root of x.

   longdoublecbrtl(longdoublex)[extern]
       The cbrtl() function returns the cube root of x.

   doubleceil(doublex)[extern]
       The  ceil()  function  returns  the  smallest  integral  value greater than or equal to x, expressed as a
       floating-point number.

   floatceilf(floatx)[extern]
       The ceilf() function returns the smallest integral value greater than or  equal  to  x,  expressed  as  a
       floating-point number.

   longdoubleceill(longdoublex)[extern]
       The  ceill()  function  returns  the  smallest  integral value greater than or equal to x, expressed as a
       floating-point number.

   staticdoublecopysign(double__x,double__y)[inline],[static]
       The copysign() function returns __x but with the sign of __y. They work even if __x or  __y  are  NaN  or
       zero.

   staticfloatcopysignf(float__x,float__y)[inline],[static]
       The  copysignf()  function  returns __x but with the sign of __y. They work even if __x or __y are NaN or
       zero.

   staticlongdoublecopysignl(longdouble__x,longdouble__y)[inline],[static]
       The copysignl() function returns __x but with the sign of __y. They work even if __x or __y  are  NaN  or
       zero.

   doublecos(doublex)[extern]
       The cos() function returns the cosine of x, measured in radians.

   floatcosf(floatx)[extern]
       The cosf() function returns the cosine of x, measured in radians.

   doublecosh(doublex)[extern]
       The cosh() function returns the hyperbolic cosine of x.

   floatcoshf(floatx)[extern]
       The coshf() function returns the hyperbolic cosine of x.

   longdoublecoshl(longdoublex)[extern]
       The coshl() function returns the hyperbolic cosine of x.

   longdoublecosl(longdoublex)[extern]
       The cosl() function returns the cosine of x, measured in radians.

   doubleexp(doublex)[extern]
       The exp() function returns the exponential value of x.

   floatexpf(floatx)[extern]
       The expf() function returns the exponential value of x.

   longdoubleexpl(longdoublex)[extern]
       The expl() function returns the exponential value of x.

   staticdoublefabs(double__x)[inline],[static]
       The fabs() function computes the absolute value of a floating-point number x.

   staticfloatfabsf(float__x)[inline],[static]
       The fabsf() function computes the absolute value of a floating-point number x.

   staticlongdoublefabsl(longdouble__x)[inline],[static]
       The fabsl() function computes the absolute value of a floating-point number x.

   doublefdim(doublex,doubley)[extern]
       The fdim() function returns max(xy,0). If x or y or both are NaN, NaN is returned.

   floatfdimf(floatx,floaty)[extern]
       The fdimf() function returns max(xy,0). If x or y or both are NaN, NaN is returned.

   longdoublefdiml(longdoublex,longdoubley)[extern]
       The fdiml() function returns max(xy,0). If x or y or both are NaN, NaN is returned.

   doublefloor(doublex)[extern]
       The floor() function returns the largest integral value less than or equal to x, expressed as a floating-
       point number.

   floatfloorf(floatx)[extern]
       The  floorf()  function  returns  the  largest  integral  value  less  than or equal to x, expressed as a
       floating-point number.

   longdoublefloorl(longdoublex)[extern]
       The floorl() function returns the largest integral value  less  than  or  equal  to  x,  expressed  as  a
       floating-point number.

   doublefma(doublex,doubley,doublez)[extern]
       The  fma()  function  performs  floating-point  multiply-add.  This is the operation (x*y)+z, but the
       intermediate result is not rounded to the destination type. This can sometimes improve the precision of a
       calculation.

   floatfmaf(floatx,floaty,floatz)[extern]
       The fmaf() function performs floating-point multiply-add. This is the operation (x*y)+z,  but  the
       intermediate result is not rounded to the destination type. This can sometimes improve the precision of a
       calculation.

   longdoublefmal(longdoublex,longdoubley,longdoublez)[extern]
       The  fmal()  function  performs  floating-point  multiply-add. This is the operation (x*y)+z, but the
       intermediate result is not rounded to the destination type. This can sometimes improve the precision of a
       calculation.

   doublefmax(doublex,doubley)[extern]
       The fmax() function returns the greater of the two values x and y. If  an  argument  is  NaN,  the  other
       argument is returned. If both arguments are NaN, NaN is returned.

   floatfmaxf(floatx,floaty)[extern]
       The  fmaxf()  function  returns  the  greater of the two values x and y. If an argument is NaN, the other
       argument is returned. If both arguments are NaN, NaN is returned.

   longdoublefmaxl(longdoublex,longdoubley)[extern]
       The fmaxl() function returns the greater of the two values x and y. If an  argument  is  NaN,  the  other
       argument is returned. If both arguments are NaN, NaN is returned.

   doublefmin(doublex,doubley)[extern]
       The  fmin()  function  returns  the  lesser  of  the two values x and y. If an argument is NaN, the other
       argument is returned. If both arguments are NaN, NaN is returned.

   floatfminf(floatx,floaty)[extern]
       The fminf() function returns the lesser of the two values x and y. If  an  argument  is  NaN,  the  other
       argument is returned. If both arguments are NaN, NaN is returned.

   longdoublefminl(longdoublex,longdoubley)[extern]
       The  fminl()  function  returns  the  lesser  of the two values x and y. If an argument is NaN, the other
       argument is returned. If both arguments are NaN, NaN is returned.

   doublefmod(doublex,doubley)[extern]
       The function fmod() returns the floating-point remainder of x/y.

   floatfmodf(floatx,floaty)[extern]
       The function fmodf() returns the floating-point remainder of x/y.

   longdoublefmodl(longdoublex,longdoubley)[extern]
       The function fmodl() returns the floating-point remainder of x/y.

   doublefrexp(doublex,int*pexp)[extern]
       The frexp() function breaks a floating-point number into a normalized fraction and an integral  power  of
       2. It stores the integer in the int object pointed to by pexp.

       If  x  is  a  normal  float  point  number,  the  frexp() function returns the value v, such that v has a
       magnitude in the interval [1/2, 1) or zero, and x equals v times 2 raised to the  power  pexp.  If  x  is
       zero,  both  parts  of  the result are zero. If x is not a finite number, the frexp() returns x as is and
       stores 0 by pexp.

   floatfrexpf(floatx,int*pexp)[extern]
       The frexpf() function breaks a floating-point number into a normalized fraction and an integral power  of
       2. It stores the integer in the int object pointed to by pexp.

       If  x  is  a  normal  float  point  number,  the frexpf() function returns the value v, such that v has a
       magnitude in the interval [1/2, 1) or zero, and x equals v times 2 raised to the  power  pexp.  If  x  is
       zero,  both  parts  of the result are zero. If x is not a finite number, the frexpf() returns x as is and
       stores 0 by pexp.

       Note
           This implementation permits a zero pointer as a directive to skip a storing the exponent.

   longdoublefrexpl(longdoublex,int*pexp)[extern]
       The frexpl() function breaks a floating-point number into a normalized fraction and an integral power  of
       2. It stores the integer in the int object pointed to by pexp.

       If  x  is  a  normal  float  point  number,  the frexpl() function returns the value v, such that v has a
       magnitude in the interval [1/2, 1) or zero, and x equals v times 2 raised to the  power  pexp.  If  x  is
       zero,  both  parts  of the result are zero. If x is not a finite number, the frexpl() returns x as is and
       stores 0 by pexp.

   doublehypot(doublex,doubley)[extern]
       The hypot() function returns sqrt(x*x+y*y). This is the length of the hypotenuse of  a  right  triangle
       with  sides  of  length x and y, or the distance of the point (x, y) from the origin. Using this function
       instead of the direct formula is wise, since the error is much smaller. No underflow with small x and  y.
       No overflow if result is in range.

   floathypotf(floatx,floaty)[extern]
       The  hypotf() function returns sqrtf(x*x+y*y). This is the length of the hypotenuse of a right triangle
       with sides of length x and y, or the distance of the point (x, y) from the origin.  Using  this  function
       instead  of the direct formula is wise, since the error is much smaller. No underflow with small x and y.
       No overflow if result is in range.

   longdoublehypotl(longdoublex,longdoubley)[extern]
       The hypotl() function returns sqrtl(x*x+y*y). This is the length of the hypotenuse of a right  triangle
       with  sides  of  length x and y, or the distance of the point (x, y) from the origin. Using this function
       instead of the direct formula is wise, since the error is much smaller. No underflow with small x and  y.
       No overflow if result is in range.

   staticintisfinite(double__x)[inline],[static]
       The  isfinite()  function  returns  a nonzero value if __x is finite: not plus or minus infinity, and not
       NaN.

   staticintisfinitef(float__x)[inline],[static]
       The isfinitef() function returns a nonzero value if __x is finite: not plus or minus  infinity,  and  not
       NaN.

   staticintisfinitel(longdouble__x)[inline],[static]
       The  isfinite()  function  returns  a nonzero value if __x is finite: not plus or minus infinity, and not
       NaN.

   intisinf(doublex)[extern]
       The function isinf() returns 1 if the argument x is positive infinity, 1 if x is negative infinity, and 0
       otherwise.

   intisinff(floatx)[extern]
       The function isinff() returns 1 if the argument x is positive infinity, 1 if x is negative infinity,  and
       0 otherwise.

   intisinfl(longdoublex)[extern]
       The  function isinfl() returns 1 if the argument x is positive infinity, 1 if x is negative infinity, and
       0 otherwise.

   intisnan(doublex)[extern]
       The function isnan() returns 1 if the argument x represents a 'not-a-number' (NaN) object, otherwise 0.

   intisnanf(floatx)[extern]
       The function isnanf() returns 1 if the argument x represents a 'not-a-number' (NaN) object, otherwise 0.

   intisnanl(longdoublex)[extern]
       The function isnanl() returns 1 if the argument x represents a 'not-a-number' (NaN) object, otherwise 0.

   doubleldexp(doublex,intiexp)[extern]
       The ldexp() function multiplies a floating-point number by an integral power of 2. It returns  the  value
       of x times 2 raised to the power iexp.

   floatldexpf(floatx,intiexp)[extern]
       The  ldexpf() function multiplies a floating-point number by an integral power of 2. It returns the value
       of x times 2 raised to the power iexp.

   longdoubleldexpl(longdoublex,intiexp)[extern]
       The ldexpl() function multiplies a floating-point number by an integral power of 2. It returns the  value
       of x times 2 raised to the power iexp.

   doublelog(doublex)[extern]
       The log() function returns the natural logarithm of argument x.

   doublelog10(doublex)[extern]
       The log10() function returns the logarithm of argument x to base 10.

   floatlog10f(floatx)[extern]
       The log10f() function returns the logarithm of argument x to base 10.

   longdoublelog10l(longdoublex)[extern]
       The log10l() function returns the logarithm of argument x to base 10.

   floatlogf(floatx)[extern]
       The logf() function returns the natural logarithm of argument x.

   longdoublelogl(longdoublex)[extern]
       The logl() function returns the natural logarithm of argument x.

   longlrint(doublex)[extern]
       The  lrint()  function  rounds  x  to the nearest integer, rounding the halfway cases to the even integer
       direction. (That is both 1.5 and 2.5 values are rounded  to  2).  This  function  is  similar  to  rint()
       function, but it differs in type of return value and in that an overflow is possible.

       Returns
           The  rounded  long  integer  value.  If x is not a finite number or an overflow was, this realization
           returns the LONG_MIN value (0x80000000).

   longlrintf(floatx)[extern]
       The lrintf() function rounds x to the nearest integer, rounding the halfway cases  to  the  even  integer
       direction.  (That  is  both  1.5  and  2.5  values are rounded to 2). This function is similar to rintf()
       function, but it differs in type of return value and in that an overflow is possible.

       Returns
           The rounded long integer value. If x is not a finite number or  an  overflow  was,  this  realization
           returns the LONG_MIN value (0x80000000).

   longlrintl(longdoublex)[extern]
       The  lrintl()  function  rounds  x to the nearest integer, rounding the halfway cases to the even integer
       direction. (That is both 1.5 and 2.5 values are rounded to  2).  This  function  is  similar  to  rintl()
       function, but it differs in type of return value and in that an overflow is possible.

       Returns
           The  rounded  long  integer  value.  If x is not a finite number or an overflow was, this realization
           returns the LONG_MIN value (0x80000000).

   longlround(doublex)[extern]
       The lround() function rounds x to the nearest integer, but rounds halfway cases away from  zero  (instead
       of  to the nearest even integer). This function is similar to round() function, but it differs in type of
       return value and in that an overflow is possible.

       Returns
           The rounded long integer value. If x is not a finite number or  an  overflow  was,  this  realization
           returns the LONG_MIN value (0x80000000).

   longlroundf(floatx)[extern]
       The  lroundf() function rounds x to the nearest integer, but rounds halfway cases away from zero (instead
       of to the nearest even integer). This function is similar to round() function, but it differs in type  of
       return value and in that an overflow is possible.

       Returns
           The  rounded  long  integer  value.  If x is not a finite number or an overflow was, this realization
           returns the LONG_MIN value (0x80000000).

   longlroundl(longdoublex)[extern]
       The lroundl() function rounds x to the nearest integer, but rounds halfway cases away from zero  (instead
       of  to the nearest even integer). This function is similar to round() function, but it differs in type of
       return value and in that an overflow is possible.

       Returns
           The rounded long integer value. If x is not a finite number or  an  overflow  was,  this  realization
           returns the LONG_MIN value (0x80000000).

   doublemodf(doublex,double*iptr)[extern]
       The  modf() function breaks the argument x into integral and fractional parts, each of which has the same
       sign as the argument. It stores the integral part as a double in the object pointed to by iptr.

       The modf() function returns the signed fractional part of x.

   floatmodff(floatx,float*iptr)[extern]
       The modff() function breaks the argument x into integral and fractional parts, each of which has the same
       sign as the argument. It stores the integral part as a float in the object pointed to by iptr.

       The modff() function returns the signed fractional part of x.

       Note
           This implementation skips writing by zero pointer. However, the GCC 4.3  can  replace  this  function
           with inline code that does not permit to use NULL address for the avoiding of storing.

   longdoublemodfl(longdoublex,longdouble*iptr)[extern]
       The modfl() function breaks the argument x into integral and fractional parts, each of which has the same
       sign as the argument. It stores the integral part as a long double in the object pointed to by iptr.

       The modf() function returns the signed fractional part of x.

   doublepow(doublex,doubley)[extern]
       The function pow() returns the value of x to the exponent y.
        Notice that for integer exponents, there is the more efficient double __builtin_powi(double x, int y).

   floatpowf(floatx,floaty)[extern]
       The function powf() returns the value of x to the exponent y.
        Notice that for integer exponents, there is the more efficient float __builtin_powif(float x, int y).

   longdoublepowl(longdoublex,longdoubley)[extern]
       The function powl() returns the value of x to the exponent y.
        Notice  that  for integer exponents, there is the more efficient long double __builtin_powil(long double
       x, int y).

   doubleround(doublex)[extern]
       The round() function rounds x to the nearest integer, but rounds halfway cases away from zero (instead of
       to the nearest even integer). Overflow is impossible.

       Returns
           The rounded value. If x is an integral or infinite, x itself is returned. If x is NaN,  then  NaN  is
           returned.

   floatroundf(floatx)[extern]
       The  roundf()  function rounds x to the nearest integer, but rounds halfway cases away from zero (instead
       of to the nearest even integer). Overflow is impossible.

       Returns
           The rounded value. If x is an integral or infinite, x itself is returned. If x is NaN,  then  NaN  is
           returned.

   longdoubleroundl(longdoublex)[extern]
       The  roundl()  function rounds x to the nearest integer, but rounds halfway cases away from zero (instead
       of to the nearest even integer). Overflow is impossible.

       Returns
           The rounded value. If x is an integral or infinite, x itself is returned. If x is NaN,  then  NaN  is
           returned.

   intsignbit(doublex)[extern]
       The  signbit()  function  returns a nonzero value if the value of x has its sign bit set. This is not the
       same as `x < 0.0', because IEEE 754 floating point allows zero to be signed. The comparison '0.0  <  0.0'
       is false, but `signbit (0.0)' will return a nonzero value.

   intsignbitf(floatx)[extern]
       The  signbitf()  function returns a nonzero value if the value of x has its sign bit set. This is not the
       same as `x < 0.0', because IEEE 754 floating point allows zero to be signed. The comparison '0.0  <  0.0'
       is false, but `signbit (0.0)' will return a nonzero value.

   intsignbitl(longdoublex)[extern]
       The  signbitl()  function returns a nonzero value if the value of x has its sign bit set. This is not the
       same as `x < 0.0', because IEEE 754 floating point allows zero to be signed. The comparison '0.0  <  0.0'
       is false, but `signbit (0.0)' will return a nonzero value.

   doublesin(doublex)[extern]
       The sin() function returns the sine of x, measured in radians.

   floatsinf(floatx)[extern]
       The sinf() function returns the sine of x, measured in radians.

   doublesinh(doublex)[extern]
       The sinh() function returns the hyperbolic sine of x.

   floatsinhf(floatx)[extern]
       The sinhf() function returns the hyperbolic sine of x.

   longdoublesinhl(longdoublex)[extern]
       The sinhl() function returns the hyperbolic sine of x.

   longdoublesinl(longdoublex)[extern]
       The sinl() function returns the sine of x, measured in radians.

   doublesqrt(doublex)[extern]
       The sqrt() function returns the non-negative square root of x.

   floatsqrtf(floatx)[extern]
       The sqrtf() function returns the non-negative square root of x.

   longdoublesqrtl(longdoublex)[extern]
       The sqrtl() function returns the non-negative square root of x.

   doublesquare(doublex)[extern]
       The function square() returns x*x.

       Note
           This function does not belong to the C standard definition.

   floatsquaref(floatx)[extern]
       The function squaref() returns x*x.

       Note
           This function does not belong to the C standard definition.

   longdoublesquarel(longdoublex)[extern]
       The function squarel() returns x*x.

       Note
           This function does not belong to the C standard definition.

   doubletan(doublex)[extern]
       The tan() function returns the tangent of x, measured in radians.

   floattanf(floatx)[extern]
       The tanf() function returns the tangent of x, measured in radians.

   doubletanh(doublex)[extern]
       The tanh() function returns the hyperbolic tangent of x.

   floattanhf(floatx)[extern]
       The tanhf() function returns the hyperbolic tangent of x.

   longdoubletanhl(longdoublex)[extern]
       The tanhl() function returns the hyperbolic tangent of x.

   longdoubletanl(longdoublex)[extern]
       The tanl() function returns the tangent of x, measured in radians.

   doubletrunc(doublex)[extern]
       The trunc() function rounds x to the nearest integer not larger in absolute value.

   floattruncf(floatx)[extern]
       The truncf() function rounds x to the nearest integer not larger in absolute value.

   longdoubletruncl(longdoublex)[extern]
       The truncl() function rounds x to the nearest integer not larger in absolute value.

#defineHUGE_VAL__builtin_huge_val()
       double infinity constant.

   #defineHUGE_VALF__builtin_huge_valf()
       float infinity constant.

   #defineHUGE_VALL__builtin_huge_vall()
       long double infinity constant.

   #defineINFINITY__builtin_inf()
       double infinity constant.

   #defineM_1_PI0.31830988618379067154
       The constant 1/pi.

   #defineM_2_PI0.63661977236758134308
       The constant 2/pi.

   #defineM_2_SQRTPI1.12837916709551257390
       The constant 2/sqrt(pi).

   #defineM_E2.7182818284590452354
       The constant Euler's number e.

   #defineM_LN102.30258509299404568402
       The constant natural logarithm of 10.

   #defineM_LN20.69314718055994530942
       The constant natural logarithm of 2.

   #defineM_LOG10E0.43429448190325182765
       The constant logarithm of Euler's number e to base 10.

   #defineM_LOG2E1.4426950408889634074
       The constant logarithm of Euler's number e to base 2.

   #defineM_PI3.14159265358979323846
       The constant pi.

   #defineM_PI_21.57079632679489661923
       The constant pi/2.

   #defineM_PI_40.78539816339744830962
       The constant pi/4.

   #defineM_SQRT1_20.70710678118654752440
       The constant 1/sqrt(2).

   #defineM_SQRT21.41421356237309504880
       The square root of 2.

   #defineNAN__builtin_nan('')
       The double representation of a constant quiet NaN.

   #definenan(__tag)__builtin_nan(__tag)
       The double representation of a constant quiet NaN. __tag is a string constant like '' or '123'.

   #definenanf(__tagp)__builtin_nanf(__tag)
       The float representation of a constant quiet NaN. __tag is a string constant like '' or '123'.

   #definenanl(__tag)__builtin_nanl(__tag)
       The long double representation of a constant quiet NaN. __tag is a string constant like '' or '123'.

       avr_math - <math.h>: Mathematics

Macros
       #define M_E   2.7182818284590452354
       #define M_LOG2E   1.4426950408889634074
       #define M_LOG10E   0.43429448190325182765
       #define M_LN2   0.69314718055994530942
       #define M_LN10   2.30258509299404568402
       #define M_PI   3.14159265358979323846
       #define M_PI_2   1.57079632679489661923
       #define M_PI_4   0.78539816339744830962
       #define M_1_PI   0.31830988618379067154
       #define M_2_PI   0.63661977236758134308
       #define M_2_SQRTPI   1.12837916709551257390
       #define M_SQRT2   1.41421356237309504880
       #define M_SQRT1_2   0.70710678118654752440
       #define NAN   __builtin_nan('')
       #define nanf(__tagp)   __builtin_nanf(__tag)
       #define nan(__tag)   __builtin_nan(__tag)
       #define nanl(__tag)   __builtin_nanl(__tag)
       #define INFINITY   __builtin_inf()
       #define HUGE_VALF   __builtin_huge_valf()
       #define HUGE_VAL   __builtin_huge_val()
       #define HUGE_VALL   __builtin_huge_vall()

   Functions
       float cosf (float x)
       double cos (double x)
       long double cosl (long double x)
       float sinf (float x)
       double sin (double x)
       long double sinl (long double x)
       float tanf (float x)
       double tan (double x)
       long double tanl (long double x)
       static float fabsf (float __x)
       static double fabs (double __x)
       static long double fabsl (long double __x)
       float fmodf (float x, float y)
       double fmod (double x, double y)
       long double fmodl (long double x, long double y)
       float modff (float x, float *iptr)
       double modf (double x, double *iptr)
       long double modfl (long double x, long double *iptr)
       float sqrtf (float x)
       double sqrt (double x)
       long double sqrtl (long double x)
       float cbrtf (float x)
       double cbrt (double x)
       long double cbrtl (long double x)
       float hypotf (float x, float y)
       double hypot (double x, double y)
       long double hypotl (long double x, long double y)
       float floorf (float x)
       double floor (double x)
       long double floorl (long double x)
       float ceilf (float x)
       double ceil (double x)
       long double ceill (long double x)
       float frexpf (float x, int *pexp)
       double frexp (double x, int *pexp)
       long double frexpl (long double x, int *pexp)
       float ldexpf (float x, int iexp)
       double ldexp (double x, int iexp)
       long double ldexpl (long double x, int iexp)
       float expf (float x)
       double exp (double x)
       long double expl (long double x)
       float coshf (float x)
       double cosh (double x)
       long double coshl (long double x)
       float sinhf (float x)
       double sinh (double x)
       long double sinhl (long double x)
       float tanhf (float x)
       double tanh (double x)
       long double tanhl (long double x)
       float acosf (float x)
       double acos (double x)
       long double acosl (long double x)
       float asinf (float x)
       double asin (double x)
       long double asinl (long double x)
       float atanf (float x)
       double atan (double x)
       long double atanl (long double x)
       float atan2f (float y, float x)
       double atan2 (double y, double x)
       long double atan2l (long double y, long double x)
       float logf (float x)
       double log (double x)
       long double logl (long double x)
       float log10f (float x)
       double log10 (double x)
       long double log10l (long double x)
       float powf (float x, float y)
       double pow (double x, double y)
       long double powl (long double x, long double y)
       int isnanf (float x)
       int isnan (double x)
       int isnanl (long double x)
       int isinff (float x)
       int isinf (double x)
       int isinfl (long double x)
       static int isfinitef (float __x)
       static int isfinite (double __x)
       static int isfinitel (long double __x)
       static float copysignf (float __x, float __y)
       static double copysign (double __x, double __y)
       static long double copysignl (long double __x, long double __y)
       int signbitf (float x)
       int signbit (double x)
       int signbitl (long double x)
       float fdimf (float x, float y)
       double fdim (double x, double y)
       long double fdiml (long double x, long double y)
       float fmaf (float x, float y, float z)
       double fma (double x, double y, double z)
       long double fmal (long double x, long double y, long double z)
       float fmaxf (float x, float y)
       double fmax (double x, double y)
       long double fmaxl (long double x, long double y)
       float fminf (float x, float y)
       double fmin (double x, double y)
       long double fminl (long double x, long double y)
       float truncf (float x)
       double trunc (double x)
       long double truncl (long double x)
       float roundf (float x)
       double round (double x)
       long double roundl (long double x)
       long lroundf (float x)
       long lround (double x)
       long lroundl (long double x)
       long lrintf (float x)
       long lrint (double x)
       long lrintl (long double x)

   Non-StandardMathFunctions
       float squaref (float x)
       double square (double x)
       long double squarel (long double x)