Next: Normalization Functions, Up: Arithmetic Functions [Contents][Index]

These functions are provided for obtaining the *absolute value* (or
*magnitude*) of a number. The absolute value of a real number
`x` is `x` if `x` is positive, -`x` if `x` is
negative. For a complex number `z`, whose real part is `x` and
whose imaginary part is `y`, the absolute value is `sqrt (`

.
`x`*`x` + `y`*`y`)

Prototypes for `abs`

, `labs`

and `llabs`

are in `stdlib.h`;
`imaxabs`

is declared in `inttypes.h`;
`fabs`

, `fabsf`

and `fabsl`

are declared in `math.h`.
`cabs`

, `cabsf`

and `cabsl`

are declared in `complex.h`.

- Function:
*int***abs***(int*`number`) - Function:
*long int***labs***(long int*`number`) - Function:
*long long int***llabs***(long long int*`number`) - Function:
*intmax_t***imaxabs***(intmax_t*`number`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions return the absolute value of

`number`.Most computers use a two’s complement integer representation, in which the absolute value of

`INT_MIN`

(the smallest possible`int`

) cannot be represented; thus,`abs (INT_MIN)`

is not defined.`llabs`

and`imaxdiv`

are new to ISO C99.See Integers for a description of the

`intmax_t`

type.

- Function:
*double***fabs***(double*`number`) - Function:
*float***fabsf***(float*`number`) - Function:
*long double***fabsl***(long double*`number`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

This function returns the absolute value of the floating-point number

`number`.

- Function:
*double***cabs***(complex double*`z`) - Function:
*float***cabsf***(complex float*`z`) - Function:
*long double***cabsl***(complex long double*`z`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions return the absolute value of the complex number

`z`(see Complex Numbers). The absolute value of a complex number is:sqrt (creal (

`z`) * creal (`z`) + cimag (`z`) * cimag (`z`))This function should always be used instead of the direct formula because it takes special care to avoid losing precision. It may also take advantage of hardware support for this operation. See

`hypot`

in Exponents and Logarithms.

Next: Normalization Functions, Up: Arithmetic Functions [Contents][Index]