--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/genericopenlibs/openenvcore/include/math.dosc Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,3817 @@
+/** @file ../include/math.h
+@internalComponent
+*/
+
+/** @fn nanval(void )
+
+Not a number value.
+@publishedAll
+@released
+*/
+
+/** @fn finite(double x)
+@param x
+
+ The finite finitef and finitel functions return a non-zero value if value is neither
+infinite nor a "not-a-number" (NaN) value, and 0 otherwise.
+
+ - Examples
+ @code
+#include <math.h>
+int main( void )
+{
+ double x;
+ int y;
+ x = 1.34565;
+ y = finite( x );
+ printf( "finite( %f ) = %d
+", x, y );
+ y = finitef( x );
+ printf( "finitef( %f ) = %d
+",x, y );
+ y = finitel( x );
+ printf( "finitel( %f ) = %d
+",x, y );
+}
+
+@endcode
+ Output
+@code
+finite ( 1.34565 ) = 1
+finitef( 1.34565 ) = 1
+finitel( 1.34565 ) =
+@endcode
+
+
+@publishedAll
+@released
+*/
+
+/** @fn finitef(float x)
+@param x
+
+
+
+
+@publishedAll
+@released
+*/
+
+/** @fn acos(double x)
+@param x
+@return The acos, acosf, and acosl functions return the arc cosine in the range [0, pi]
+radians.
+If: | x | \> 1 , acos (x); returns an NaN.
+
+- Detailed description
+
+
+ The acos, acosf, and acosl functions compute the principal value of the arc cosine of x .
+
+- Examples
+@code
+#include <math.h>
+int main( )
+{
+ double x = -1;
+ double y = acos( x );
+ printf( "acos(%f) = %f
+", x, y );
+ y = acosf( x );
+ printf( "acosf(%f) = %f
+", x, y );
+ y = acosl( x );
+ printf( "acosl(%f) = %f
+", x, y );
+}
+
+@endcode
+ Output
+@code
+acos( -1.000000 ) = 3.14159
+acosf(-1.000000 ) = 3.14159
+acosl(-1.000000 ) = 3.14159
+
+@endcode
+@see asin()
+@see atan()
+@see atan2()
+@see cos()
+@see cosh()
+@see math()
+@see sin()
+@see sinh()
+@see tan()
+@see tanh()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn asin(double x)
+@param x
+@return The asin, asinf, and asinl functions return the arc sine in the range
+-words [-pi/2, +pi/2]
+radians.
+If: | x | \> 1 asin (x); returns an NaN.
+
+- Detailed description
+ The asin and asinf functions compute the principal value of the arc sine of x .
+The function asinl is an alias to the function asin. A domain error occurs for arguments not in the range [-1, +1].
+
+- Examples
+@code
+#include <math.h>
+int main( )
+{
+ double x = 0.5;
+ double y = asin( x );
+ printf( "asin(%f) = %f
+", x, y );
+ y = asinf( x );
+ printf( "asinf(%f) = %f
+", x, y );
+ y = asinl( x );
+ printf( "asinl(%f) = %f
+", x, y );
+}
+
+@endcode
+ Output
+@code
+asin( 0.500000 ) = 0.523599
+asinf(0.500000 ) = 0.523599
+asinl(0.500000 ) = 0.523599
+
+@endcode
+@see acos()
+@see atan()
+@see atan2()
+@see cos()
+@see cosh()
+@see math()
+@see sin()
+@see sinh()
+@see tan()
+@see tanh()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn atan(double x)
+@param x
+@see acos()
+@see asin()
+@see atan2()
+@see cos()
+@see cosh()
+@see math()
+@see sin()
+@see sinh()
+@see tan()
+@see tanh()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn atan2(double y, double x)
+@param y
+@param x
+@see acos()
+@see asin()
+@see atan()
+@see cos()
+@see cosh()
+@see math()
+@see sin()
+@see sinh()
+@see tan()
+@see tanh()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn cos(double x)
+@param x
+@see acos()
+@see asin()
+@see atan()
+@see atan2()
+@see cosh()
+@see math()
+@see sin()
+@see sinh()
+@see tan()
+@see tanh()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn sin(double x)
+@param x
+@return The sin and the sinf functions return the sine value.
+
+- Detailed description
+ The sin and the sinf functions compute the sine of x (measured in radians).
+A large magnitude argument may yield a result with little
+or no significance. sinl is just an alias to the function sin
+
+- Examples
+@code
+#include <math.h>
+int main( )
+{
+ double pi_by_6 = 0.52359877559829887307710723054658383 ;
+ double y;
+ y = sin( pi_by_6 );
+ printf( "sin( %f) = %f
+", x1, y );
+ y = sinf( pi_by_6);
+ printf( "sinf( %f) = %f
+", pi_by_6, y );
+ y = sinl( pi_by_6);
+ printf( "sinl( %f) = %f
+", pi_by_6, y );
+ }
+
+@endcode
+ Output
+@code
+sin ( 0.52359877559829887307710723054658383 ) = 0.500000
+sinf( 0.52359877559829887307710723054658383 ) = 0.500000
+sinl( 0.52359877559829887307710723054658383 ) = 0.500000
+
+@endcode
+@see acos()
+@see asin()
+@see atan()
+@see atan2()
+@see cos()
+@see cosh()
+@see math()
+@see sinh()
+@see tan()
+@see tanh()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn tan(double x)
+@param x
+@return The tan function returns the tangent value.
+
+- Detailed description
+ The tan and tanf functions compute the tangent of x (measured in radians).
+A large magnitude argument may yield a result
+with little or no significance.
+The function tanl is an alias to the function tan
+
+- Examples
+@code
+#include <math.h>
+int main( )
+{
+ double pi_by_4 = 0.7853981633974483096156608458198757;
+ double y;
+ y = tan( pi_by_4 );
+ printf( "tan( %f) = %f
+", pi_by_4, y );
+ y = tanf( pi_by_4);
+ printf( "tanf( %f) = %f
+", pi_by_4, y );
+ y = tanl( pi_by_4);
+ printf( "tanl( %f) = %f
+
+", pi_by_4, y );
+}
+
+@endcode
+ Output
+@code
+tan ( 0.7853981633974483096156608458198757 ) = 1.000000
+tanf( 0.7853981633974483096156608458198757 ) = 1.000000
+tanl( 0.7853981633974483096156608458198757; ) =1.000000
+
+@endcode
+@see acos()
+@see asin()
+@see atan()
+@see atan2()
+@see cos()
+@see cosh()
+@see math()
+@see sin()
+@see sinh()
+@see tanh()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn cosh(double x)
+@param x
+@see acos()
+@see asin()
+@see atan()
+@see atan2()
+@see cos()
+@see math()
+@see sin()
+@see sinh()
+@see tan()
+@see tanh()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn sinh(double x)
+@param x
+- Detailed description
+ The sinh and the sinhf functions compute the hyperbolic sine of x .
+The function sinhl is an alias to the function sinh
+
+- Examples
+@code
+#include <math.h>
+int main( )
+{
+ double inp = 0.75;
+ double y;
+ y = sinh( inp );
+ printf( "sinh( %f) = %f
+", inp, y );
+ y = sinhf( inp);
+ printf( "sinhf( %f) = %f
+", inp, y );
+ y = sinhl( inp);
+ printf( "sinhl( %f) = %f
+", inp, y );
+}
+
+@endcode
+ Output
+@code
+sinh ( 0.75 ) = 0.8223167
+sinhf( 0.75 ) = 0.8223167
+sinhl( 0.75 ) = 0.8223167
+
+@endcode
+@see acos()
+@see asin()
+@see atan()
+@see atan2()
+@see cos()
+@see cosh()
+@see math()
+@see sin()
+@see tan()
+@see tanh()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn tanh(double x)
+@param x
+@return The tanh, tanhf and tanhl functions return the hyperbolic tangent value.
+
+- Detailed description
+ The tanh and tanhf functions compute the hyperbolic tangent of x . tanhl is an alias to the function tanh.
+
+- Examples
+@code
+#include <math.h>
+int main( )
+{
+ double inp = 1.0;
+ double y;
+ y = tanh( inp );
+ printf( "tanh( %f) = %f
+", inp, y );
+ y = tanhf( inp);
+ printf( "tanhf( %f) = %f
+", inp, y );
+ y = tanhl( inp);
+ printf( "tanhl( %f) = %f
+
+", inp, y );
+ inp = 2209.0;
+ y = sqrt( inp);
+ printf( "sqrt( %f) = %d
+", inp, y );
+ y = sqrtf( inp);
+ printf( "sqrtf( %f) = %d
+", inp, y );
+ y = sqrtl( inp);
+ printf( "sqrtl( %f) = %d
+", inp, y );
+}
+
+@endcode
+ Output
+@code
+tanh ( 1.000000 ) = 0.7615941
+tanhf( 1.000000 ) = 0.7615941
+tanhl( 1.000000 ) = 0.7615941
+
+@endcode
+@see acos()
+@see asin()
+@see atan()
+@see atan2()
+@see cos()
+@see cosh()
+@see math()
+@see sin()
+@see sinh()
+@see tan()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn exp(double x)
+@param x
+@return These functions will return the appropriate computation unless an error
+occurs or an argument is out of range.
+The functions pow (x, y); and powf (x, y); return an NaN if x \< 0 and y is not an integer.
+An attempt to take the logarithm of ±0 will return infinity.
+An attempt to take the logarithm of a negative number will
+return a NaN.
+
+- Detailed description
+ The exp and expf functions compute the base e exponential value of the given argument x .
+
+ The exp2 and exp2f functions compute the base 2 exponential of the given argument x .
+
+ The expm1 and expm1f functions compute the value exp(x)-1 accurately even for tiny argument x .
+
+ The log and logf functions compute the value of the natural logarithm of argument x .
+
+ The log10 and log10f functions compute the value of the logarithm of argument x to base 10.
+
+ The log1p and log1pf functions compute
+the value of log(1+x) accurately even for tiny argument x .
+
+ The pow and powf functions compute the value
+of x to the exponent y .
+
+ Here the long double version APIs are aliases to the double version APIs.
+All apis \<function\>l behaves similiar to that \<function\>.
+
+- Examples
+@code
+#include <math.h>
+int main( void )
+{
+ double x, y;
+ x = 1.0;
+ y = exp( x );
+ printf( "exp( %f ) = %f
+", x, y );
+ y = expf( x );
+ printf( "expf( %f ) = %f
+",x, y );
+ y = expl( x );
+ printf( "expl( %f ) = %f
+",x, y );
+ x = 0.0;
+ y = exp2( x );
+ printf( "exp2( %f ) = %f
+", x, y );
+ y = exp2f( x );
+ printf( "exp2f( %f ) = %f
+",x, y );
+ y = exp2l( x );
+ printf( "exp2l( %f ) = %f
+",x, y );
+ x = 1.0 ;
+ y = expm1( x );
+ printf( "expm1( %f ) = %f
+", x, y );
+ y = expm1f( x );
+ printf( "expm1f( %f ) = %f
+",x, y );
+ y = expm1l( x );
+ printf( "expm1l( %f ) = %f
+",x, y );
+}
+
+@endcode
+ Output
+@code
+exp ( 1.0 ) = 2.718282
+expf ( 1.0 ) = 2.718282
+expl ( 1.0 ) = 2.718282
+exp2 ( 0.0 ) = 1.000000
+exp2f ( 0.0 ) = 1.000000
+exp2l ( 0.0 ) = 1.000000
+expm1 ( 1.0 ) = 1.718281
+expm1f( 1.0 ) = 1.718281
+expm1l( 1.0 ) = 1.718281
+
+@endcode
+
+Notes:
+
+ The functions exp(x)-1 and log(1+x) are called
+expm1 and logp1 in BASIC on the Hewlett-Packard HP -71B and APPLE Macintosh, EXP1 and LN1 in Pascal, exp1 and log1 in C
+on APPLE Macintoshes, where they have been provided to make
+sure financial calculations of ((1+x)**n-1)/x, namely
+expm1(n*log1p(x))/x, will be accurate when x is tiny.
+They also provide accurate inverse hyperbolic functions. The function pow (x, 0); returns x**0 = 1 for all x including x = 0, oo, and NaN .
+Previous implementations of pow may
+have defined x**0 to be undefined in some or all of these
+cases.
+Here are reasons for returning x**0 = 1 always: Any program that already tests whether x is zero (or
+infinite or NaN) before computing x**0 cannot care
+whether 0**0 = 1 or not.
+Any program that depends
+upon 0**0 to be invalid is dubious anyway since that
+expression's meaning and, if invalid, its consequences
+vary from one computer system to another. Some Algebra texts (e.g. Sigler's) define x**0 = 1 for
+all x, including x = 0.
+This is compatible with the convention that accepts a[0]
+as the value of polynomial
+@code
+p(x) = a[0]*x**0 + a[1]*x**1 + a[2]*x**2 +...+ a[n]*x**n
+
+@endcode
+ at x = 0 rather than reject a[0]*0**0 as invalid. Analysts will accept 0**0 = 1 despite that x**y can
+approach anything or nothing as x and y approach 0
+independently.
+The reason for setting 0**0 = 1 anyway is this:
+@code
+If x(z) and y(z) are
+
+ any
+functions analytic (expandable
+in power series) in z around z = 0, and if there
+x(0) = y(0) = 0, then x(z)**y(z) -> 1 as z -> 0.
+
+@endcode
+ If 0**0 = 1, then
+oo**0 = 1/0**0 = 1 too; and
+then NaN**0 = 1 too because x**0 = 1 for all finite
+and infinite x, i.e., independently of x.
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn frexp(double x, int *eptr)
+@param x
+@param eptr
+@return These functions return the value y ,
+such that y is a double with magnitude in the interval [1/2, 1]
+or zero, and x equals y times 2 raised to the power *eptr .
+If x is zero, both parts of the result are zero.
+
+- Detailed description
+ The frexp , frexpf, and frexpl functions break a floating-point number into a normalized
+fraction and an integral power of 2.
+They store the integer in the int object pointed to by eptr .
+As there is no long double is not supported by Symbian, frexpl (is, aliased, to, the); frexp
+
+
+
+- Examples
+@code
+void main( void )
+{
+ double x1 = 4.0 , y;
+ int res;
+ y = frexp( x1, &res; );
+ printf( "frexp(%f , &res;):: Int Part: %d and Fractional Part: %f
+", x1, res, y );
+ y = frexpf( x1, &res; );
+ printf( "frexpf(%f , &res;):: Int Part: %d and Fractional Part: %f
+", x1, res, y );
+ y = frexpl( x1, &res; );
+ printf( "frexpl(%f , &res;):: Int Part: %d and Fractional Part: %f
+", x1, res, y );
+}
+
+@endcode
+ Output
+@code
+frexp ( 4.0 , &res; ) :: Int Part: 3 and Fractional Part: 0.5
+frexpf( 4.0, &res; ) :: Int Part: 3 and Fractional Part: 0.5
+frexpl( 4.0, &res; ) :: Int Part: 3 and Fractional Part: 0.5
+
+@endcode
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn ldexp(double x, int n)
+@param x
+@param n
+@return These functions return the value of x times 2 raised to the power n .
+
+- Detailed description
+ The ldexp, ldexpf, and ldexpl functions multiply a floating-point number by an integral
+power of 2.
+
+- Examples
+@code
+#include <math.h>
+int main( void )
+{
+ double x1 = 0.8, x2 = 4, y;
+ y = ldexp( x1, x2 );
+ printf( "ldexp(%f , %f) = %f
+", x1, x2, y );
+ y = ldexpf( x1, x2 );
+ printf( "ldexpf(%f , %f) = %f
+", x1, x2, y );
+ y = ldexpl( x1, x2 );
+ printf( "ldexpl(%f , %f) = %f
+", x1, x2, y );
+}
+
+@endcode
+ Output
+@code
+ldexp ( 0.8, 4 ) = 12.8
+ldexpf( 0.8, 4 ) = 12.8
+ldexpl( 0.8, 4 ) = 12.8
+
+@endcode
+@see frexp()
+@see math()
+@see modf()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn log(double x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn log10(double x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn modf(double x, double *iptr)
+@param x
+@param iptr
+@return The modf, modff and modfl functions return the signed fractional part of a value .
+
+- Detailed description
+ 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 function modff (is, the, float, version, of, modf().); The function modfl is an alias to the function modf.
+
+- Examples
+@code
+#include <math.h>
+#include <stdio.h>
+int main()
+{
+ double x1 = 123.456703 , y;
+ double iptr;
+ float fptr;
+ y = modf( x1, &iptr; );
+ printf( "modf(%f , &iptr;):: Int Part: %f and Fractional Part: %f 0, x1, iptr, y );
+ y = modff( x1, &fptr; );
+ printf( "modff(%f , &iptr;):: Int Part: %f and Fractional Part: %f 0, x1, fptr, y );
+ y = modfl( x1, &iptr; );
+ printf( "modfl(%f , &iptr;):: Int Part: %f and Fractional Part: %f 0, x1, iptr, y );
+}
+
+@endcode
+ Output
+@code
+modf ( 123.456703 , &iptr; ) :: Int Part: 123 and Fractional Part: 0.456703
+modff( 123.456703, &iptr; ) :: Int Part: 123 and Fractional Part: 0.456703
+modfl( 123.456703, &iptr; ) :: Int Part: 123 and Fractional Part: 0.456703
+
+@endcode
+@see frexp()
+@see ldexp()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn pow(double x, double y)
+@param x
+@param y
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn sqrt(double x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn ceil(double x)
+@param x
+@return x is integral or infinite, x itself is returned.
+
+
+The ceil , ceilf, and ceill functions return the smallest integral value
+greater than or equal to x ,
+expressed as a floating-point number.
+
+- Examples
+@code
+#include <math.h>
+int main( void )
+{
+ double y;
+ y = ceil( 2.8 );
+ printf( "The ceil of 2.8 is %f
+", y );
+ y = ceil( -2.8 );
+ printf( "The ceil of -2.8 is %f
+", y );
+ y = ceilf( 2.8 );
+ printf( "The ceilf of 2.8 is %f
+", y );
+ y = ceilf( -2.8 );
+ printf( "The ceilf of -2.8 is %f
+", y );
+ y = ceill( 2.8 );
+ printf( "The ceill of 2.8 is %f
+", y );
+ y = ceill( -2.8 );
+ printf( "The ceill of -2.8 is %f
+", y );
+}
+
+@endcode
+ Output
+@code
+The ceil of 2.8 is 3.000000
+The ceil of -2.8 is -2.000000
+The ceilf of 2.8 is 3.000000
+The ceilf of -2.8 is -2.000000
+The ceill of 2.8 is 3.000000
+The ceill of -2.8 is -2.000000
+
+@endcode
+@see abs()
+@see fabs()
+@see floor()
+@see ieee()
+@see math()
+@see rint()
+@see round()
+@see trunc()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn ceilf(float x)
+@param x
+@see abs()
+@see fabs()
+@see floor()
+@see ieee()
+@see math()
+@see rint()
+@see round()
+@see trunc()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn fabs(double x)
+@param x
+@return The fabs , fabsf and fabsl functions return the absolute value of x .
+
+The fabs , fabsf and fabsl functions compute the absolute value of a floating-point number x .
+
+Examples
+@code
+#include <stdio.h>
+#include <math.h>
+int main( void )
+{
+ double dx = -3.141593, dy;
+ dy = fabs( dx );
+ printf( "fabs( %f ) = %f
+", dx, dy );
+ dy = fabsf( dx );
+ printf( "fabsf( %f ) = %f
+", dx, dy );
+ dy = fabsl( dx );
+ printf( "fabsl( %f ) = %f
+", dx, dy );
+}
+
+@endcode
+ Output
+@code
+fabs( -3.141593 ) = 3.141593
+fabsf( -3.141593 ) = 3.141593
+fabsl( -3.141593 ) = 3.141593
+
+@endcode
+@see abs()
+@see ceil()
+@see floor()
+@see ieee()
+@see math()
+@see rint()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn fabsf(float x)
+@param x
+@see abs()
+@see ceil()
+@see floor()
+@see ieee()
+@see math()
+@see rint()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn fabsl(long double x)
+@param x
+@see abs()
+@see ceil()
+@see floor()
+@see ieee()
+@see math()
+@see rint()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn floor(double x)
+@param x
+@return x is integral or infinite, x itself is returned.
+
+
+The floor , floorf, and floorl functions return the largest integral value
+less than or equal to x ,
+expressed as a floating-point number.
+
+- Examples
+@code
+#include <math.h>
+int main( void )
+{
+ double y;
+ y = floor( 2.8 );
+ printf( "The floor of 2.8 is %f
+", y );
+ y = floorf( 2.8 );
+ printf( "The floorf of 2.8 is %f
+", y );
+ y = floorl( 2.8 );
+ printf( "The floorl of 2.8 is %f
+", y );
+}
+
+@endcode
+ Output
+@code
+The floor of 2.8 is 2.000000
+The floorf of 2.8 is 2.000000
+The floorl of 2.8 is 2.000000
+
+@endcode
+@see abs()
+@see ceil()
+@see fabs()
+@see ieee()
+@see math()
+@see rint()
+@see round()
+@see trunc()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn floorf(float x)
+@param x
+@see abs()
+@see ceil()
+@see fabs()
+@see ieee()
+@see math()
+@see rint()
+@see round()
+@see trunc()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn fmod(double x, double y)
+@param x
+@param y
+@return The fmod, fmodf, and fmodl functions return the value x - i * y , for some integer i such that, if y is non-zero, the result has the same sign as x and magnitude less than the magnitude of y .
+If y is zero, whether a domain error occurs or the fmod and fmodf function returns zero is implementation-defined.
+
+
+The fmod, fmodf, and fmodl functions compute the floating-point remainder of x / y . fmodl is an alias to the function fmod.
+
+Examples
+@code
+#include <math.h>
+int main()
+{
+ double x1 = 6.5, x2 = 2.25, y;
+ y = fmod( x1, x2 );
+ printf( "fmod(%f , %f) = %f
+", x1, x2, y );
+ y = fmodf( x1, x2 );
+ printf( "fmodf(%f , %f) = %f
+", x1, x2, y );
+ y = fmodl( x1, x2 );
+ printf( "fmodl(%f , %f) = %f
+", x1, x2, y );
+}
+
+@endcode
+ Output
+@code
+fmod ( 6.4, 2 ) = 2.0
+fmodf( 6.4, 2 ) = 2.0
+fmodl( 6.4, 2 ) = 2.0
+
+@endcode
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn fmodf(float x, float y)
+@param x
+@param y
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn acosh(double x)
+@param x
+@return The acosh , acoshf ,
+and acoshl functions
+return the inverse hyperbolic cosine of x .
+If the argument is less than 1, acosh returns an NaN.
+
+
+The acosh and acoshf functions compute the inverse hyperbolic cosine
+of the real
+argument x .
+The function acoshl is an alias to the function acosh .
+
+- Examples
+@code
+#include <math.h>
+int main( )
+{
+ double x = 1;
+ double y = acosh( x );
+ printf( "acosh(%f) = %f
+", x, y );
+ y = acoshf( x );
+ printf( "acoshf(%f) = %f
+", x, y );
+ y = acoshl( x );
+ printf( "acoshl(%f) = %f
+", x, y );
+}
+
+@endcode
+ Output
+@code
+acosh( 1.000000 ) = 0.0
+acoshf(1.000000 ) = 0.0
+acoshl(1.000000 ) = 0.0
+
+@endcode
+@see asinh()
+@see atanh()
+@see exp()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn acoshf(float x)
+@param x
+@see asinh()
+@see atanh()
+@see exp()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn asinh(double x)
+@param x
+@see acosh()
+@see atanh()
+@see exp()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn asinhf(float x)
+@param x
+@see acosh()
+@see atanh()
+@see exp()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn atanh(double x)
+@param x
+@see acosh()
+@see asinh()
+@see exp()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn atanhf(float x)
+@param x
+@see acosh()
+@see asinh()
+@see exp()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn cbrt(double x)
+@param x
+@return The cbrt and cbrtf functions return the requested cube root.
+The sqrt and sqrtf functions return the requested square root
+unless an error occurs.
+An attempt to take the sqrt of negative x causes an NaN to be returned.
+
+
+The cbrt and cbrtf functions compute
+the cube root of x .
+The function cbrtl is an alias to the function cbrt.
+
+ The sqrt and sqrtf functions compute the
+non-negative square root of x.
+The function sqrtl is an alias to the function sqrt.
+
+- Examples
+@code
+#include <math.h>
+int main( )
+{
+ double inp = -0.001;
+ double y;
+ y = cbrt( inp );
+ printf( "cbrt( %f) = %f
+", x1, y );
+ y = cbrtf( inp);
+ printf( "cbrtf( %f) = %f
+", inp, y );
+ y = cbrtl( inp);
+ printf( "cbrtl( %f) = %f
+
+", inp, y );
+ inp = 2209.0;
+ y = sqrt( inp);
+ printf( "sqrt( %f) = %d
+", inp, y );
+ y = sqrtf( inp);
+ printf( "sqrtf( %f) = %d
+", inp, y );
+ y = sqrtl( inp);
+ printf( "sqrtl( %f) = %d
+", inp, y );
+}
+
+@endcode
+ Output
+@code
+cbrt ( -0.001 ) = -0.100000
+cbrtf( -0.001 ) = -0.100000
+cbrtl( -0.001 ) = -0.100000
+sqrt ( 2209.0 ) = 47.0
+sqrtf( 2209.0 ) = 47.0
+sqrtl( 2209.0 ) = 47.0
+
+@endcode
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn erf(double x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn erfc(double x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn erff(float x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn erfcf(float x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn exp2(double x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn exp2f(float x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn expm1(double)
+
+The expm1 and expm1f functions compute the value exp(x)-1 accurately even for tiny argument x .
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn expm1f(float x)
+
+The expm1 and expm1f functions compute the value exp(x)-1 accurately even for tiny argument x .
+
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn fma(double x, double y, double z)
+@param x
+@param y
+@param z
+
+@code
+
+The fma, fmaf, and fmal functions return (x * y) + z, computed with only one rounding error. Using the ordinary multiplication and addition operators, by contrast, results in two roundings: one for the intermediate product and one for the final result.
+For instance, the expression 1.2e100 * 2.0e208 - 1.4e308 produces oo due to overflow in the intermediate product, whereas fma(1.2e100, 2.0e208, -1.4e308) returns approximately 1.0e308.
+
+The fused multiply-add operation is often used to improve the accuracy of calculations such as dot products. It may also be used to improve performance on machines that implement it natively. The macros FP_FAST_FMA, FP_FAST_FMAF and FP_FAST_FMAL may be defined in #include \<math.h\>to indicate that fma, fmaf, and fmal (respectively) have comparable or faster speed than a multiply operation followed by an add operation.
+@endcode
+
+
+
+- Examples
+@code
+#include <math.h>
+int main()
+{
+ double x1 = 1, x2 = 2, x3 =3, y;
+ y = fma( x1, x2, x3 );
+ printf( "fma(%f , %f , %f) = %f
+", x1, x2, x3, y );
+ y = fmaf( x1, x2, x3 );
+ printf( "fmaf(%f , %f , %f) = %f
+", x1, x2, x3, y );
+ y = fmal( x1, x2, x3 );
+ printf( "fmal(%f , %f , %f) = %f
+", x1, x2, x3, y );
+}
+
+@endcode
+ Output
+@code
+fma ( 1, 2, 3 ) = 5
+fmaf( 1, 2, 3 ) = 5
+fmal( 1, 2, 3 ) = 5
+
+@endcode
+ Implementation notes In general, these routines will behave as one would expect if x * y + z
+were computed with unbounded precision and range,
+then rounded to the precision of the return type.
+However, on some platforms,
+
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn fmaf(float x, float y, float z)
+@param x
+@param y
+@param z
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn fmax(double x, double y)
+@param x
+@param y
+
+The fmax, fmaxf, and fmaxl functions return the larger of x and y ,
+and likewise, the fmin, fminf, and fminl functions return the smaller of x and y .
+They treat +0.0
+as being larger than -0.0.
+If one argument is an NaN(Not a Number), then the other argument is returned.
+If both arguments are NaN(Not a Number)s, then the result is an NaN(Not a Number).
+
+- Examples
+@code
+#include <math.h>
+int main( void )
+{
+ double y;
+ y = fmax( 0, -9 );
+ printf( "fmax ( 0, -9) = %f
+", y );
+ y = fmaxf( 0, -9 );
+ printf( "fmaxf( 0, -9) = %f
+", y );
+ y = fmaxl( 0, -9 );
+ printf( "fmaxl( 0, -9) = %f
+", y );
+ y = fmin( 0, -9 );
+ printf( "fmin ( 0, -9) = %f
+", y );
+ y = fminf( 0, -9 );
+ printf( "fminf ( 0, -9) = %f
+", y );
+ y = fminl( 0, -9 );
+ printf( "fminl ( 0, -9) = %f
+", y );
+}
+
+@endcode
+ Output
+@code
+fmax( 0, -9 ) = 0
+fmaxf( 0, -9 ) = 0
+fmaxl( 0, -9 ) = 0
+fmin( 0, -9 ) = -9
+fminf( 0, -9 ) = -9
+fminl( 0, -9 ) = -9
+
+@endcode
+@see fabs()
+@see fdim()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn fmaxf(float x, float y)
+@param x
+@param y
+@see fabs()
+@see fdim()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn fmaxl(long double x, long double y)
+@param x
+@param y
+@see fabs()
+@see fdim()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn hypot(double x, double y)
+@param x
+@param y
+
+@code
+ The hypot and hypotf functions
+compute the
+sqrt(x*x+y*y)
+in such a way that underflow will not happen, and overflow
+occurs only if the final result deserves it.
+@endcode
+
+Examples
+@code
+void main( void )
+{
+ double x1 = 3.0 , x2 = 4.0, y;
+ y = hypot( x1, x2 );
+ printf( "atan2(%f , %f) = %f
+", x1, x2, y );
+ y = hypotf( x1, x2 );
+ printf( "atan2f(%f , %f) = %f
+", x1, x2, y );
+ y = hypotl( x1, x2 );
+ printf( "hypotl(%f , %f) = %f
+", x1, x2, y );
+}
+
+@endcode
+ Output
+@code
+hypot ( 3.0, 4.0 ) = 5.000000
+hypotf( 3.0, 4.0 ) = 5.000000
+hypotl( 3.0, 4.0 ) = 5.000000
+
+@endcode
+
+Notes:
+
+As might be expected, hypot (v, NaN);
+and hypot (NaN, v);
+are NaN for all finite v. But programmers might be surprised at first to discover that hypot (±oo, NaN);
+= +oo. This is intentional; it happens because hypot (oo, v);
+= +oo for all v, finite or infinite. Hence hypot (oo, v);
+is independent of v. Unlike the reserved operand fault on a VAX, the IEEE NaN is designed to disappear when it turns out to be irrelevant, as it does in hypot (oo, NaN);
+hypot.
+
+hypot (oo, v);
+= hypot (v, oo);
+= +oo for all v, including NaN.
+
+@see math()
+@see sqrt()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn hypotf(float x, float y)
+@param x
+@param y
+@see math()
+@see sqrt()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn ilogb(double x)
+@param x
+
+The functions ilogb, ilogbf, and ilogbl return x ’s exponent, in integer format. ilogb (±oo);
+@code
+returns INT_MAX, ilogb (±NaN);
+returns FP_ILOGBNAN and ilogb (0);
+returns FP_ILOGB0.
+@endcode
+
+Examples
+@code
+#include <math.h>
+int main( )
+{
+ double e = 1024;
+ /*iLogb(), ilogbf() and ilogbl() */
+ y = ilogb( e );
+ printf( "ilogb( %f) = %f
+", e, y );
+ y = ilogbf( e );
+ printf( "ilogbf( %f) = %f
+", e, y );
+ y = ilogbl( e );
+ printf( "ilogbl( %f) = %f
+
+", e, y );
+}
+
+@endcode
+ Output
+@code
+ilogb (1024) = 10.000000
+ilogbf(1024) = 10.000000
+ilogbl(1024) = 10.000000
+
+@endcode
+@see frexp()
+@see ieee()
+@see math()
+@see scalbn()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn ilogbf(float x)
+@param x
+@see frexp()
+@see ieee()
+@see math()
+@see scalbn()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn ilogbl(long double x)
+@param x
+@see frexp()
+@see ieee()
+@see math()
+@see scalbn()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn lgamma(double x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn lgamma_r(double x, int *signgamp)
+@param x
+@param signgamp
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn lgammaf(float x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn lgammaf_r(float x, int *signgamp)
+@param x
+@param signgamp
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn llrint(double x)
+@param x
+@return
+
+- Detailed description
+ The lrint function returns the integer nearest to its argument x according to the current rounding mode.
+When the rounded result is representable as a long ,
+the expression
+
+ The llrint , llrintf and lrintf functions differ from lrint only in their input and output types. lrintf and llrintl is just an aliases to the functions lrint (and); llrint respectively
+
+- Examples
+@code
+#include <math.h>
+int main( void )
+{
+ double x1 = 1.4;
+ long long y;
+ int res ;
+ y = llrint( x1 );
+ printf( "llrint(%f) = %d
+", x1, y );
+ y = llrintf( x1 );
+ printf( "llrintf(%f) = %d
+", x1, y );
+ y = llrintl( x1 );
+ printf( "llrintl(%f) = %d
+", x1, y );
+ res = lrint( x1 );
+ printf( "lrint(%f) = %d
+", x1, res );
+ res = lrintf( x1 );
+ printf( "lrintf(%f) = %d
+", x1, res );
+ res = lrintl( x1 );
+ printf( "lrintl(%f) = %d
+", x1, res );
+}
+
+@endcode
+ Output
+@code
+llrint ( 1.4 ) = 1.000000
+llrintf( 1.4 ) = 1.000000
+llrintl( 1.4 ) = 1.000000
+lrint ( 1.4 ) = 1.000000
+lrintf( 1.4 ) = 1.000000
+lrintl( 0.0 ) = 1.000000
+
+@endcode
+@see lround()
+@see math()
+@see rint()
+@see round()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn llrintf(float x)
+@param x
+@see lround()
+@see math()
+@see rint()
+@see round()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn llround(double x)
+@param x
+
+
+The lround function returns the integer nearest to its argument x ,
+rounding away from zero in halfway cases.
+If the rounded result is too large to be represented as a long
+value, the return value is undefined.
+When the rounded result is representable as a long ,
+the expression lround (x); is equivalent to round (x);( long) (although the former may be more efficient).
+
+ The llround , llroundf , llroundl , lroundf and lroundl functions differ from lround only in their input and output types.
+
+Examples
+@code
+#include <math.h>
+int main( void )
+{
+ double x1 = 1.5;
+ long long y;
+ int res ;
+ y = llround( x1 );
+ printf( "llround(%f) = %d
+", x1, y );
+ y = llroundf( x1 );
+ printf( "llroundf(%f) = %d
+", x1, y );
+ y = llroundl( x1 );
+ printf( "llroundl(%f) = %d
+
+", x1, y );
+ res = lround( x1 );
+ printf( "lround(%f) = %d
+", x1, res );
+ res = lroundf( x1 );
+ printf( "lroundf(%f) = %d
+", x1, res );
+ res = lroundl( x1 );
+ printf( "lroundl(%f) = %d
+", x1, res );
+}
+
+@endcode
+ Output
+@code
+llround ( 1.5 ) = 2.000000
+llroundf( 1.5 ) = 2.000000
+llroundl( 1.5 ) = 2.000000
+lround ( 1.5 ) = 2.000000
+lroundf( 1.5 ) = 2.000000
+lroundl( 1.5 ) = 2.000000
+
+@endcode
+@see lrint()
+@see math()
+@see rint()
+@see round()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn llroundf(float x)
+@param x
+@see lrint()
+@see math()
+@see rint()
+@see round()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn log1p(double x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn log1pf(float x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn logb(double x)
+@param x
+- Detailed description
+
+ These functions allow users to test conformance to -ieee754 .
+Their use is not otherwise recommended.
+@code
+ logb (x); and logbf (x); return x 's exponent n ,
+a signed integer converted to double-precision floating-point. logb (±oo); = +oo; logb (0); = -oo
+
+ scalb (x, n); and scalbf (x, n); return x *(2** n )
+computed by exponent manipulation.
+
+ significand (x); and significandf (x); return sig ,
+where x = sig * 2** n with 1 <= sig <2. significand (x); and significandf (x); are not defined when x is 0, ±oo, or NaN.
+Here , long double version function are just aliases to
+their corresponding double version apis.
+@endcode
+
+- Examples
+@code
+#include <math.h>
+int main( )
+{
+ double e = 2.718282;
+ /*Logb(), logbf() and logbl() */
+ y = logb( e );
+ printf( "logb( %f) = %f
+", e, y );
+ y = logbf( e );
+ printf( "logbf( %f) = %f
+", e, y );
+ y = logbl( e );
+ printf( "logbl( %f) = %f
+
+", e, y );
+ /*scalb(), scalbf() and scalbl()*/
+ double x1 = 0.8, x2 = 4.0 ;
+ y = scalb( x1, x2 );
+ printf( "scalb( %f, %f) = %f
+", x1, x2, y );
+ y = scalbf( x1, x2 );
+ printf( "scalbf( %f, %f) = %f
+", x1, x2, y );
+ y = scalbl( x1, x2 );
+ printf( "scalbl( %f, %f) = %f
+", x1, x2, y );
+ /*significand(), significandf() and significandl()*/
+ x2 = 4.0 ;
+ y = significand( x2 );
+ printf( "significand(%f) = %f
+", x2, y );
+ y = significandf( x2 );
+ printf( "significandf(%f) = %f
+",x2, y );
+ y = significandl( x2 );
+ printf( "significandl(%f) = %f
+",x2, y );
+}
+
+@endcode
+ Output
+@code
+logb( 2.718282) = 1.000000
+logbf( 2.718282) = 1.000000
+logbl( 2.718282) = 1.000000
+scalb( 0.8, 4.0 ) = 12.800000
+scalbf( 0.8, 4.0 ) = 12.800000
+scalbl( 0.8, 4.0 ) = 12.800000
+significand ( 4.0) = 1.000000
+significandf( 4.0) = 1.000000
+significandl( 4.0) = 1.000000
+
+@endcode
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn logbf(float x)
+@param x
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn lrint(double x)
+@param x
+@see lround()
+@see math()
+@see rint()
+@see round()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn lrintf(float x)
+@param x
+@see lround()
+@see math()
+@see rint()
+@see round()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn lround(double x)
+@param x
+@see lrint()
+@see math()
+@see rint()
+@see round()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn lroundf(float x)
+@param x
+@see lrint()
+@see math()
+@see rint()
+@see round()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn nextafter(double x, double y)
+@param x
+@param y
+- Detailed description
+ These functions
+return the next machine representable number from x in direction y .
+
+- Examples
+@code
+#include <math.h>
+int main( )
+{
+ double inp1 = 1.3;
+ double inp2 = 2;
+ double y;
+ y = nextafter( inp1, inp2 );
+ printf( "nextafter(%f , %f) = %f
+", inp1, inp2, y );
+ y = nextafterf( inp1, inp2 );
+ printf( "nextafterf(%f , %f) = %f
+", inp1, inp2, y );
+ y = nextafterl( inp1, inp2 );
+ printf( "nextafterl(%f , %f) = %f
+
+", inp1, inp2, y );
+ inp1 = 9;
+ inp2 = 9;
+ y = nexttoward( inp1, inp2 );
+ printf( "nexttoward(%f , %f) = %f
+", inp1, inp2, y );
+ y = nexttowardf( inp1, inp2 );
+ printf( "nexttowardf(%f , %f) = %f
+", inp1, inp2, y );
+ y = nexttowardl( inp1, inp2 );
+ printf( "nexttowardl(%f , %f) = %f
+", inp1, inp2, y );
+}
+
+@endcode
+ Output
+@code
+nextafter ( 1.3, 2.0 ) = 1.3
+nextafterf ( 1.3, 2.0 ) = 1.3
+nextafterl ( 1.3, 2.0 ) = 1.3
+nexttoward ( 9, 9 ) = 9
+nexttowardf ( 9, 9 ) = 9
+nexttowardl ( 9, 9 ) = 9
+
+@endcode
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn nextafterf(float x, float y)
+@param x
+@param y
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn remainder(double x, double p)
+@param x
+@param p
+@see fmod()
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn remainderf(float x, float p)
+@param x
+@param p
+@see fmod()
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn remquo(double x, double y, int *quo)
+@param x
+@param y
+@param quo
+@see fmod()
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn remquof(float x, float y, int *quo)
+@param x
+@param y
+@param quo
+@see fmod()
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn rint(double x)
+@param x
+@see abs()
+@see ceil()
+@see fabs()
+@see floor()
+@see ieee()
+@see lrint()
+@see lround()
+@see math()
+@see round()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn rintf(float x)
+@param x
+@see abs()
+@see ceil()
+@see fabs()
+@see floor()
+@see ieee()
+@see lrint()
+@see lround()
+@see math()
+@see round()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn j0(double x)
+@param x
+@return If these functions are successful,
+the computed value is returned.
+
+- Detailed description
+ The functions j0 , j0f , j1 and j1f compute the Bessel function of the first kind of the order 0 and the order 1, respectively,
+for the
+real value x ;
+the functions jn and jnf compute the Bessel function of the first kind of the integer order n for the real value x .
+
+ The functions y0 , y0f , y1 ,
+and y1f compute the linearly independent Bessel function of the second kind of the order 0 and the order 1, respectively,
+for the
+positive real value x ;
+the functions yn and ynf compute the Bessel function of the second kind for the integer order n for the positive real value x .
+
+ Here the long double version APIs are aliases the double version APIs.
+All APIs \<Function\>l behaves similiar to that of \<Function\>.
+
+- Examples
+@code
+#include <math.h>
+int main( )
+{
+ double x = 1.0;
+ /*J0(), j0f() and j0l() */
+ double y = j0( x );
+ printf( "j0( %f) = %f
+", x, y );
+ y = j0f( x );
+ printf( "j0f( %f) = %f
+", x, y );
+ y = j0l( x );
+ printf( "j0l( %f) = %f
+
+", x, y );
+ /*J1(), j1f() and j1l() */
+ y = j1( x );
+ printf( "j1( %f) = %f
+", x, y );
+ y = j1f( x );
+ printf( "j1f( %f) = %f
+", x, y );
+ y = j1l( x );
+ printf( "j1l( %f) = %f
+
+", x, y );
+ /*jn(), jnf() and jnl() */
+ y = jn( 3, x );
+ printf( "jn( 2, %f) = %f
+", x, y );
+ y = jnf( 1, x );
+ printf( "jnf( 1, %f) = %f
+", x, y );
+ y = jnl( 10, 0.75 );
+ printf( "jnl(10, %f) = %f
+
+", 0.75, y );
+ /*y0(), y0f() and y0l() */
+ y = y0( x );
+ printf( "y0( %f) = %f
+", x, y );
+ y = y0f( x );
+ printf( "y0f( %f) = %f
+", x, y );
+ y = y0l( x );
+ printf( "y0l( %f) = %f
+
+", x, y );
+ /*y1(), y1f() and y1l() */
+ y = y1( x );
+ printf( "y1( %f) = %f
+", x, y );
+ y = y1f( x );
+ printf( "y1f( %f) = %f
+", x, y );
+ y = y1l( x );
+ printf( "y1l( %f) = %f
+
+", x, y );
+ /*yn(), ynf() and ynl() */
+ y = yn( 3, x );
+ printf( "yn( 2, %f) = %f
+", x, y );
+ y = ynf( 1, x );
+ printf( "ynf( 1, %f) = %f
+", x, y );
+ y = ynl( 10, 0.75 );
+ printf( "ynl(10, %f) = %f
+
+", 0.75, y );
+}
+
+@endcode
+ Output
+@code
+j0( 1.000) = 0.76519768
+j0f( 1.000) = 0.76519768
+j0l( 1.000) = 0.76519768
+j1 ( 1.000) = 0.4400505
+j1f( 1.000) = 0.4400505
+j1l( 1.000) = 0.4400505
+jn ( 3, 1.000) = 0.0195633
+jnf( 1, 1.000) = 0.4400505
+jnl( 10, 0.75) = 0.1496212
+y0 ( 1.000) = 0.0882569
+y0f( 1.000) = 0.0882569
+y0l( 1.000) = 0.0882569
+y1 ( 1.000) = -0.7812128
+y1f( 1.000) = -0.7812128
+y1l( 1.000) = -0.7812128
+yn ( 3, 1.000) = -5.8215176
+ynf( 1, 1.000) = -0.781212
+ynl( 10, 0.75) = -2133501638.9
+
+@endcode
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn j0f(float x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn j1(double x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn j1f(float x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn jn(int n, double x)
+@param n
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn jnf(int n, float x)
+@param n
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn scalb(double x, double fn)
+@param x
+@param fn
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn scalbf(float x, float fn)
+@param x
+@param fn
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn scalbln(double x, long n)
+@param x
+@param n
+@return x (*, FLT_RADIX**n); ±HUGE_VAL, (±HUGE_VALF,, and, ±HUGE_VALL); (according to the sign of x ) as appropriate for the return type of the function. x is NaN , a shall be returned. x is ±0 or ±Inf, x shall be returned. n is 0, x shall be returned.
+
+- Detailed description
+ These routines return x *(2** n )
+computed by exponent manipulation.
+
+- Examples
+@code
+#include <math.h>
+int main( )
+{
+ /*scalbn(), scalbnf() and scalbnl()*/
+ double x1 = 0.8, x2 = 4.0 ;
+ y = scalbn( x1, x2 );
+ printf( "scalbn( %f, %f) = %f
+", x1, x2, y );
+ y = scalbnf( x1, x2 );
+ printf( "scalbnf( %f, %f) = %f
+", x1, x2, y );
+ y = scalbnl( x1, x2 );
+ printf( "scalbnl( %f, %f) = %f
+", x1, x2, y );
+ /*scalbln(), scalblnf() and scalblnl()*/
+ x1 = 0.8, x2 = 4.0 ;
+ y = scalbln( x1, x2 );
+ printf( "scalbln( %f, %f) = %f
+", x1, x2, y );
+ y = scalblnf( x1, x2 );
+ printf( "scalblnf( %f, %f) = %f
+", x1, x2, y );
+ y = scalblnl( x1, x2 );
+ printf( "scalblnl( %f, %f) = %f
+", x1, x2, y );
+}
+
+@endcode
+ Output
+@code
+scalbn ( 0.8, 4.0 ) = 12.800000
+scalbnf( 0.8, 4.0 ) = 12.800000
+scalbnl( 0.8, 4.0 ) = 12.800000
+scalbln ( 0.8, 4.0 ) = 12.800000
+scalblnf( 0.8, 4.0 ) = 12.800000
+scalblnl( 0.8, 4.0 ) = 12.800000
+
+@endcode
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn scalblnf(float x, long n)
+@param x
+@param n
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn scalblnl(long double x, long n)
+@param x
+@param n
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn scalbn(double x, int n)
+@param x
+@param n
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn scalbnf(float x, int n)
+@param x
+@param n
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn y0(double x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn y0f(float x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn y1(double x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn y1f(float x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn yn(int n, double x)
+@param n
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn ynf(int n, float x)
+@param n
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn gamma(double x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn gammaf(float x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn copysign(double x, double y)
+@param x
+@param y
+- Detailed description
+ The copysign , copysignf, and copysignl functions
+return x with its sign changed to y 's .
+
+- Examples
+@code
+#include <math.h>
+void main( void )
+{
+ double x1 = 0, x2 = -4, y;
+ y = copysign( x1, x2 );
+ printf( "copysign(%f , %f) = %f
+", x1, x2, y );
+ y = copysignf( x1, x2 );
+ printf( "copysignf(%f , %f) = %f
+", x1, x2, y );
+ y = copysignl( x1, x2 );
+ printf( "copysignl(%f , %f) = %f
+", x1, x2, y );
+}
+
+@endcode
+ Output
+@code
+copysign ( 0, -4 ) = -0.0
+copysignf( 0, -4 ) = -0.0
+copysignl( 0, -4 ) = -0.0
+
+@endcode
+@see fabs()
+@see fdim()
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn copysignf(float x, float y)
+@param x
+@param y
+@see fabs()
+@see fdim()
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn copysignl(long double x, long double y)
+@param x
+@param y
+@see fabs()
+@see fdim()
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn fdim(double x, double y)
+@param x
+@param y
+- Detailed description
+ The fdim, fdimf, and fdiml functions return the positive difference between x and y .
+That is, if x- y is positive, then x- y is returned.
+If either x or y is an NaN, then an NaN is returned.
+Otherwise, the result is +0.0.
+
+- Examples
+@code
+#include <math.h>
+int main( void )
+{
+ double x1 = 0, x2 = -9, y;
+ y = fdim( x1, x2 );
+ printf( "fdim(%f , %f) = %f
+", x1, x2, y );
+ y = fdimf( x1, x2 );
+ printf( "fdimf(%f , %f) = %f
+", x1, x2, y );
+ y = fdiml( x1, x2 );
+ printf( "fdiml(%f , %f) = %f
+", x1, x2, y );
+}
+
+@endcode
+ Output
+@code
+fdim ( 0, -9 ) = 9
+fdimf( 0, -9 ) = 9
+fdiml( 0, -9 ) = 9
+
+@endcode
+@see fabs()
+@see fmax()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn fdimf(float x, float y)
+@param x
+@param y
+@see fabs()
+@see fmax()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn fdiml(long double x, long double y)
+@param x
+@param y
+@see fabs()
+@see fmax()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn fmin(double x, double y)
+@param x
+@param y
+@see fabs()
+@see fdim()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn fminf(float x, float y)
+@param x
+@param y
+@see fabs()
+@see fdim()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn nearbyint(double x)
+@param x
+@return x is integral or infinite, x itself is returned.
+
+- Detailed description
+ The rint and rintf functions return the integral value nearest to x according to the prevailing rounding mode.
+
+ The nearbyint and nearbyintf functions perform the same operation.
+The functions nearbyintl and rintl are aliases to the functions nearbyint and rint respectively.
+
+- Examples
+@code
+#include <math.h>
+int main( )
+{
+ double inp = 1.5;
+ double y;
+ y = nearbyint( inp );
+ printf( "nearbyint(%f ) = %f
+", inp, y );
+ y = nearbyintf( inp );
+ printf( "nearbyintf(%f ) = %f
+", inp, y );
+ y = nearbyintl( inp );
+ printf( "nearbyintl(%f ) = %f
+
+", inp, y );
+ y = rint( inp );
+ printf( "rint(%f ) = %f
+", inp, y );
+ y = rintf( inp );
+ printf( "rintf(%f ) = %f
+", inp, y );
+ y = rintl( inp );
+ printf( "rintl(%f ) = %f
+
+", inp, y );
+}
+
+@endcode
+ Output
+@code
+nearbyint ( 1.5 ) = 2.000000
+nearbyintf ( 1.5 ) = 2.000000
+nearbyintl ( 1.5 ) = 2.000000
+rint ( 1.5 ) = 2.000000
+rintf( 1.5 ) = 2.000000
+rintl( 1.5 ) = 2.000000
+
+@endcode
+@see abs()
+@see ceil()
+@see fabs()
+@see floor()
+@see ieee()
+@see lrint()
+@see lround()
+@see math()
+@see round()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn nearbyintf(float x)
+@param x
+@see abs()
+@see ceil()
+@see fabs()
+@see floor()
+@see ieee()
+@see lrint()
+@see lround()
+@see math()
+@see round()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn round(double x)
+@param x
+@return x is integral or infinite, x itself is returned.
+
+- Detailed description
+ The round , roundf ,
+and roundl functions return the nearest integral value to x ;
+if x lies halfway between two integral values, then these
+functions return the integral value with the larger
+absolute value (i.e., they round away from zero).
+
+- Examples
+@code
+#include <math.h>
+int main( )
+{
+ double inp = 0.5;
+ double y;
+ y = round( inp );
+ printf( "round(%f ) = %f
+", inp, y );
+ y = roundf( inp );
+ printf( "roundf(%f ) = %f
+", inp, y );
+ y = roundl( inp );
+ printf( "roundl(%f ) = %f
+
+", inp, y );
+}
+
+@endcode
+ Output
+@code
+round ( 0.5 ) = 1.000000
+roundf ( 0.5 ) = 1.000000
+roundl ( 0.5 ) = 1.000000
+
+@endcode
+@see ceil()
+@see floor()
+@see ieee()
+@see lrint()
+@see lround()
+@see math()
+@see rint()
+@see trunc()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn roundf(float x)
+@param x
+@see ceil()
+@see floor()
+@see ieee()
+@see lrint()
+@see lround()
+@see math()
+@see rint()
+@see trunc()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn trunc(double x)
+@param x
+@return x is integral, infinite or NaN , x itself is returned.
+
+- Detailed description
+ The trunc , truncf ,
+and truncl functions return the nearest integral value with magnitude less than
+or equal to | x | .
+They are equivalent to rint , rintf ,
+and rintl ,
+respectively, in the FE_TOWARDZERO rounding mode.
+
+- Examples
+@code
+#include <math.h>
+int main( )
+{
+ double inp = 1048580.625;
+ double y;
+ y = trunc( inp );
+ printf( "trunc( %f) = %f
+", inp, y );
+ y = truncf( inp);
+ printf( "truncf( %f) = %f
+", inp, y );
+ y = truncl( inp);
+ printf( "truncl( %f) = %f
+
+", inp, y );
+}
+
+@endcode
+ Output
+@code
+trunc ( 1048580.625 ) = 1048580.000000
+truncf( 1048580.625 ) = 1048580.000000
+truncl( 1048580.625 ) = 1048580.000000
+
+@endcode
+@see ceil()
+@see fegetround()
+@see floor()
+@see math()
+@see nextafter()
+@see rint()
+@see round()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn truncf(float x)
+@param x
+@see ceil()
+@see fegetround()
+@see floor()
+@see math()
+@see nextafter()
+@see rint()
+@see round()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn truncl(long double x)
+@param x
+@see ceil()
+@see fegetround()
+@see floor()
+@see math()
+@see nextafter()
+@see rint()
+@see round()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn drem(double x, double y)
+@param x
+@param y
+@return The drem() function returns the remainder, unless y is zero.
+
+- Detailed description
+ The drem dremf and the dreml functions compute the remainder of dividing x by y. The
+return value is x - n * y, where n is the quotient of x / y, rounded to
+the nearest integer. If the quotient is 1/2, it is rounded to the even
+number.
+The function dreml an alias to the function drem.
+
+- Examples
+@code
+#include <math.h>
+void main()
+{
+ double x1 = 6.4, x2 = 2, y;
+ y = drem( x1, x2 );
+ printf( "drem(%f , %f) = %f
+", x1, x2, y );
+ y = dremf( x1, x2 );
+ printf( "dremf(%f , %f) = %f
+", x1, x2, y );
+ y = dreml( x1, x2 );
+ printf( "dreml(%f , %f) = %f
+", x1, x2, y );
+}
+
+@endcode
+ Output
+@code
+drem ( 6.4, 2 ) = 0.4
+dremf( 6.4, 2 ) = 0.4
+dreml( 6.4, 2 ) = 0.4
+
+@endcode
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn isnanf(float)
+
+test for infinity or not-a-number
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn significand(double x)
+@param x
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn significandf(float x)
+@param x
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn acosf(float x)
+@param x
+@see asin()
+@see atan()
+@see atan2()
+@see cos()
+@see cosh()
+@see math()
+@see sin()
+@see sinh()
+@see tan()
+@see tanh()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn asinf(float x)
+@param x
+@see acos()
+@see atan()
+@see atan2()
+@see cos()
+@see cosh()
+@see math()
+@see sin()
+@see sinh()
+@see tan()
+@see tanh()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn atanf(float x)
+@param x
+@see acos()
+@see asin()
+@see atan2()
+@see cos()
+@see cosh()
+@see math()
+@see sin()
+@see sinh()
+@see tan()
+@see tanh()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn atan2f(float y, float x)
+@param y
+@param x
+@see acos()
+@see asin()
+@see atan()
+@see cos()
+@see cosh()
+@see math()
+@see sin()
+@see sinh()
+@see tan()
+@see tanh()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn cosf(float x)
+@param x
+@see acos()
+@see asin()
+@see atan()
+@see atan2()
+@see cosh()
+@see math()
+@see sin()
+@see sinh()
+@see tan()
+@see tanh()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn sinf(float x)
+@param x
+@see acos()
+@see asin()
+@see atan()
+@see atan2()
+@see cos()
+@see cosh()
+@see math()
+@see sinh()
+@see tan()
+@see tanh()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn tanf(float x)
+@param x
+@see acos()
+@see asin()
+@see atan()
+@see atan2()
+@see cos()
+@see cosh()
+@see math()
+@see sin()
+@see sinh()
+@see tanh()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn coshf(float x)
+@param x
+@see acos()
+@see asin()
+@see atan()
+@see atan2()
+@see cos()
+@see math()
+@see sin()
+@see sinh()
+@see tan()
+@see tanh()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn sinhf(float x)
+@param x
+@see acos()
+@see asin()
+@see atan()
+@see atan2()
+@see cos()
+@see cosh()
+@see math()
+@see sin()
+@see tan()
+@see tanh()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn tanhf(float x)
+@param x
+@see acos()
+@see asin()
+@see atan()
+@see atan2()
+@see cos()
+@see cosh()
+@see math()
+@see sin()
+@see sinh()
+@see tan()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn expf(float x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn frexpf(float x, int *eptr)
+@param x
+@param eptr
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn log10f(float x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn logf(float x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn modff(float x, float *iptr)
+@param x
+@param iptr
+@see frexp()
+@see ldexp()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn powf(float x, float y)
+@param x
+@param y
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn sqrtf(float x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn cbrtf(float x)
+@param x
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @fn nexttowardf(float x, long double y)
+@param x
+@param y
+@see ieee()
+@see math()
+
+
+
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def HUGE_VAL
+
+A positive double expression, not necessarily representable as a float.
+Used as an error value returned by the mathematics library. HUGE_VAL evaluates to positive infinity on systems supporting the ANSI/IEEE Std 754:1985 standard.
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def FP_ILOGB0
+
+The value of FP_ILOGB0 shall be either INT_MIN or - INT_MAX.
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def FP_ILOGBNAN
+
+The value of FP_ILOGBNAN shall be either INT_MAX or INT_MIN.
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def HUGE_VALL
+
+A positive long double constant expression. Used as an error value returned by the mathematics library.
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def HUGE_VALF
+
+A positive float constant expression. Used as an error value returned by the mathematics library.
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def INFINITY
+
+A constant expression of type float representing positive or unsigned infinity, if available;
+else a positive constant of type float that overflows at translation time.
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def NAN
+
+A constant expression of type float representing a quiet NaN.
+This symbolic constant is only defined if the implementation supports quiet NaNs for the float type.
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def MATH_ERRNO
+
+macro shall expand to the integer constants 1
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def MATH_ERREXCEPT
+
+macro shall expand to the integer constants 1
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def math_errhandling
+
+Macro shall expand to an expression that has type int and the value MATH_ERRNO, MATH_ERREXCEPT, or the bitwise-inclusive OR of both
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def FP_INFINITE
+
+Macro shall be defined for number classification. They represent the mutually-exclusive kinds of floating-point values.
+They expand to integer constant expressions with distinct values.
+Additional implementation-defined floating-point classifications, with macro definitions beginning with FP_ and an uppercase letter, may also be specified by the implementation.
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def FP_NAN
+
+Macro shall be defined for number classification. They represent the mutually-exclusive kinds of floating-point values.
+They expand to integer constant expressions with distinct values.
+Additional implementation-defined floating-point classifications, with macro definitions beginning with FP_ and an uppercase letter, may also be specified by the implementation.
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def FP_NORMAL
+
+Macro shall be defined for number classification. They represent the mutually-exclusive kinds of floating-point values.
+They expand to integer constant expressions with distinct values.
+Additional implementation-defined floating-point classifications, with macro definitions beginning with FP_ and an uppercase letter, may also be specified by the implementation.
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def FP_SUBNORMAL
+
+Macro shall be defined for number classification. They represent the mutually-exclusive kinds of floating-point values.
+They expand to integer constant expressions with distinct values.
+Additional implementation-defined floating-point classifications, with macro definitions beginning with FP_ and an uppercase letter, may also be specified by the implementation.
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def FP_ZERO
+
+Macro shall be defined for number classification. They represent the mutually-exclusive kinds of floating-point values.
+They expand to integer constant expressions with distinct values.
+Additional implementation-defined floating-point classifications, with macro definitions beginning with FP_ and an uppercase letter, may also be specified by the implementation.
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def fpclassify(x)
+
+The math.h header shall define the following macros, where real floating indicates that the argument shall be an expression of real floating type
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def isfinite(x)
+
+The math.h header shall define the following macros, where real floating indicates that the argument shall be an expression of real floating type
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def isinf(x)
+
+The math.h header shall define the following macros, where real floating indicates that the argument shall be an expression of real floating type
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def isnan(x)
+
+The math.h header shall define the following macros, where real floating indicates that the argument shall be an expression of real floating type
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def isnormal(x)
+
+The math.h header shall define the following macros, where real floating indicates that the argument shall be an expression of real floating type
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def isgreater(x, y)
+
+The math.h header shall define the following macros, where real floating indicates that the argument shall be an expression of real floating type
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def isless(x, y)
+
+The math.h header shall define the following macros, where real floating indicates that the argument shall be an expression of real floating type
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def islessequal(x, y)
+
+The math.h header shall define the following macros, where real floating indicates that the argument shall be an expression of real floating type
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def islessgreater(x, y)
+
+The math.h header shall define the following macros, where real floating indicates that the argument shall be an expression of real floating type
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def isunordered(x, y)
+
+The math.h header shall define the following macros, where real floating indicates that the argument shall be an expression of real floating type
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def isgreaterequal(x, y)
+
+The math.h header shall define the following macros, where real floating indicates that the argument shall be an expression of real floating type
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def signbit(x)
+
+The math.h header shall define the following macros, where real floating indicates that the argument shall be an expression of real floating type
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def M_E
+
+Defines the Value of e
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def M_LOG2E
+
+Defines the Value of log2e
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def M_LOG10E
+
+Defines the Value of log10e
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def M_LN2
+
+Defines the Value of loge2
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def M_LN10
+
+Defines the Value of loge10
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def M_PI
+
+Defines the Value of pi
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def M_PI_2
+
+Defines the Value of pi/2
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def M_PI_4
+
+Defines the Value of pi/4
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def M_1_PI
+
+Defines the Value of 1/pi
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def M_2_PI
+
+Defines the Value of 2/pi
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def M_2_SQRTPI
+
+Defines the Value of 2/sqrt(pi)
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def M_SQRT2
+
+Defines the Value of sqrt(2)
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def M_SQRT1_2
+
+Defines the Value of 1/sqrt(2)
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def MAXFLOAT
+
+Value of maximum non-infinite single-precision floating point number.
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @def HUGE
+
+Defines to (float)3.40282346638528860e+38
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @typedef typedef __double_t double_t;
+
+Double 8 bytes
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+/** @typedef typedef __float_t float_t;
+
+Float 4 bytes
+
+@publishedAll
+@externallyDefinedApi
+*/
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+