July 21, 2005 EXP 3

### NAME

exp, expf, expm1, expm1f, log, logf, log2, log2f, log10, log10f, log1p, log1pf, pow, powf - exponential, logarithm, power functions

### LIBRARY

Math Library (libm, -lm)

### SYNOPSIS

```double` exp(```double x`)
```float` expf(```float x`)
```double` expm1(```double x`)
```float` expm1f(```float x`)
```double` log(```double x`)
```float` logf(```float x`)
```double` log2(```double x`)
```float` log2f(```float x`)
```double` log10(```double x`)
```float` log10f(```float x`)
```double` log1p(```double x`)
```float` log1pf(```float x`)
```double` pow(```double x``, double y`)
```float` powf(```float x``, float y`)

### DESCRIPTION

The exp(``) function computes the exponential value of the given argument ```x`.

The expm1(``) function computes the value exp(x)-1 accurately even for tiny argument ```x`.

The log(``) function computes the value of the natural logarithm of argument ```x`.

The log10(``) function computes the value of the logarithm of argument ```x` to base 10.

The log1p(``) function computes the value of log(1+x) accurately even for tiny argument ```x`.

The log2(``) and the log2f(``) functions compute the value of the logarithm of argument ```x` to base 2.

The pow(``) computes the value of x to the exponent y.

### 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, set the global variable errno to ```ERANGE` and cause a reserved operand fault on a VAX. 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` and on the VAX generate a reserved operand fault. On a VAX, errno is set to ```EDOM` and the reserved operand is returned by log unless ```x` > 0, by log1p(``) unless ```x` > -1.

### ERRORS

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 8 bits for VAX D and 11 bits for IEEE 754 Double. No such drastic loss has been exposed by testing; the worst errors observed have been below 20 ulps for VAX D, 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**56 on a VAX, 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, Infinity (not found on a VAX), and NaN (the reserved operand on a VAX). 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 ) 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) gt; 1 as z gt; 0.

4. If 0**0 = 1, then infinity**0 = 1/0**0 = 1 too; and then **0 = 1 too because x**0 = 1 for all finite and infinite x, i.e., independently of x.

### SEE ALSO

math(3)

### STANDARDS

The exp(``), log(``), log10(``) and pow(``) functions conform to ANSI X3.159-1989 (``ANSI C89'') .

### HISTORY

A exp(``), log(``) and pow(``) functions appeared in Version 6 `AT&T UNIX`. A log10(``) function appeared in Version 7 `AT&T UNIX`. The log1p(``) and expm1(``) functions appeared in 4.3BSD.