exp#

Raise e to a power.

exp returns e (the base of natural logarithms, roughly 2.718281828459045) raised to the power of EXPR. It is the inverse of log: for any finite positive $x, exp(log($x)) reproduces $x to within floating-point rounding. With no argument, exp operates on $_.

Synopsis#

exp EXPR
exp

What you get back#

A double-precision floating-point number. The result is always non-negative: exp(0) == 1, exp of any positive value is greater than 1, and exp of any negative value lies in the open interval (0, 1).

On every Linux target pperl supports, the underlying type is IEEE 754 binary64, so the range of finite results is roughly 5e-324 up to 1.7976931348623157e+308. Arguments above about 709.78 overflow to Inf; arguments below about -745 underflow to 0.0.

Examples#

Get e itself, and verify the round-trip against log:

my $e = exp(1);                     # 2.718281828459045
printf "%.15f\n", exp(log(42));     # 42.000000000000000

No-argument form reads $_:

for (1, 2, 3) {
    printf "exp(%d) = %.6f\n", $_, exp;
}
# exp(1) = 2.718282
# exp(2) = 7.389056
# exp(3) = 20.085537

Compose with other numeric built-ins. The hyperbolic sine, for example, has no dedicated operator but falls out of exp:

sub sinh { (exp($_[0]) - exp(-$_[0])) / 2 }
printf "%.6f\n", sinh(1);           # 1.175201

Overflow at the top of the IEEE 754 range:

print exp(709), "\n";               # 8.21840746949e+307
print exp(710), "\n";               # Inf

Underflow at the bottom:

print exp(-745), "\n";              # 5e-324  (smallest subnormal)
print exp(-746), "\n";              # 0

Edge cases#

Very large positive argument: Any argument greater than roughly 709.78 produces Inf. Inf propagates through subsequent arithmetic (Inf + 1 == Inf, Inf - Inf is NaN) and stringifies as "Inf".
Very negative argument: Arguments below roughly -745 underflow to 0.0. Values in between render as denormal floats with progressively reduced precision.
NaN input: exp(NaN) is NaN. NaN compares unequal to everything including itself — test with Scalar::Util::looks_like_number or $x != $x rather than ==.
exp(0) is exactly 1, not a rounded approximation.
Non-numeric argument: Perl coerces the argument through its standard string-to-number rules before calling the C exp(3) routine. exp("") and exp("abc") are therefore exp(0) == 1, with an Argument "…" isn't numeric warning under use warnings. A leading-numeric string like "3.5xyz" becomes 3.5, again with a warning.
undef argument: Coerced to 0, yielding 1, with an uninitialized warning under use warnings.
List context: exp is a unary numeric function. It ignores list context and always returns a single scalar. my @r = exp(2) puts one element into @r.

Differences from upstream#

Fully compatible with upstream Perl 5.42.