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

From cppreference.net

Definido en el encabezado `<cmath>`
	(1)
float pow ( float base, float exp ) ; double pow ( double base, double exp ) ; long double pow ( long double base, long double exp ) ;			(hasta C++23)
/* floating-point-type / pow ( / floating-point-type / base, / floating-point-type */ exp )			(desde C++23) (constexpr desde C++26)
float pow ( float base, int exp ) ; double pow ( double base, int exp ) ; long double pow ( long double base, int exp ) ;		(2)	(hasta C++11)
float powf ( float base, float exp ) ;		(3)	(desde C++11) (constexpr desde C++26)
long double powl ( long double base, long double exp ) ;		(4)	(desde C++11) (constexpr desde C++26)
Sobrecargas adicionales (desde C++11)
Definido en el encabezado `<cmath>`
template < class Arithmetic1, class Arithmetic2 > /* common-floating-point-type */ pow ( Arithmetic1 base, Arithmetic2 exp ) ;		(A)	(constexpr desde C++26)

1-4) Calcula el valor de base elevado a la potencia exp . La biblioteca proporciona sobrecargas de


          std::pow

para todos los tipos de punto flotante sin calificación cv como tipo de los parámetros base y exp . (since C++23)

A) Se proporcionan sobrecargas adicionales para todas las demás combinaciones de tipos aritméticos.

(since C++11)

Contenidos

Parámetros

base	-	base como valor de punto flotante o entero
exp	-	exponente como valor de punto flotante o entero

Valor de retorno

Si no ocurren errores, base elevado a la potencia de exp ( $base exp$ ), es devuelto.

Si ocurre un error de dominio, se devuelve un valor definido por la implementación (NaN donde esté soportado).

Si ocurre un error de polo o un error de rango debido a desbordamiento, ±HUGE_VAL , ±HUGE_VALF , o ±HUGE_VALL es devuelto.

Si ocurre un error de rango debido a desbordamiento inferior, se devuelve el resultado correcto (después del redondeo).

Manejo de errores

Los errores se reportan como se especifica en math_errhandling .

Si base es finito y negativo y exp es finito y no entero, ocurre un error de dominio y puede ocurrir un error de rango.

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

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

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

pow ( + 0 , exp ) , donde exp es un entero impar negativo, retorna +∞ y genera FE_DIVBYZERO .
pow ( - 0 , exp ) , donde exp es un entero impar negativo, retorna -∞ y genera FE_DIVBYZERO .
pow ( ± 0 , exp ) , donde exp es negativo, finito, y es un entero par o un no entero, retorna +∞ y genera FE_DIVBYZERO .
pow ( ± 0 , - ∞ ) retorna +∞ y puede generar FE_DIVBYZERO .
pow ( + 0 , exp ) , donde exp es un entero impar positivo, retorna +0.
pow ( - 0 , exp ) , donde exp es un entero impar positivo, retorna -0.
pow ( ± 0 , exp ) , donde exp es no entero positivo o un entero par positivo, retorna +0.
pow ( - 1 , ±∞ ) retorna 1.
pow ( + 1 , exp ) retorna 1 para cualquier exp , incluso cuando exp es NaN.
pow ( base, ± 0 ) retorna 1 para cualquier base , incluso cuando base es NaN.
pow ( base, exp ) retorna NaN y genera FE_INVALID si base es finito y negativo y exp es finito y no entero.
pow ( base, - ∞ ) retorna +∞ para cualquier |base| < 1 .
pow ( base, - ∞ ) retorna +0 para cualquier |base| > 1 .
pow ( base, + ∞ ) retorna +0 para cualquier |base| < 1 .
pow ( base, + ∞ ) retorna +∞ para cualquier |base| > 1 .
pow ( - ∞, exp ) retorna -0 si exp es un entero impar negativo.
pow ( - ∞, exp ) retorna +0 si exp es un no entero negativo o entero par negativo.
pow ( - ∞, exp ) retorna -∞ si exp es un entero impar positivo.
pow ( - ∞, exp ) retorna +∞ si exp es un no entero positivo o entero par positivo.
pow ( + ∞, exp ) retorna +0 para cualquier exp negativo.
pow ( + ∞, exp ) retorna +∞ para cualquier exp positivo.
excepto donde se especifica arriba, si cualquier argumento es NaN, se retorna NaN.

Notas

C++98 agregó sobrecargas donde exp tiene tipo int además de la función C pow() , y el tipo de retorno de std :: pow ( float , int ) era float . Sin embargo, las sobrecargas adicionales introducidas en C++11 especifican que std :: pow ( float , int ) debe retornar double . LWG issue 550 fue planteado para abordar este conflicto, y la resolución es eliminar las sobrecargas adicionales de int exp .

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

Las sobrecargas adicionales no requieren ser proporcionadas exactamente como (A) . Solo necesitan ser suficientes para garantizar que para su primer argumento num1 y segundo argumento num2 :

Si num1 o num2 tiene tipo long double , entonces std :: pow ( num1, num2 ) tiene el mismo efecto que std :: pow ( static_cast < long double > ( num1 ) ,
static_cast < long double > ( num2 ) ) .
En caso contrario, si num1 y/o num2 tiene tipo double o un tipo entero, entonces std :: pow ( num1, num2 ) tiene el mismo efecto que std :: pow ( static_cast < double > ( num1 ) ,
static_cast < double > ( num2 ) ) .
En caso contrario, si num1 o num2 tiene tipo float , entonces std :: pow ( num1, num2 ) tiene el mismo efecto que std :: pow ( static_cast < float > ( num1 ) ,
static_cast < float > ( num2 ) ) .

(hasta C++23)

Si num1 y num2 tienen tipos aritméticos, entonces std :: pow ( num1, num2 ) tiene el mismo efecto que std :: pow ( static_cast < /*common-floating-point-type*/ > ( num1 ) ,
static_cast < /*common-floating-point-type*/ > ( num2 ) ) , donde /*common-floating-point-type*/ es el tipo de punto flotante con el mayor rango de conversión de punto flotante y mayor subrango de conversión de punto flotante entre los tipos de num1 y num2 , los argumentos de tipo entero se consideran con el mismo rango de conversión de punto flotante que double .

Si no existe tal tipo de punto flotante con el mayor rango y subrango, entonces la resolución de sobrecarga no resulta en un candidato utilizable de las sobrecargas proporcionadas.

(desde C++23)

Ejemplo

Ejecutar este código

#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
// #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 << "    FE_INVALID raised\n";
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "pow(-0, -3) = " << std::pow(-0.0, -3) << '\n';
    if (std::fetestexcept(FE_DIVBYZERO))
        std::cout << "    FE_DIVBYZERO raised\n";
}

Salida posible:

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 Numerical argument out of domain
    FE_INVALID raised
pow(-0, -3) = -inf
    FE_DIVBYZERO raised

Véase también

sqrt sqrtf sqrtl (C++11) (C++11)	calcula la raíz cuadrada ( $\sqrt x$ ) (función)
cbrt cbrtf cbrtl (C++11) (C++11) (C++11)	calcula la raíz cúbica ( $3 \sqrt x$ ) (función)
hypot hypotf hypotl (C++11) (C++11) (C++11)	calcula la hipotenusa $\sqrt x 2 +y 2$ y $\sqrt x 2 +y 2 +z 2$ (desde C++17) (función)
pow (std::complex)	potencia compleja, uno o ambos argumentos pueden ser números complejos (plantilla de función)
pow (std::valarray)	aplica la función std::pow a dos valarrays o a un valarray y un valor (plantilla de función)
Documentación C para pow

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants