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

*/