std::exp,std::expf,std::expl(3)

NAME
std::exp,std::expf,std::expl - std::exp,std::expf,std::expl

Synopsis
   Defined in header <cmath>
   float exp ( float arg );
   float expf( float arg ); (since C++11)
   double exp ( double arg ); (1) (2)
   long double exp ( long double arg );
   long double expl( long double arg ); (3) (since C++11)
   double exp ( IntegralType arg ); (4) (since C++11)
   1-3) Computes e (Euler's number, 2.7182818...) raised to the given power arg
   4) A set of overloads or a function template accepting an argument of any integral
   type. Equivalent to (2) (the argument is cast to double).

Parameters
   arg - value of floating-point or Integral type

Return value
   If no errors occur, the base-e exponential of arg (earg
   ) is returned.
   If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is
   returned.
   If a range error occurs due to underflow, the correct result (after rounding) is
   returned.

Error handling
   Errors are reported as specified in math_errhandling.
   If the implementation supports IEEE floating-point arithmetic (IEC 60559),
     * If the argument is ±0, 1 is returned
     * If the argument is -∞, +0 is returned
     * If the argument is +∞, +∞ is returned
     * If the argument is NaN, NaN is returned

Notes
   For IEEE-compatible type double, overflow is guaranteed if 709.8 < arg, and
   underflow is guaranteed if arg < -708.4

Example
// Run this code
 #include <iostream>
 #include <iomanip>
 #include <cmath>
 #include <cerrno>
 #include <cstring>
 #include <cfenv>
 // #pragma STDC FENV_ACCESS ON
 int main()
 {
     std::cout << "exp(1) = e¹ = " << std::setprecision(16) << std::exp(1) << '\n'
               << "FV of $100, continuously compounded at 3% for 1 year = "
               << std::setprecision(6) << 100*std::exp(0.03) << '\n';
     // special values
     std::cout << "exp(-0) = " << std::exp(-0.0) << '\n'
               << "exp(-Inf) = " << std::exp(-INFINITY) << '\n';
     // error handling
     errno = 0;
     std::feclearexcept(FE_ALL_EXCEPT);
     std::cout << "exp(710) = " << std::exp(710) << '\n';
     if (errno == ERANGE)
         std::cout << " errno == ERANGE: " << std::strerror(errno) << '\n';
     if (std::fetestexcept(FE_OVERFLOW))
         std::cout << " FE_OVERFLOW raised\n";
 }

Possible output:
 exp(1) = e¹ = 2.718281828459045
 FV of $100, continuously compounded at 3% for 1 year = 103.045
 exp(-0) = 1
 exp(-Inf) = 0
 exp(710) = inf
     errno == ERANGE: Numerical result out of range
     FE_OVERFLOW raised

See also
   exp2
   exp2f
   exp2l returns 2 raised to the given power (\({\small 2^x}\)2^x)
   (C++11) (function)
   (C++11)
   (C++11)
   expm1
   expm1f returns e raised to the given power, minus one (\({\small
   expm1l e^x-1}\)e^x-1)
   (C++11) (function)
   (C++11)
   (C++11)
   log
   logf computes natural (base e) logarithm (\({\small \ln{x} }\)ln(x))
   logl (function)
   (C++11)
   (C++11)
   exp(std::complex) complex base e exponential
                      (function template)
   exp(std::valarray) applies the function std::exp to each element of valarray
                      (function template)