/** @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()