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

Definiert in der Header-Datei `<cmath>`
	(1)
float exp ( float num ); double exp ( double num ); long double exp ( long double num );			(bis C++23)
/* Gleitkommazahl-Typ / exp ( /Gleitkommazahltyp*/ num );			(seit C++23) (constexpr seit C++26)
float expf( float num );		(2)	(seit C++11) (constexpr seit C++26)
long double expl( long double num );		(3)	(seit C++11) (constexpr seit C++26)
SIMD-Überladung (seit C++26)
Definiert im Header `<simd>`
template< /math-floating-point/ V > constexpr /deduzierter-simd-t/<V> exp ( const V& v_num );		(S)	(seit C++26)
Zusätzliche Überladungen (seit C++11)
Definiert in der Header-Datei `<cmath>`
template< class Integer > double exp ( Integer num );		(A)	(constexpr seit C++26)

1-3) Berechnet

e

(Eulersche Zahl, 2.7182818...) hoch die gegebene Potenz num. Die Bibliothek stellt Überladungen von std::exp für alle cv-unqualifizierten Gleitkommatypen als Parametertyp zur Verfügung.(seit C++23)

S) Die SIMD-Überladung führt eine elementweise std::exp auf v_num durch.

(Siehe math-floating-point und deduced-simd-t für ihre Definitionen.)

(seit C++26)

A) Zusätzliche Überladungen werden für alle ganzzahligen Typen bereitgestellt, die als double behandelt werden.

(seit C++11)

[edit] Parameter

num

-

Gleitkomma- oder Ganzzahlwert

[edit] Rückgabewert

Wenn keine Fehler auftreten, wird die eulersche Exponentialfunktion von num ( $e num$ ) zurückgegeben.

Wenn aufgrund von Überlauf ein Bereichsfehler auftritt, wird +HUGE_VAL, +HUGE_VALF oder +HUGE_VALL zurückgegeben.

Wenn ein Bereichsfehler aufgrund eines Unterlaufs auftritt, wird das korrekte Ergebnis (nach Rundung) zurückgegeben.

[edit] Fehlerbehandlung

Fehler werden wie in math_errhandling beschrieben gemeldet.

Wenn die Implementierung IEEE-Gleitkomma-Arithmetik (IEC 60559) unterstützt,

Wenn das Argument ±0 ist, wird 1 zurückgegeben.
Wenn das Argument -∞ ist, wird +0 zurückgegeben.
Wenn das Argument +∞ ist, wird +∞ zurückgegeben.
Wenn das Argument NaN ist, wird NaN zurückgegeben.

[edit] Hinweise

Für den IEEE-kompatiblen Typ double ist ein Überlauf garantiert, wenn $709.8 < num$ , und ein Unterlauf garantiert, wenn $num < -708.4$ .

Die zusätzlichen Überladungen müssen nicht exakt wie in (A) bereitgestellt werden. Sie müssen nur ausreichen, um sicherzustellen, dass für ihr Argument num vom ganzzahligen Typ std::exp(num) denselben Effekt hat wie std::exp(static_cast<double>(num)).

[edit] Beispiel

Führen Sie diesen Code aus

#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";
}

Mögliche Ausgabe

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: Numerical result out of range
    FE_OVERFLOW raised

[edit] Siehe auch

exp2exp2fexp2l (C++11)(C++11)(C++11)	gibt $2$ hoch der gegebenen Potenz zurück (${\small 2^x}$ $2 x$ ) (Funktion) [bearbeiten]
expm1expm1fexpm1l (C++11)(C++11)(C++11)	gibt $e$ hoch der gegebenen Potenz minus $1$ zurück (${\small e^x-1}$ $e x -1$ ) (Funktion) [bearbeiten]
loglogflogl (C++11)(C++11)	berechnet den natürlichen (Basis $e$ ) Logarithmus (${\small\ln{x}}$ $ln(x)$ ) (Funktion) [bearbeiten]
exp(std::complex)	komplexer Basis-e-Exponentialwert (function template) [edit]
exp(std::valarray)	wendet die Funktion std::exp auf jedes Element von valarray an (function template) [edit]
C-Dokumentation für exp

Compiler-Unterstützung
Freestanding und gehostet
Sprache
Standardbibliothek
Header der Standardbibliothek
Benannte Anforderungen
Feature-Test-Makros (C++20)
Bibliothek für Sprachunterstützung
Konzepte-Bibliothek (C++20)
Diagnostik-Bibliothek
Speicherverwaltungsbibliothek
Metaprogrammierungsbibliothek (C++11)
Allgemeine Dienstprogramme-Bibliothek
Container-Bibliothek
Iterator-Bibliothek
Ranges-Bibliothek (C++20)
Algorithmen-Bibliothek
Bibliothek für Zeichenketten
Textverarbeitungsbibliothek
Numerik-Bibliothek
Datums- und Zeitbibliothek
Ein-/Ausgabe-Bibliothek
Dateisystembibliothek (C++17)
Unterstützung für nebenläufige Programmierung (C++11)
Ausführungssteuerungsbibliothek (C++26)
Technische Spezifikationen
Symbolverzeichnis
Externe Bibliotheken

cppreference.com

Namensräume

Varianten

Ansichten

Aktionen