Namespaces
Variants

std:: pow (std::complex)

From cppreference.net
C++
Numerics library
std::complex
Défini dans l'en-tête <complex>
template < class T >
std:: complex < T > pow ( const std:: complex < T > & x, int y ) ;
(1) (jusqu'à C++11)
template < class T >
std:: complex < T > pow ( const std:: complex < T > & x, const std:: complex < T > & y ) ;
(2)
template < class T >
std:: complex < T > pow ( const std:: complex < T > & x, const T & y ) ;
(3)
template < class T >
std:: complex < T > pow ( const T & x, const std:: complex < T > & y ) ;
(4)
Défini dans l'en-tête <complex>
(A)
template < class T1, class T2 >

std:: complex < /* type-commun */ >

pow ( const std:: complex < T1 > & x, const std:: complex < T2 > & y ) ;
(jusqu'à C++23)
template < class T1, class T2 >

std:: complex < std:: common_type_t < T1, T2 >>

pow ( const std:: complex < T1 > & x, const std:: complex < T2 > & y ) ;
(depuis C++23)
(B)
template < class T, class NonComplex >

std:: complex < /* type-commun */ >

pow ( const std:: complex < T > & x, const NonComplex & y ) ;
(jusqu'en C++23)
template < class T, class NonComplex >

std:: complex < std:: common_type_t < T, NonComplex >>

pow ( const std:: complex < T > & x, const NonComplex & y ) ;
(depuis C++23)
(C)
template < class T, class NonComplex >

std:: complex < /* type-commun */ >

pow ( const NonComplex & x, const std:: complex < T > & y ) ;
(jusqu'à C++23)
template < class T, class NonComplex >

std:: complex < std:: common_type_t < T, NonComplex >>

pow ( const NonComplex & x, const std:: complex < T > & y ) ;
(depuis C++23)
1-4) Calcule le nombre complexe x élevé à la puissance complexe y avec une coupure de branche le long de l'axe réel négatif pour le premier argument. Les arguments non complexes sont traités comme des nombres complexes avec une composante imaginaire positive nulle.
A-C) Des surcharges supplémentaires sont fournies. NonComplex n'est pas une spécialisation de std::complex .
(depuis C++11)

Table des matières

Paramètres

x - base
y - exposant

Valeur de retour

1-4) Si aucune erreur ne se produit, la puissance complexe x y
est renvoyée.
Les erreurs et les cas particuliers sont gérés comme si l'opération était implémentée par std:: exp ( y * std:: log ( x ) ) .
Le résultat de std:: pow ( 0 , 0 ) est défini par l'implémentation.
A-C) Identique à (2-4) .

Notes

La surcharge (1) a été fournie en C++98 pour correspondre aux surcharges supplémentaires (2) de std::pow . Ces surcharges ont été supprimées par la résolution de LWG issue 550 , et la surcharge (1) a été supprimée par la résolution de LWG issue 844 .

Les surcharges supplémentaires ne sont pas tenues d'être fournies exactement comme (A-C) . Elles doivent seulement être suffisantes pour garantir que pour leur premier argument base et second argument exponent :

Si base et/ou exponent a le type std:: complex < T > :

  • Si base et/ou exponent a le type std:: complex < long double > ou long double , alors std::pow(base, exponent) a le même effet que std::pow ( std:: complex < long double > ( base ) ,
    std:: complex < long double > ( exponent ) )     .
  • Sinon, si base et/ou exponent a le type std:: complex < double > , double , ou un type entier, alors std::pow(base, exponent) a le même effet que std::pow ( std:: complex < double > ( base ) ,
    std:: complex < double > ( exponent ) )     .
  • Sinon, si base et/ou exponent a le type std:: complex < float > ou float , alors std::pow(base, exponent) a le même effet que std::pow ( std:: complex < float > ( base ) ,
    std:: complex < float > ( exponent ) )     .
(jusqu'à C++23)

Si un argument a le type std:: complex < T1 > et l'autre argument a le type T2 ou std:: complex < T2 > , alors std::pow(base, exponent) a le même effet que std::pow ( std:: complex < std:: common_type_t < T1, T2 >> ( base ) ,
std:: complex < std:: common_type_t < T1, T2 >> ( exponent ) ) .

Si std:: common_type_t < T1, T2 > n'est pas bien formé, alors le programme est mal formé.

(depuis C++23)

Exemple

Exécuter ce code 
#include <complex>
#include <iostream>
int main()
{
    std::cout << std::fixed;
    std::complex<double> z(1.0, 2.0);
    std::cout << "(1,2)^2 = " << std::pow(z, 2) << '\n';
    std::complex<double> z2(-1.0, 0.0); // racine carrée de -1
    std::cout << "-1^0.5 = " << std::pow(z2, 0.5) << '\n';
    std::complex<double> z3(-1.0, -0.0); // autre côté de la coupure
    std::cout << "(-1,-0)^0.5 = " << std::pow(z3, 0.5) << '\n';
    std::complex<double> i(0.0, 1.0); // i^i = exp(-pi / 2)
    std::cout << "i^i = " << std::pow(i, i) << '\n';
}

Sortie : 

(1,2)^2 = (-3.000000,4.000000)
-1^0.5 = (0.000000,1.000000)
(-1,-0)^0.5 = (0.000000,-1.000000)
i^i = (0.207880,0.000000)

Voir aussi

racine carrée complexe dans le demi-plan droit
(modèle de fonction)
(C++11) (C++11)
élève un nombre à la puissance donnée ( x y )
(fonction)
applique la fonction std::pow à deux valarrays ou à un valarray et une valeur
(modèle de fonction)
documentation C pour cpow