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

Definido en el archivo de encabezado `<cmath>`
	(1)
`float pow ( float base, float exp );`
`float powf( float base, float exp );`			(desde C++11)
`double pow ( double base, double exp );`		(2)
		(3)
`long double pow ( long double base, long double exp );`
`long double powl( long double base, long double exp );`				(desde C++11)
`float pow ( float base, int iexp );`			(4)	(hasta C++11)
`double pow ( double base, int iexp );`			(5)	(hasta C++11)
`long double pow ( long double base, int iexp );`			(6)	(hasta C++11)
`Promovido pow ( Aritmético1 base, Aritmético2 exp );`			(7)	(desde C++11)

1-6) Calcula el valor de base elevada a la potencia exp o iexp.

7) Un conjunto de sobrecargas o una plantilla de función para todas las combinaciones de los argumentos de tipo aritmético no cubiertas por 1-3). Si algún argumento tiene tipo entero, se convierte a double. Si cualquier argumento es long double, entonces el tipo de retorno Promovido también es long double, de lo contrario el tipo de retorno es siempre double.

Parámetros

base	-	La base como un valor de tipo flotante o un tipo entero.
exp	-	El exponente como un valor de tipo flotante o un tipo entero.
iexp	-	El exponente como un valor entero.

Valor de retorno

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

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

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.

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.

Ejemplo

Ejecuta este código

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

Posible salida:

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

Véase también

sqrtsqrtfsqrtl (C++11)(C++11)	Calcula la raíz cuadrada ($\small{\sqrt{x} }$ $\sqrt x$ ) (función) [editar]
cbrtcbrtfcbrtl (C++11)(C++11)(C++11)	Calcula la raíz cúbica ($\small{\sqrt[3]{x} }$ $3 \sqrt x$ ) (función) [editar]
hypothypotfhypotl (C++11)(C++11)(C++11)	Calcula la raíz cuadrada de la suma de los cuadrados de dos o tres (C++17) números dados ($\scriptsize{\sqrt{x^2+y^2} }$ $\sqrt x 2 +y 2$ ), ($\scriptsize{\sqrt{x^2+y^2+z^2} }$ $\sqrt x 2 +y 2 +z 2$ ) (función) [editar]
pow(std::complex)	Potencia compleja; uno o ambos argumentos pueden ser un número complejo. (plantilla de función) [editar]
pow(std::valarray)	aplica la función std::pow a dos o valarrays valarray una y un valor Original: applies the function std::pow to two valarrays or a valarray and a value The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (plantilla de función) [editar]
Documentación de C para pow

Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas

cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones