EXP(3) | Library Functions Manual | EXP(3)

# NAME

`exp`, `expf`, `expl`, `exp2`, `exp2f`, `exp2l`, `expm1`, `expm1f`, `expm1l`, `log`, `logf`, `logl`, `log2`, `log2f`, `log2l`, `log10`, `log10f`, `log10l`, `log1p`, `log1pf`, `log1pl`, `pow`, `powf`, `powl` — exponential, logarithm, power functions

# SYNOPSIS

Math Library (libm, -lm)
`#include <math.h>`

double
`exp`(double x);

float
`expf`(float x);

long double
`expl`(long double x);

double
`exp2`(double x);

float
`exp2f`(float x);

long double
`exp2l`(long double x);

double
`expm1`(double x);

float
`expm1f`(float x);

long double
`expm1l`(long double x);

double
`log`(double x);

float
`logf`(float x);

long double
`logl`(long double x);

double
`log2`(double x);

float
`log2f`(float x);

long double
`log2l`(long double x);

double
`log10`(double x);

float
`log10f`(float x);

long double
`log10l`(long double x);

double
`log1p`(double x);

float
`log1pf`(float x);

long double
`log1pl`(long double x);

double
`pow`(double x, double y);

float
`powf`(float x, float y);

long double
`powl`(long double x, long double y);

# DESCRIPTION

The `exp`() function computes the base e exponential value of the given argument x. The `expf`() function is a single precision version of `exp`(). The `expl`() function is an extended precision version of `exp`().

The `exp2`() function computes the base 2 exponential of the given argument x. The `exp2f`() function is a single precision version of `exp2`(). The `exp2l`() function is an extended precision version of `exp2`().

The `expm1`() function computes the value exp(x) − 1 accurately even for tiny argument x. The `expm1f`() function is a single precision version of `expm1`(). The `expm1l`() function is an extended precision version of `expm1`().

The `log`() function computes the value of the natural logarithm of argument x. The `logf`() function is a single precision version of `log`(). The `logl`() function is an extended precision version of `log`().

The `log2`() function computes the value of the logarithm of argument x to base 2. The `log2f`() function is a single precision version of `log2`(). The `log2l`() function is an extended precision version of `log2`().

The `log10`() function computes the value of the logarithm of argument x to base 10. The `log10f`() function is a single precision version of `log10`(). The `log10l`() function is an extended precision version of `log10`().

The `log1p`() function computes the value of log(1 + x) accurately even for tiny argument x. The `log1pf`() function is a single precision version of `log1p`(). The `log1pl`() function is an extended precision version of `log1p`().

The `pow`() function computes the value of x to the exponent y. The `powf`() function is a single precision version of `pow`(). The `powl`() function is an extended precision version of `pow`().

# RETURN VALUES

These functions will return the appropriate computation unless an error occurs or an argument is out of range. The functions `exp`(), `expm1`() and `pow`() detect if the computed value will overflow and set the global variable errno to `ERANGE`. The function `pow`(x, y) checks to see if x < 0 and y is not an integer, in the event this is true, the global variable errno is set to `EDOM`.

# ERRORS (due to Roundoff etc.)

exp(x), log(x), expm1(x) and log1p(x) are accurate to within an ulp, and log10(x) to within about 2 ulps; an ulp is one Unit in the Last Place. The error in `pow`(x, y) is below about 2 ulps when its magnitude is moderate, but increases as `pow`(x, y) approaches the over/underflow thresholds until almost as many bits could be lost as are occupied by the floating-point format's exponent field; that is 11 bits for IEEE 754 Double. No such drastic loss has been exposed by testing; the worst errors observed have been below 300 ulps for IEEE 754 Double. Moderate values of `pow`() are accurate enough that `pow`(integer, integer) is exact until it is bigger than 2**53 for IEEE 754.

# 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 and infinity. 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:

1. 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.
2. 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

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

   at x = 0 rather than reject a[0]*0**0 as invalid.

3. 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:
   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.
4. If 0**0 = 1, then infinity**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 ALSO

fpclassify(3), ilogb(3)

# HISTORY

The `exp`() and `log`() functions first appeared in Version 1 AT&T UNIX; `pow`() in Version 3 AT&T UNIX; `log10`() in Version 7 AT&T UNIX; `log1p`() and `expm1`() in 4.3BSD.

June 7, 2025 | Debian