std::pow, std::powf, std::powl

[editar] Parámetros

[editar] Valor de retorno

Si no se producen errores, se devuelve base elevada a la potencia exp (o iexp) (baseexp
).

Si se produce un error de dominio, se devuelve un valor definido por la implementación (NaN donde se dé apoyo).

Si se produce un error de plo o un error de rango debido a desbordamiento, se devuelve ±HUGE_VAL, ±HUGE_VALF, o ±HUGE_VALL.

Si se produce un error debido a subdesbordamiento, se devuelve el resultado correcto (después del redondeo).

[editar] Manejo de errores

Los errores se informan como se especifica en math_errhandling.

Si base es finita y negativa y exp es finito y no entero, se produce un error de dominio y se puede producir un error de rango.

Si base es cero y exp es cero, se puede producir un error de dominio.

Si base es cero y exp es negativo, se puede producir un error de dominio o un error de polo.

Si la implementación admite la aritmética de punto flotante IEEE (IEC 60559):

• pow(+0, exp), donde exp es un entero non negativo, devuelve +∞ y genera FE_DIVBYZERO.
• pow(-0, exp), donde exp es un entero non negativo, devuelve -∞ y genera FE_DIVBYZERO.
• pow(±0, exp), donde exp es negativo, finito, y es un entero par o no entero, devuelve +∞ y genera FE_DIVBYZERO.
• pow(±0, -∞) devuelve +∞ y puede generar FE_DIVBYZERO.
• pow(+0, exp), donde exp es un entero par positivo, devuelve +0.
• pow(-0, exp), donde exp es un entero par positivo, devuelve -0.
• pow(±0, exp), donde exp es un no entero positivo o un entero par negativo, devuelve +0.
• pow(-1, ±∞) devuelve 1.
• pow(+1, exp) devuelve 1 para cualquier exp, incluso cuando exp es NaN.
• pow(base, ±0) devuelve 1 para cualquier base, incluso cuando base es NaN.
• pow(base, exp) devuelve NaN y genera FE_INVALID si base es finita y negative y exp es finito y no entero.
• pow(base, -∞) devuelve +∞ para cualquier |base|<1.
• pow(base, -∞) devuelve +0 para cualquier |base|>1.
• pow(base, +∞) devuelve +0 para cualquier |base|<1.
• pow(base, +∞) devuelve +∞ para cualquier |base|>1.
• pow(-∞, exp) devuelve -0 si exp es un entero non negativo
• pow(-∞, exp) devuelve +0 si exp es un no entero negativo o un entero par negativo.
• pow(-∞, exp) devuelve -∞ si exp es un entero par positivo.
• pow(-∞, exp) devuelve +∞ si exp es no entero positivo o un entero par positivo.
• pow(+∞, exp) devuelve +0 para cualquier exp negativo.
• pow(+∞, exp) devuelve +∞ para cualquier exp positivo.
• excepto donde se especifique anteriormente, si cualquier argumento es NaN, se devuelve NaN.

[editar] Notas

pow(float, int) devuelve float hasta C++11 (de acuerdo con la sobrecarga 4) pero devuelve double desde C++11 (de acuerdo con la sobrecarga 7).

Aunque std::pow no se puede usar para obtener una raíz de un número negativo, std::cbrt se proporciona para el caso común donde exp es 1/3.

[editar] Ejemplo

#include <iostream>
#include <cmath>
#include <cerrno>
#include <cfenv>
#include <cstring>
 
#pragma STDC FENV_ACCESS ON
int main()
{
    // uso típico
    std::cout << "pow(2, 10) = " << std::pow(2,10) << '\n'
              << "pow(2, 0.5) = " << std::pow(2,0.5) << '\n'
              << "pow(-2, -3) = " << std::pow(-2,-3) << '\n';
    // valores especiales
    std::cout << "pow(-1, NAN) = " << std::pow(-1,NAN) << '\n'
              << "pow(+1, NAN) = " << std::pow(+1,NAN) << '\n'
              << "pow(INFINITY, 2) = " << std::pow(INFINITY, 2) << '\n'
              << "pow(INFINITY, -1) = " << std::pow(INFINITY, -1) << '\n';
    // manejo de errores
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "pow(-1, 1/3) = " << std::pow(-1, 1.0/3) << '\n';
    if (errno == EDOM)
        std::cout << "    errno == EDOM " << std::strerror(errno) << '\n';
    if (std::fetestexcept(FE_INVALID))
        std::cout << "    Se generó FE_INVALID\n";
 
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "pow(-0, -3) = " << std::pow(-0.0, -3) << '\n';
    if (std::fetestexcept(FE_DIVBYZERO))
        std::cout << "    Se generó FE_DIVBYZERO\n";
}

pow(2, 10) = 1024
pow(2, 0.5) = 1.41421
pow(-2, -3) = -0.125
pow(-1, NAN) = nan
pow(+1, NAN) = 1
pow(INFINITY, 2) = inf
pow(INFINITY, -1) = 0
pow(-1, 1/3) = -nan
    errno == EDOM Argumento numérico fuera de dominio
    Se generó FE_INVALID
pow(-0, -3) = -inf
    Se generó FE_DIVBYZERO

[editar] Véase también