These functions compute e (the base of natural logarithms) raised
to the power x.

If the magnitude of the result is too large to be representable,
exp signals overflow.

— Function: double exp2 (double x)

— Function: float exp2f (float x)

— Function: long double exp2l (long double x)

These functions compute 2 raised to the power x.
Mathematically, exp2 (x) is the same as exp (x * log (2)).

— Function: double exp10 (double x)

— Function: float exp10f (float x)

— Function: long double exp10l (long double x)

— Function: double pow10 (double x)

— Function: float pow10f (float x)

— Function: long double pow10l (long double x)

These functions compute 10 raised to the power x.
Mathematically, exp10 (x) is the same as exp (x * log (10)).

These functions are GNU extensions. The name exp10 is
preferred, since it is analogous to exp and exp2.

— Function: double log (double x)

— Function: float logf (float x)

— Function: long double logl (long double x)

These functions compute the natural logarithm of x. exp (log
(x)) equals x, exactly in mathematics and approximately in
C.

If x is negative, log signals a domain error. If x
is zero, it returns negative infinity; if x is too close to zero,
it may signal overflow.

— Function: double log10 (double x)

— Function: float log10f (float x)

— Function: long double log10l (long double x)

These functions return the base-10 logarithm of x.
log10 (x) equals log (x) / log (10).

— Function: double log2 (double x)

— Function: float log2f (float x)

— Function: long double log2l (long double x)

These functions return the base-2 logarithm of x.
log2 (x) equals log (x) / log (2).

— Function: double logb (double x)

— Function: float logbf (float x)

— Function: long double logbl (long double x)

These functions extract the exponent of x and return it as a
floating-point value. If FLT_RADIX is two, logb is equal
to floor (log2 (x)), except it's probably faster.

If x is de-normalized, logb returns the exponent x
would have if it were normalized. If x is infinity (positive or
negative), logb returns ∞. If x is zero,
logb returns ∞. It does not signal.

— Function: int ilogb (double x)

— Function: int ilogbf (float x)

— Function: int ilogbl (long double x)

These functions are equivalent to the corresponding logb
functions except that they return signed integer values.

Since integers cannot represent infinity and NaN, ilogb instead
returns an integer that can't be the exponent of a normal floating-point
number. math.h defines constants so you can check for this.

— Macro: int FP_ILOGB0

ilogb returns this value if its argument is 0. The
numeric value is either INT_MIN or -INT_MAX.

This macro is defined in ISO C99.

— Macro: int FP_ILOGBNAN

ilogb returns this value if its argument is NaN. The
numeric value is either INT_MIN or INT_MAX.

This macro is defined in ISO C99.

These values are system specific. They might even be the same. The
proper way to test the result of ilogb is as follows:

i = ilogb (f);
if (i == FP_ILOGB0 || i == FP_ILOGBNAN)
{
if (isnan (f))
{
/* Handle NaN. */
}
else if (f == 0.0)
{
/* Handle 0.0. */
}
else
{
/* Some other value with large exponent,perhaps +Inf. */
}
}

— Function: long double powl (long double base, long double power)

These are general exponentiation functions, returning base raised
to power.

Mathematically, pow would return a complex number when base
is negative and power is not an integral value. pow can't
do that, so instead it signals a domain error. pow may also
underflow or overflow the destination type.

— Function: double sqrt (double x)

— Function: float sqrtf (float x)

— Function: long double sqrtl (long double x)

These functions return the nonnegative square root of x.

If x is negative, sqrt signals a domain error.
Mathematically, it should return a complex number.

— Function: double cbrt (double x)

— Function: float cbrtf (float x)

— Function: long double cbrtl (long double x)

These functions return the cube root of x. They cannot
fail; every representable real value has a representable real cube root.

— Function: double hypot (double x, double y)

— Function: float hypotf (float x, float y)

— Function: long double hypotl (long double x, long double y)

These functions return sqrt (x*x +
y*y). This is the length of the hypotenuse of a right
triangle with sides of length x and y, or the distance
of the point (x, y) from the origin. Using this function
instead of the direct formula is wise, since the error is
much smaller. See also the function cabs in Absolute Value.

— Function: double expm1 (double x)

— Function: float expm1f (float x)

— Function: long double expm1l (long double x)

These functions return a value equivalent to exp (x) - 1.
They are computed in a way that is accurate even if x is
near zero—a case where exp (x) - 1 would be inaccurate owing
to subtraction of two numbers that are nearly equal.

— Function: double log1p (double x)

— Function: float log1pf (float x)

— Function: long double log1pl (long double x)

These functions returns a value equivalent to log (1 + x).
They are computed in a way that is accurate even if x is
near zero.

ISO C99 defines complex variants of some of the exponentiation and
logarithm functions.