# OpenBSD manual page server

Manual Page Search Parameters

 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

```#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 () function computes the base e exponential value of the given argument x. The () function is a single precision version of `exp`(). The () function is an extended precision version of `exp`().

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

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

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

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

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

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

The () function computes the value of x to the exponent y. The () function is a single precision version of `pow`(). The () 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 in the . 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.

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 (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 as the value of polynomial
`p(x) = a*x**0 + a*x**1 + a*x**2 +...+ a[n]*x**n`

at x = 0 rather than reject a*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 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.
 June 29, 2021 OpenBSD-current