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