Namespaces
Variants

std:: exp (std::complex)

From cppreference.net
C++
Numerics library
std::complex
Défini dans l'en-tête <complex>
template < class T >
std:: complex < T > exp ( const std:: complex < T > & z ) ;

Calcule l'exponentielle en base e de z , c'est-à-dire e (le nombre d'Euler, 2.7182818 ) élevé à la puissance z .

Table des matières

Paramètres

z - valeur complexe

Valeur de retour

Si aucune erreur ne se produit, e élevé à la puissance z , e z
, est retourné.

Gestion des erreurs et valeurs spéciales

Les erreurs sont signalées conformément à math_errhandling .

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

  • std:: exp ( std:: conj ( z ) ) == std:: conj ( std:: exp ( z ) )
  • Si z est (±0,+0) , le résultat est (1,+0)
  • Si z est (x,+∞) (pour tout x fini), le résultat est (NaN,NaN) et FE_INVALID est déclenché.
  • Si z est (x,NaN) (pour tout x fini), le résultat est (NaN,NaN) et FE_INVALID peut être déclenché.
  • Si z est (+∞,+0) , le résultat est (+∞,+0)
  • Si z est (-∞,y) (pour tout y fini), le résultat est +0cis(y)
  • Si z est (+∞,y) (pour tout y fini non nul), le résultat est +∞cis(y)
  • Si z est (-∞,+∞) , le résultat est (±0,±0) (les signes ne sont pas spécifiés)
  • Si z est (+∞,+∞) , le résultat est (±∞,NaN) et FE_INVALID est déclenché (le signe de la partie réelle n'est pas spécifié)
  • Si z est (-∞,NaN) , le résultat est (±0,±0) (les signes ne sont pas spécifiés)
  • Si z est (+∞,NaN) , le résultat est (±∞,NaN) (le signe de la partie réelle n'est pas spécifié)
  • Si z est (NaN,+0) , le résultat est (NaN,+0)
  • Si z est (NaN,y) (pour tout y non nul), le résultat est (NaN,NaN) et FE_INVALID peut être déclenché
  • Si z est (NaN,NaN) , le résultat est (NaN,NaN)

où cis(y) est cos(y) + i sin(y) .

Notes

La fonction exponentielle complexe e z
pour z = x+iy est égale à e x
cis(y) , ou e x
(cos(y) + i sin(y)) .

La fonction exponentielle est une fonction entière dans le plan complexe et ne présente aucune coupure de branche.

Les résultats suivants sont équivalents lorsque la partie réelle est 0 :

Dans ce cas exp peut être environ 4,5 fois plus lent. L'une des autres formes devrait être utilisée au lieu d'appeler exp avec un argument dont la partie réelle est littéralement 0. Il n'y a aucun avantage à essayer d'éviter exp avec une vérification à l'exécution de z. real ( ) == 0 cependant.

Exemple

Exécuter ce code 
#include <cmath>
#include <complex>
#include <iostream>
int main()
{
   const double pi = std::acos(-1.0);
   const std::complex<double> i(0.0, 1.0);
   std::cout << std::fixed << " exp(i * pi) = " << std::exp(i * pi) << '\n';
}

Sortie : 

exp(i * pi) = (-1.000000,0.000000)

Voir aussi

logarithme naturel complexe avec les coupures de branche le long de l'axe réel négatif
(modèle de fonction)
(C++11) (C++11)
retourne e élevé à la puissance donnée ( e x )
(fonction)
applique la fonction std::exp à chaque élément du valarray
(modèle de fonction)
construit un nombre complexe à partir de la magnitude et de l'angle de phase
(modèle de fonction)
Documentation C pour cexp