Namespaces
Variants

std:: exp, std:: expf, std:: expl

From cppreference.net
C++
Numerics library
Common mathematical functions
Nearest integer floating point operations
(C++11)
(C++11)
(C++11) (C++11) (C++11)
Floating point manipulation functions
(C++11) (C++11)
(C++11)
(C++11)
Classification and comparison
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
Défini dans l'en-tête <cmath>
(1)
float exp ( float num ) ;

double exp ( double num ) ;

long double exp ( long double num ) ;
(jusqu'à C++23)
/*floating-point-type*/
exp ( /*floating-point-type*/ num ) ;
(depuis C++23)
(constexpr depuis C++26)
float expf ( float num ) ;
(2) (depuis C++11)
(constexpr depuis C++26)
long double expl ( long double num ) ;
(3) (depuis C++11)
(constexpr depuis C++26)
Surcharge SIMD (depuis C++26)
Défini dans l'en-tête <simd>
template < /*math-floating-point*/ V >

constexpr /*deduced-simd-t*/ < V >

exp ( const V & v_num ) ;
(S) (depuis C++26)
Défini dans l'en-tête <cmath>
template < class Integer >
double exp ( Integer num ) ;
(A) (constexpr depuis C++26)
1-3) Calcule e ( le nombre d'Euler , 2.7182818 ... ) élevé à la puissance donnée num . La bibliothèque fournit des surcharges de std::exp pour tous les types à virgule flottante non qualifiés cv comme type du paramètre. (depuis C++23)
S) La surcharge SIMD effectue un calcul std::exp élément par élément sur v_num .
(Voir math-floating-point et deduced-simd-t pour leurs définitions.)
(depuis C++26)
A) Des surcharges supplémentaires sont fournies pour tous les types entiers, qui sont traités comme double .
(since C++11)

Table des matières

Paramètres

num - valeur à virgule flottante ou entière

Valeur de retour

Si aucune erreur ne se produit, l'exponentielle de base e de num ( e num
) est retournée.

Si une erreur de plage se produit en raison d'un dépassement, +HUGE_VAL , +HUGE_VALF , ou +HUGE_VALL est renvoyé.

Si une erreur de plage se produit en raison d'un dépassement inférieur, le résultat correct (après arrondi) est retourné.

Gestion des erreurs

Les erreurs sont signalées comme spécifié dans math_errhandling .

Si l'implémentation prend en charge l'arithmétique à virgule flottante IEEE (IEC 60559),

  • Si l'argument est ±0, 1 est retourné.
  • Si l'argument est -∞, +0 est retourné.
  • Si l'argument est +∞, +∞ est retourné.
  • Si l'argument est NaN, NaN est retourné.

Notes

Pour le type compatible IEEE double , le dépassement de capacité est garanti si 709.8 < num , et le sous-dépassement est garanti si num < -708.4 .

Les surcharges supplémentaires ne sont pas requises d'être fournies exactement comme (A) . Elles doivent seulement être suffisantes pour garantir que pour leur argument num de type entier, std :: exp ( num ) ait le même effet que std :: exp ( static_cast < double > ( num ) ) .

Exemple

Exécuter ce code 
#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <numbers>
// #pragma STDC FENV_ACCESS ON
consteval double approx_e()
{
    long double e{1.0};
    for (auto fac{1ull}, n{1llu}; n != 18; ++n, fac *= n)
        e += 1.0 / fac;
    return e;
}
int main()
{
    std::cout << std::setprecision(16)
              << "exp(1) = e¹ = " << std::exp(1) << '\n'
              << "numbers::e  = " << std::numbers::e << '\n'
              << "approx_e    = " << approx_e() << '\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";
}

Sortie possible : 

exp(1) = e¹ = 2.718281828459045
numbers::e  = 2.718281828459045
approx_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: Résultat numérique hors limites
    FE_OVERFLOW raised

Voir aussi

(C++11) (C++11) (C++11)
retourne 2 élevé à la puissance donnée ( 2 x )
(fonction)
(C++11) (C++11) (C++11)
retourne e élevé à la puissance donnée, moins 1 ( e x -1 )
(fonction)
(C++11) (C++11)
calcule le logarithme naturel (base e ) ( ln(x) )
(fonction)
exponentielle complexe de base e
(modèle de fonction)
applique la fonction std::exp à chaque élément du valarray
(modèle de fonction)
Documentation C pour exp