1 /** @file ../include/math.h

     2 @internalComponent

     3 */

     4 

     5 /** @fn nanval(void )

     6 

     7 Not a number value.

     8 @publishedAll

     9 @released

    10 */

    11 

    12 /** @fn  finite(double x)

    13 @param x

    14 

    15   The finite finitef and finitel functions  return  a  non-zero value if value is neither

    16 infinite nor a "not-a-number" (NaN) value, and 0 otherwise.

    17 

    18  - Examples

    19  @code

    20 #include <math.h>

    21 int main( void )

    22 {

    23    double x;

    24    int y; 

    25    x = 1.34565;

    26    y = finite( x );

    27    printf( "finite( %f ) =  %d

    28 ", x, y );

    29    y = finitef( x );

    30    printf( "finitef( %f ) = %d

    31 ",x, y );

    32    y = finitel( x );

    33    printf( "finitel( %f ) = %d

    34 ",x, y );

    35 }

    36 

    37 @endcode

    38  Output

    39 @code

    40 finite ( 1.34565 ) = 1

    41 finitef( 1.34565 ) = 1

    42 finitel( 1.34565 ) =

    43 @endcode

    44  

    45 

    46 @publishedAll

    47 @released

    48 */

    49 

    50 /** @fn  finitef(float x)

    51 @param x

    52 

    53 

    54  

    55 

    56 @publishedAll

    57 @released

    58 */

    59 

    60 /** @fn  acos(double x)

    61 @param x

    62 @return   The acos, acosf, and acosl functions return the arc cosine in the range [0, pi]

    63 radians.

    64 If: | x | \> 1 , acos (x); returns an NaN.

    65 

    66 - Detailed description

    67  

    68 

    69  The acos, acosf, and acosl functions compute the principal value of the arc cosine of x .

    70 

    71 - Examples

    72 @code

    73 #include <math.h>

    74 int main( )

    75 {

    76    double x = -1;

    77    double y = acos( x );

    78    printf( "acos(%f) = %f

    79 ", x, y );

    80    y = acosf( x );

    81    printf( "acosf(%f) = %f

    82 ", x, y );

    83    y = acosl( x );

    84    printf( "acosl(%f) = %f

    85 ", x, y ); 

    86 }

    87 

    88 @endcode

    89  Output

    90 @code

    91 acos( -1.000000 ) = 3.14159

    92 acosf(-1.000000 ) = 3.14159

    93 acosl(-1.000000 ) = 3.14159

    94 

    95 @endcode

    96 @see asin()

    97 @see atan()

    98 @see atan2()

    99 @see cos()

   100 @see cosh()

   101 @see math()

   102 @see sin()

   103 @see sinh()

   104 @see tan()

   105 @see tanh()

   106 

   107 

   108  

   109 

   110 @publishedAll

   111 @externallyDefinedApi

   112 */

   113 

   114 /** @fn  asin(double x)

   115 @param x

   116 @return   The asin, asinf, and asinl functions return the arc sine in the range

   117 -words [-pi/2, +pi/2]

   118 radians.

   119 If: | x | \> 1 asin (x); returns an NaN.

   120 

   121 - Detailed description

   122   The asin and asinf functions compute the principal value of the arc sine of x .

   123 The function asinl is an alias to the function asin. A domain error occurs for arguments not in the range [-1, +1].

   124 

   125 - Examples

   126 @code

   127 #include <math.h>

   128 int main( )

   129 {

   130    double x = 0.5; 

   131    double y = asin( x );

   132    printf( "asin(%f) = %f

   133 ", x, y );

   134    y = asinf( x );

   135    printf( "asinf(%f) = %f

   136 ", x, y );

   137    y = asinl( x );

   138    printf( "asinl(%f) = %f

   139 ", x, y ); 

   140 }

   141 

   142 @endcode

   143  Output

   144 @code

   145 asin( 0.500000 ) = 0.523599

   146 asinf(0.500000 ) = 0.523599

   147 asinl(0.500000 ) = 0.523599

   148 

   149 @endcode

   150 @see acos()

   151 @see atan()

   152 @see atan2()

   153 @see cos()

   154 @see cosh()

   155 @see math()

   156 @see sin()

   157 @see sinh()

   158 @see tan()

   159 @see tanh()

   160 

   161 

   162    

   163 

   164 @publishedAll

   165 @externallyDefinedApi

   166 */

   167 

   168 /** @fn  atan(double x)

   169 @param x

   170 @see acos()

   171 @see asin()

   172 @see atan2()

   173 @see cos()

   174 @see cosh()

   175 @see math()

   176 @see sin()

   177 @see sinh()

   178 @see tan()

   179 @see tanh()

   180 

   181 

   182    

   183 

   184 @publishedAll

   185 @externallyDefinedApi

   186 */

   187 

   188 /** @fn  atan2(double y, double x)

   189 @param y

   190 @param x

   191 @see acos()

   192 @see asin()

   193 @see atan()

   194 @see cos()

   195 @see cosh()

   196 @see math()

   197 @see sin()

   198 @see sinh()

   199 @see tan()

   200 @see tanh()

   201 

   202 

   203    

   204 

   205 @publishedAll

   206 @externallyDefinedApi

   207 */

   208 

   209 /** @fn  cos(double x)

   210 @param x

   211 @see acos()

   212 @see asin()

   213 @see atan()

   214 @see atan2()

   215 @see cosh()

   216 @see math()

   217 @see sin()

   218 @see sinh()

   219 @see tan()

   220 @see tanh()

   221 

   222 

   223    

   224 

   225 @publishedAll

   226 @externallyDefinedApi

   227 */

   228 

   229 /** @fn  sin(double x)

   230 @param x

   231 @return   The sin and the sinf functions return the sine value.

   232 

   233 - Detailed description

   234   The sin and the sinf functions compute the sine of x (measured in radians).

   235 A large magnitude argument may yield a result with little

   236 or no significance. sinl is just an alias to the function sin

   237 

   238 - Examples

   239 @code

   240 #include <math.h>

   241 int main( )

   242 {

   243    double pi_by_6 = 0.52359877559829887307710723054658383 ;

   244    double y;

   245    y = sin( pi_by_6 );

   246    printf( "sin( %f)  = %f

   247 ", x1,  y );

   248    y = sinf( pi_by_6);

   249    printf( "sinf( %f) = %f

   250 ", pi_by_6, y );

   251    y = sinl( pi_by_6);

   252    printf( "sinl( %f) = %f

   253 ", pi_by_6, y );

   254  }

   255 

   256 @endcode

   257  Output

   258 @code

   259 sin ( 0.52359877559829887307710723054658383 ) = 0.500000

   260 sinf( 0.52359877559829887307710723054658383 ) = 0.500000

   261 sinl( 0.52359877559829887307710723054658383 ) = 0.500000

   262 

   263 @endcode

   264 @see acos()

   265 @see asin()

   266 @see atan()

   267 @see atan2()

   268 @see cos()

   269 @see cosh()

   270 @see math()

   271 @see sinh()

   272 @see tan()

   273 @see tanh()

   274 

   275 

   276    

   277 

   278 @publishedAll

   279 @externallyDefinedApi

   280 */

   281 

   282 /** @fn  tan(double x)

   283 @param x

   284 @return   The tan function returns the tangent value.

   285 

   286 - Detailed description

   287   The tan and tanf functions compute the tangent of x (measured in radians).

   288 A large magnitude argument may yield a result

   289 with little or no significance.

   290 The function tanl is an alias to the function tan

   291 

   292 - Examples

   293 @code

   294 #include <math.h>

   295 int main( )

   296 {

   297    double pi_by_4 = 0.7853981633974483096156608458198757;

   298    double y;

   299    y = tan( pi_by_4 );

   300    printf( "tan( %f)  = %f

   301 ", pi_by_4,  y );

   302    y = tanf( pi_by_4);

   303    printf( "tanf( %f) = %f

   304 ", pi_by_4, y );

   305    y = tanl( pi_by_4);

   306    printf( "tanl( %f) = %f

   307 

   308 ", pi_by_4, y );

   309 }

   310 

   311 @endcode

   312  Output

   313 @code

   314 tan ( 0.7853981633974483096156608458198757 ) = 1.000000

   315 tanf( 0.7853981633974483096156608458198757 ) = 1.000000

   316 tanl( 0.7853981633974483096156608458198757; ) =1.000000

   317 

   318 @endcode

   319 @see acos()

   320 @see asin()

   321 @see atan()

   322 @see atan2()

   323 @see cos()

   324 @see cosh()

   325 @see math()

   326 @see sin()

   327 @see sinh()

   328 @see tanh()

   329 

   330 

   331    

   332 

   333 @publishedAll

   334 @externallyDefinedApi

   335 */

   336 

   337 /** @fn  cosh(double x)

   338 @param x

   339 @see acos()

   340 @see asin()

   341 @see atan()

   342 @see atan2()

   343 @see cos()

   344 @see math()

   345 @see sin()

   346 @see sinh()

   347 @see tan()

   348 @see tanh()

   349 

   350 

   351    

   352 

   353 @publishedAll

   354 @externallyDefinedApi

   355 */

   356 

   357 /** @fn  sinh(double x)

   358 @param x

   359 - Detailed description

   360   The sinh and the sinhf functions compute the hyperbolic sine of x .

   361 The function sinhl is an alias to the function sinh

   362 

   363 - Examples

   364 @code

   365 #include <math.h>

   366 int main( )

   367 {

   368    double inp = 0.75;

   369    double y;

   370    y = sinh( inp );

   371    printf( "sinh( %f)  = %f

   372 ", inp,  y );

   373    y = sinhf( inp);

   374    printf( "sinhf( %f) = %f

   375 ", inp, y );

   376    y = sinhl( inp);

   377    printf( "sinhl( %f) = %f

   378 ", inp, y );

   379 }

   380 

   381 @endcode

   382  Output

   383 @code

   384 sinh ( 0.75 ) = 0.8223167

   385 sinhf( 0.75 ) = 0.8223167

   386 sinhl( 0.75 ) = 0.8223167

   387 

   388 @endcode

   389 @see acos()

   390 @see asin()

   391 @see atan()

   392 @see atan2()

   393 @see cos()

   394 @see cosh()

   395 @see math()

   396 @see sin()

   397 @see tan()

   398 @see tanh()

   399 

   400 

   401    

   402 

   403 @publishedAll

   404 @externallyDefinedApi

   405 */

   406 

   407 /** @fn  tanh(double x)

   408 @param x

   409 @return   The tanh, tanhf and tanhl functions return the hyperbolic tangent value.

   410 

   411 - Detailed description

   412   The tanh and tanhf functions compute the hyperbolic tangent of x . tanhl is an alias to the function tanh.

   413 

   414 - Examples

   415 @code

   416 #include <math.h>

   417 int main( )

   418 {

   419    double inp = 1.0;

   420    double y; 

   421    y = tanh( inp );

   422    printf( "tanh( %f)  = %f

   423 ", inp,  y );

   424    y = tanhf( inp);

   425    printf( "tanhf( %f) = %f

   426 ", inp, y );

   427    y = tanhl( inp);

   428    printf( "tanhl( %f) = %f

   429 

   430 ", inp, y );

   431    inp = 2209.0;

   432    y = sqrt( inp);

   433    printf( "sqrt( %f)  = %d

   434 ", inp,  y );

   435    y = sqrtf( inp);

   436    printf( "sqrtf( %f) = %d

   437 ", inp, y );

   438    y = sqrtl( inp);

   439    printf( "sqrtl( %f) = %d

   440 ", inp, y );

   441 }

   442 

   443 @endcode

   444  Output

   445 @code

   446 tanh ( 1.000000 ) = 0.7615941

   447 tanhf( 1.000000 ) = 0.7615941

   448 tanhl( 1.000000 ) = 0.7615941

   449 

   450 @endcode

   451 @see acos()

   452 @see asin()

   453 @see atan()

   454 @see atan2()

   455 @see cos()

   456 @see cosh()

   457 @see math()

   458 @see sin()

   459 @see sinh()

   460 @see tan()

   461 

   462 

   463    

   464 

   465 @publishedAll

   466 @externallyDefinedApi

   467 */

   468 

   469 /** @fn  exp(double x)

   470 @param x

   471 @return   These functions will return the appropriate computation unless an error

   472 occurs or an argument is out of range.

   473 The functions pow (x, y); and powf (x, y); return an NaN if x \< 0 and y is not an integer.

   474 An attempt to take the logarithm of ±0 will return infinity.

   475 An attempt to take the logarithm of a negative number will

   476 return a NaN.

   477 

   478 - Detailed description

   479   The exp and expf functions compute the base e exponential value of the given argument x .

   480 

   481  The exp2 and exp2f functions compute the base 2 exponential of the given argument x .

   482 

   483  The expm1 and expm1f functions compute the value exp(x)-1 accurately even for tiny argument x .

   484 

   485  The log and logf functions compute the value of the natural logarithm of argument x .

   486 

   487  The log10 and log10f functions compute the value of the logarithm of argument x to base 10.

   488 

   489  The log1p and log1pf functions compute

   490 the value of log(1+x) accurately even for tiny argument x .

   491 

   492  The pow and powf functions compute the value

   493 of x to the exponent y .

   494 

   495  Here the long double version APIs are aliases to the double version APIs.

   496 All apis \<function\>l behaves similiar to that \<function\>.

   497 

   498 - Examples

   499 @code

   500 #include <math.h>

   501 int main( void )

   502 {

   503    double x, y;

   504    x = 1.0;

   505    y = exp( x );

   506    printf( "exp( %f ) = %f

   507 ", x, y );

   508    y = expf( x );

   509    printf( "expf( %f ) = %f

   510 ",x, y );

   511    y = expl( x );

   512    printf( "expl( %f ) = %f

   513 ",x, y );

   514    x = 0.0;

   515    y = exp2( x );

   516    printf( "exp2( %f ) = %f

   517 ", x, y );

   518    y = exp2f( x );

   519    printf( "exp2f( %f ) = %f

   520 ",x, y );

   521    y = exp2l( x );

   522    printf( "exp2l( %f ) = %f

   523 ",x, y );

   524    x = 1.0 ;

   525    y = expm1( x );

   526    printf( "expm1( %f ) = %f

   527 ", x, y );

   528    y = expm1f( x );

   529    printf( "expm1f( %f ) = %f

   530 ",x, y );

   531    y = expm1l( x );

   532    printf( "expm1l( %f ) = %f

   533 ",x, y );

   534 }

   535 

   536 @endcode

   537  Output

   538 @code

   539 exp   ( 1.0 ) = 2.718282

   540 expf  ( 1.0 ) = 2.718282

   541 expl  ( 1.0 ) = 2.718282

   542 exp2  ( 0.0 ) = 1.000000

   543 exp2f ( 0.0 ) = 1.000000

   544 exp2l ( 0.0 ) = 1.000000

   545 expm1 ( 1.0 ) = 1.718281        

   546 expm1f( 1.0 ) = 1.718281

   547 expm1l( 1.0 ) = 1.718281

   548 

   549 @endcode

   550 

   551 Notes:

   552 

   553  The functions exp(x)-1 and log(1+x) are called

   554 expm1 and logp1 in BASIC on the Hewlett-Packard HP -71B and APPLE Macintosh, EXP1 and LN1 in Pascal, exp1 and log1 in C

   555 on APPLE Macintoshes, where they have been provided to make

   556 sure financial calculations of ((1+x)**n-1)/x, namely

   557 expm1(n*log1p(x))/x, will be accurate when x is tiny.

   558 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 .

   559 Previous implementations of pow may

   560 have defined x**0 to be undefined in some or all of these

   561 cases.

   562 Here are reasons for returning x**0 = 1 always: Any program that already tests whether x is zero (or

   563 infinite or NaN) before computing x**0 cannot care

   564 whether 0**0 = 1 or not.

   565 Any program that depends

   566 upon 0**0 to be invalid is dubious anyway since that

   567 expression's meaning and, if invalid, its consequences

   568 vary from one computer system to another. Some Algebra texts (e.g. Sigler's) define x**0 = 1 for

   569 all x, including x = 0.

   570 This is compatible with the convention that accepts a[0]

   571 as the value of polynomial

   572 @code

   573 p(x) = a[0]*x**0 + a[1]*x**1 + a[2]*x**2 +...+ a[n]*x**n

   574 

   575 @endcode

   576  at x = 0 rather than reject a[0]*0**0 as invalid. Analysts will accept 0**0 = 1 despite that x**y can

   577 approach anything or nothing as x and y approach 0

   578 independently.

   579 The reason for setting 0**0 = 1 anyway is this:

   580 @code

   581 If x(z) and y(z) are

   582 

   583  any

   584 functions analytic (expandable

   585 in power series) in z around z = 0, and if there

   586 x(0) = y(0) = 0, then x(z)**y(z) -> 1 as z -> 0.

   587 

   588 @endcode

   589  If 0**0 = 1, then

   590 oo**0 = 1/0**0 = 1 too; and

   591 then NaN**0 = 1 too because x**0 = 1 for all finite

   592 and infinite x, i.e., independently of x.

   593 @see math()

   594 

   595 

   596    

   597 

   598 @publishedAll

   599 @externallyDefinedApi

   600 */

   601 

   602 /** @fn  frexp(double x, int *eptr)

   603 @param x

   604 @param eptr

   605 @return   These functions return the value y ,

   606 such that y is a double with magnitude in the interval [1/2, 1]

   607 or zero, and x equals y times 2 raised to the power *eptr .

   608 If x is zero, both parts of the result are zero.

   609 

   610 - Detailed description

   611   The frexp , frexpf, and frexpl functions break a floating-point number into a normalized

   612 fraction and an integral power of 2.

   613 They store the integer in the int object pointed to by eptr .

   614 As there is no long double is not supported by Symbian, frexpl (is, aliased, to, the); frexp

   615 

   616 

   617 

   618 - Examples

   619 @code

   620 void main( void )

   621 {

   622    double x1 = 4.0 , y;

   623    int res;

   624    y = frexp( x1, &res; );

   625    printf( "frexp(%f , &res;):: Int Part: %d and Fractional Part: %f 

   626 ", x1, res, y );

   627    y = frexpf( x1, &res; );

   628    printf( "frexpf(%f , &res;):: Int Part: %d and Fractional Part: %f 

   629 ", x1, res, y );

   630    y = frexpl( x1, &res; );

   631    printf( "frexpl(%f , &res;):: Int Part: %d and Fractional Part: %f 

   632 ", x1, res, y );

   633 }

   634 

   635 @endcode

   636  Output

   637 @code

   638 frexp ( 4.0 , &res; ) :: Int Part: 3 and Fractional Part: 0.5

   639 frexpf( 4.0,  &res; ) :: Int Part: 3 and Fractional Part: 0.5

   640 frexpl( 4.0,  &res; ) :: Int Part: 3 and Fractional Part: 0.5

   641 

   642 @endcode

   643    

   644 

   645 @publishedAll

   646 @externallyDefinedApi

   647 */

   648 

   649 /** @fn  ldexp(double x, int n)

   650 @param x

   651 @param n

   652 @return   These functions return the value of x times 2 raised to the power n .

   653 

   654 - Detailed description

   655   The ldexp, ldexpf, and ldexpl functions multiply a floating-point number by an integral

   656 power of 2.

   657 

   658 - Examples

   659 @code

   660 #include <math.h>

   661 int main( void )

   662 {

   663    double x1 = 0.8, x2 = 4, y;

   664    y = ldexp( x1, x2 );

   665    printf( "ldexp(%f , %f) = %f

   666 ", x1, x2, y );

   667    y = ldexpf( x1, x2 );

   668    printf( "ldexpf(%f , %f) = %f

   669 ", x1, x2, y );

   670    y = ldexpl( x1, x2 );

   671    printf( "ldexpl(%f , %f) = %f

   672 ", x1, x2, y );

   673 }

   674 

   675 @endcode

   676  Output

   677 @code

   678 ldexp ( 0.8, 4 ) = 12.8

   679 ldexpf( 0.8, 4 ) = 12.8

   680 ldexpl( 0.8, 4 ) = 12.8

   681 

   682 @endcode

   683 @see frexp()

   684 @see math()

   685 @see modf()

   686 

   687 

   688    

   689 

   690 @publishedAll

   691 @externallyDefinedApi

   692 */

   693 

   694 /** @fn  log(double x)

   695 @param x

   696 @see math()

   697 

   698 

   699    

   700 

   701 @publishedAll

   702 @externallyDefinedApi

   703 */

   704 

   705 /** @fn  log10(double x)

   706 @param x

   707 @see math()

   708 

   709 

   710    

   711 

   712 @publishedAll

   713 @externallyDefinedApi

   714 */

   715 

   716 /** @fn  modf(double x, double *iptr)

   717 @param x

   718 @param iptr

   719 @return   The modf, modff and modfl functions return the signed fractional part of a value .

   720 

   721 - Detailed description

   722   The modf function breaks the argument x into integral and fractional parts, each of which has the

   723 same sign as the argument.

   724 It stores the integral part as a double

   725 in the object pointed to by iptr .

   726 The function modff (is, the, float, version, of, modf().); The function modfl is an alias to the function modf.

   727 

   728 - Examples

   729 @code

   730 #include <math.h>

   731 #include <stdio.h>

   732 int main()

   733 {

   734    double x1 = 123.456703 , y;

   735    double  iptr;

   736    float fptr;

   737    y = modf( x1, &iptr; );

   738    printf( "modf(%f , &iptr;):: Int Part: %f and Fractional Part: %f 0, x1, iptr, y );

   739    y = modff( x1, &fptr; );

   740    printf( "modff(%f , &iptr;):: Int Part: %f and Fractional Part: %f 0, x1, fptr, y );

   741    y = modfl( x1, &iptr; );

   742    printf( "modfl(%f , &iptr;):: Int Part: %f and Fractional Part: %f 0, x1, iptr, y );

   743 }

   744 

   745 @endcode

   746  Output

   747 @code

   748 modf ( 123.456703 , &iptr; ) :: Int Part: 123 and Fractional Part: 0.456703

   749 modff( 123.456703,  &iptr; ) :: Int Part: 123 and Fractional Part: 0.456703

   750 modfl( 123.456703,  &iptr; ) :: Int Part: 123 and Fractional Part: 0.456703

   751 

   752 @endcode

   753 @see frexp()

   754 @see ldexp()

   755 @see math()

   756 

   757 

   758    

   759 

   760 @publishedAll

   761 @externallyDefinedApi

   762 */

   763 

   764 /** @fn  pow(double x, double y)

   765 @param x

   766 @param y

   767 @see math()

   768 

   769 

   770    

   771 

   772 @publishedAll

   773 @externallyDefinedApi

   774 */

   775 

   776 /** @fn  sqrt(double x)

   777 @param x

   778 @see math()

   779 

   780 

   781    

   782 

   783 @publishedAll

   784 @externallyDefinedApi

   785 */

   786 

   787 /** @fn  ceil(double x)

   788 @param x

   789 @return   x is integral or infinite, x itself is returned.

   790 

   791 

   792 The ceil , ceilf, and ceill functions return the smallest integral value

   793 greater than or equal to x ,

   794 expressed as a floating-point number.

   795 

   796 - Examples

   797 @code

   798 #include <math.h>

   799 int main( void )

   800 {

   801    double y;

   802    y = ceil( 2.8 );

   803    printf( "The ceil of 2.8 is %f

   804 ", y );

   805    y = ceil( -2.8 );

   806    printf( "The ceil of -2.8 is %f

   807 ", y );

   808    y = ceilf( 2.8 );

   809    printf( "The ceilf of 2.8 is %f

   810 ", y );

   811    y = ceilf( -2.8 );

   812    printf( "The ceilf of -2.8 is %f

   813 ", y );

   814    y = ceill( 2.8 );

   815    printf( "The ceill of 2.8 is %f

   816 ", y );

   817    y = ceill( -2.8 );

   818    printf( "The ceill of -2.8 is %f

   819 ", y );

   820 }

   821 

   822 @endcode

   823  Output

   824 @code

   825 The ceil of 2.8 is 3.000000

   826 The ceil of -2.8 is -2.000000

   827 The ceilf of 2.8 is 3.000000

   828 The ceilf of -2.8 is -2.000000

   829 The ceill of 2.8 is 3.000000

   830 The ceill of -2.8 is -2.000000

   831 

   832 @endcode

   833 @see abs()

   834 @see fabs()

   835 @see floor()

   836 @see ieee()

   837 @see math()

   838 @see rint()

   839 @see round()

   840 @see trunc()

   841 

   842 

   843    

   844 

   845 @publishedAll

   846 @externallyDefinedApi

   847 */

   848 

   849 /** @fn  ceilf(float x)

   850 @param x

   851 @see abs()

   852 @see fabs()

   853 @see floor()

   854 @see ieee()

   855 @see math()

   856 @see rint()

   857 @see round()

   858 @see trunc()

   859 

   860 

   861    

   862 

   863 @publishedAll

   864 @externallyDefinedApi

   865 */

   866 

   867 /** @fn  fabs(double x)

   868 @param x

   869 @return   The fabs , fabsf and fabsl functions return the absolute value of x .

   870 

   871 The fabs , fabsf and fabsl functions compute the absolute value of a floating-point number x .

   872 

   873 Examples

   874 @code

   875 #include  <stdio.h>

   876 #include  <math.h>

   877 int main( void )

   878 {

   879    double dx = -3.141593, dy;

   880    dy = fabs( dx );

   881    printf( "fabs( %f ) = %f

   882 ", dx, dy );

   883    dy = fabsf( dx );

   884    printf( "fabsf( %f ) = %f

   885 ", dx, dy );

   886    dy = fabsl( dx );

   887    printf( "fabsl( %f ) = %f

   888 ", dx, dy );

   889 }

   890 

   891 @endcode

   892  Output

   893 @code

   894 fabs( -3.141593  ) = 3.141593

   895 fabsf( -3.141593 ) = 3.141593

   896 fabsl( -3.141593 ) = 3.141593

   897 

   898 @endcode

   899 @see abs()

   900 @see ceil()

   901 @see floor()

   902 @see ieee()

   903 @see math()

   904 @see rint()

   905 

   906 

   907    

   908 

   909 @publishedAll

   910 @externallyDefinedApi

   911 */

   912 

   913 /** @fn  fabsf(float x)

   914 @param x

   915 @see abs()

   916 @see ceil()

   917 @see floor()

   918 @see ieee()

   919 @see math()

   920 @see rint()

   921 

   922 

   923    

   924 

   925 @publishedAll

   926 @externallyDefinedApi

   927 */

   928 

   929 /** @fn  fabsl(long double x)

   930 @param x

   931 @see abs()

   932 @see ceil()

   933 @see floor()

   934 @see ieee()

   935 @see math()

   936 @see rint()

   937 

   938 

   939    

   940 

   941 @publishedAll

   942 @externallyDefinedApi

   943 */

   944 

   945 /** @fn  floor(double x)

   946 @param x

   947 @return   x is integral or infinite, x itself is returned.

   948 

   949 

   950 The floor , floorf, and floorl functions return the largest integral value

   951 less than or equal to x ,

   952 expressed as a floating-point number.

   953 

   954 - Examples

   955 @code

   956 #include <math.h>

   957 int main( void )

   958 {

   959    double y;

   960    y = floor( 2.8 );

   961    printf( "The floor of 2.8 is %f

   962 ", y );

   963    y = floorf( 2.8 );

   964    printf( "The floorf of 2.8 is %f

   965 ", y );

   966    y = floorl( 2.8 );

   967    printf( "The floorl of 2.8 is %f

   968 ", y );

   969 }

   970 

   971 @endcode

   972  Output

   973 @code

   974 The floor  of 2.8 is 2.000000

   975 The floorf of 2.8 is 2.000000

   976 The floorl of 2.8 is 2.000000

   977 

   978 @endcode

   979 @see abs()

   980 @see ceil()

   981 @see fabs()

   982 @see ieee()

   983 @see math()

   984 @see rint()

   985 @see round()

   986 @see trunc()

   987 

   988 

   989    

   990 

   991 @publishedAll

   992 @externallyDefinedApi

   993 */

   994 

   995 /** @fn  floorf(float x)

   996 @param x

   997 @see abs()

   998 @see ceil()

   999 @see fabs()

  1000 @see ieee()

  1001 @see math()

  1002 @see rint()

  1003 @see round()

  1004 @see trunc()

  1005 

  1006 

  1007    

  1008 

  1009 @publishedAll

  1010 @externallyDefinedApi

  1011 */

  1012 

  1013 /** @fn  fmod(double x, double y)

  1014 @param x

  1015 @param y

  1016 @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 .

  1017 If y is zero, whether a domain error occurs or the fmod and fmodf function returns zero is implementation-defined.

  1018 

  1019 

  1020 The fmod, fmodf, and fmodl functions compute the floating-point remainder of x / y . fmodl is an alias to the function fmod.

  1021 

  1022 Examples

  1023 @code

  1024 #include <math.h>

  1025 int main()

  1026 {

  1027    double x1 = 6.5, x2 = 2.25, y;

  1028    y = fmod( x1, x2 );

  1029    printf( "fmod(%f , %f) = %f

  1030 ", x1, x2, y );

  1031    y = fmodf( x1, x2 );

  1032    printf( "fmodf(%f , %f) = %f

  1033 ", x1, x2, y );

  1034    y = fmodl( x1, x2 );

  1035    printf( "fmodl(%f , %f) = %f

  1036 ", x1, x2, y );

  1037 }

  1038 

  1039 @endcode

  1040  Output

  1041 @code

  1042 fmod ( 6.4, 2 ) = 2.0

  1043 fmodf( 6.4, 2 ) = 2.0

  1044 fmodl( 6.4, 2 ) = 2.0

  1045 

  1046 @endcode

  1047 @see math()

  1048 

  1049 

  1050    

  1051 

  1052 @publishedAll

  1053 @externallyDefinedApi

  1054 */

  1055 

  1056 /** @fn  fmodf(float x, float y)

  1057 @param x

  1058 @param y

  1059 @see math()

  1060 

  1061 

  1062    

  1063 

  1064 @publishedAll

  1065 @externallyDefinedApi

  1066 */

  1067 

  1068 /** @fn  acosh(double x)

  1069 @param x

  1070 @return   The acosh , acoshf ,

  1071 and acoshl functions

  1072 return the inverse hyperbolic cosine of x .

  1073 If the argument is less than 1, acosh returns an NaN.

  1074 

  1075 

  1076 The acosh and acoshf functions compute the inverse hyperbolic cosine

  1077 of the real

  1078 argument x .

  1079 The function acoshl is an alias to the function acosh .

  1080 

  1081 - Examples

  1082 @code

  1083 #include <math.h>

  1084 int main( )

  1085 {

  1086    double x = 1;

  1087    double y = acosh( x );

  1088    printf( "acosh(%f) = %f

  1089 ", x, y );

  1090    y = acoshf( x );

  1091    printf( "acoshf(%f) = %f

  1092 ", x, y );

  1093    y = acoshl( x );

  1094    printf( "acoshl(%f) = %f

  1095 ", x, y ); 

  1096 }

  1097 

  1098 @endcode

  1099  Output

  1100 @code

  1101 acosh( 1.000000 ) = 0.0

  1102 acoshf(1.000000 ) = 0.0

  1103 acoshl(1.000000 ) = 0.0

  1104 

  1105 @endcode

  1106 @see asinh()

  1107 @see atanh()

  1108 @see exp()

  1109 @see math()

  1110 

  1111 

  1112    

  1113 

  1114 @publishedAll

  1115 @externallyDefinedApi

  1116 */

  1117 

  1118 /** @fn  acoshf(float x)

  1119 @param x

  1120 @see asinh()

  1121 @see atanh()

  1122 @see exp()

  1123 @see math()

  1124 

  1125 

  1126    

  1127 

  1128 @publishedAll

  1129 @externallyDefinedApi

  1130 */

  1131 

  1132 /** @fn  asinh(double x)

  1133 @param x

  1134 @see acosh()

  1135 @see atanh()