Namespaces
Variants

    std:: pow (std::complex)

    From es.cppreference.net
    C++
    Numerics library
    std::complex
    Definido en el encabezado <complex>
    template < class T >
    std:: complex < T > pow ( const std:: complex < T > & x, int y ) ;
    		(1) (hasta 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)
    Definido en el encabezado <complex>
    (A)
    template < class T1, class T2 >

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

    pow ( const std:: complex < T1 > & x, const std:: complex < T2 > & y ) ;
    		(hasta 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 ) ;
    		(desde C++23)
    (B)
    template < class T, class NonComplex >

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

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

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

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

    std:: complex < /* tipo-común */ >

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

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

    pow ( const NonComplex & x, const std:: complex < T > & y ) ;
    		(desde C++23)
    1-4) Calcula el complejo x elevado a una potencia compleja y con un corte de rama a lo largo del eje real negativo para el primer argumento. Los argumentos no complejos se tratan como números complejos con componente imaginario cero positivo.
    A-C) Se proporcionan sobrecargas adicionales. NonComplex no es una especialización de std::complex .
    		(since C++11)

    Contenidos

    Parámetros

    x - base
    y - exponente

    Valor de retorno

    1-4) Si no ocurren errores, se devuelve la potencia compleja x y
    .
    Los errores y casos especiales se manejan como si la operación estuviera implementada por std:: exp ( y * std:: log ( x ) ) .
    El resultado de std:: pow ( 0 , 0 ) está definido por la implementación.
    A-C) Igual que (2-4) .

    Notas

    La sobrecarga (1) se proporcionó en C++98 para coincidir con las sobrecargas adicionales (2) de std::pow . Esas sobrecargas fueron eliminadas mediante la resolución de LWG issue 550 , y la sobrecarga (1) fue eliminada mediante la resolución de LWG issue 844 .

    Las sobrecargas adicionales no están obligadas a proporcionarse exactamente como (A-C) . Solo necesitan ser suficientes para garantizar que para su primer argumento base y segundo argumento exponent :

    Si base y/o exponent tiene tipo std:: complex < T > :

    • Si base y/o exponent tiene tipo std:: complex < long double > o long double , entonces std::pow(base, exponent) tiene el mismo efecto que std::pow ( std:: complex < long double > ( base ) ,
      std:: complex < long double > ( exponent ) )       .
    • En caso contrario, si base y/o exponent tiene tipo std:: complex < double > , double , o un tipo entero, entonces std::pow(base, exponent) tiene el mismo efecto que std::pow ( std:: complex < double > ( base ) ,
      std:: complex < double > ( exponent ) )       .
    • En caso contrario, si base y/o exponent tiene tipo std:: complex < float > o float , entonces std::pow(base, exponent) tiene el mismo efecto que std::pow ( std:: complex < float > ( base ) ,
      std:: complex < float > ( exponent ) )       .
    		(hasta C++23)

    Si un argumento tiene tipo std:: complex < T1 > y el otro argumento tiene tipo T2 o std:: complex < T2 > , entonces std::pow(base, exponent) tiene el mismo efecto 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 > no está bien formado, entonces el programa está mal formado.

    		(desde C++23)

    Ejemplo

    Ejecutar este código 
    #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); // raíz cuadrada de -1
    std::cout << "-1^0.5 = " << std::pow(z2, 0.5) << '\n';
    std::complex<double> z3(-1.0, -0.0); // otro lado del corte
    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';
}

    Salida: 

    (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)

    Véase también

    		raíz cuadrada compleja en el rango del semiplano derecho
    (plantilla de función)
    (C++11) (C++11)
    		eleva un número a la potencia dada ( x y )
    (función)
    		aplica la función std::pow a dos valarrays o a un valarray y un valor
    (plantilla de función)
    Documentación C para cpow