NAME¶

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

Synopsis¶

Defined in header <cmath>
float pow ( float base, float exp );

double pow ( double base, double exp ); (until C++23)

long double pow ( long double base, long double exp
);
/* floating-point-type */
(since C++23)
pow ( /* floating-point-type */ base, (constexpr since C++26)

/* floating-point-type */ exp )
float pow ( float base, int exp );

double pow ( double base, int exp ); (1) (2) (until C++11)

long double pow ( long double base, int exp );
float powf( float base, float exp ); (3) (since C++11)
(constexpr since C++26)
long double powl( long double base, long double exp (4) (since C++11)
); (constexpr since C++26)
Additional overloads (since C++11)
Defined in header <cmath>
template< class Arithmetic1, class Arithmetic2 >

/* common-floating-point-type */ (A) (constexpr since C++26)

pow ( Arithmetic1 base, Arithmetic2 exp
);

1-4) Computes the value of base raised to the power exp.
The library provides overloads of std::pow for all cv-unqualified floating-point
types as the type of the parameters base and exp.
(since C++23)

A) Additional overloads are provided for all other combinations of (since C++11)
arithmetic types.

Parameters¶

base - base as a floating-point or integer value
exp - exponent as a floating-point or integer value

Return value¶

If no errors occur, base raised to the power of exp (baseexp
), is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where
supported).

If a pole error or a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or
±HUGE_VALL is returned.

If a range error occurs due to underflow, the correct result (after rounding) is
returned.

Error handling¶

Errors are reported as specified in math_errhandling.

If base is finite and negative and exp is finite and non-integer, a domain error
occurs and a range error may occur.

If base is zero and exp is zero, a domain error may occur.

If base is zero and exp is negative, a domain error or a pole error may occur.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),

* pow(+0, exp), where exp is a negative odd integer, returns +∞ and raises
FE_DIVBYZERO.
* pow(-0, exp), where exp is a negative odd integer, returns -∞ and raises
FE_DIVBYZERO.
* pow(±0, exp), where exp is negative, finite, and is an even integer or a
non-integer, returns +∞ and raises FE_DIVBYZERO.
* pow(±0, -∞) returns +∞ and may raise FE_DIVBYZERO.
* pow(+0, exp), where exp is a positive odd integer, returns +0.
* pow(-0, exp), where exp is a positive odd integer, returns -0.
* pow(±0, exp), where exp is positive non-integer or a positive even integer,
returns +0.
* pow(-1, ±∞) returns 1.
* pow(+1, exp) returns 1 for any exp, even when exp is NaN.
* pow(base, ±0) returns 1 for any base, even when base is NaN.
* pow(base, exp) returns NaN and raises FE_INVALID if base is finite and negative
and exp is finite and non-integer.
* pow(base, -∞) returns +∞ for any |base| < 1.
* pow(base, -∞) returns +0 for any |base| > 1.
* pow(base, +∞) returns +0 for any |base| < 1.
* pow(base, +∞) returns +∞ for any |base| > 1.
* pow(-∞, exp) returns -0 if exp is a negative odd integer.
* pow(-∞, exp) returns +0 if exp is a negative non-integer or negative even
integer.
* pow(-∞, exp) returns -∞ if exp is a positive odd integer.
* pow(-∞, exp) returns +∞ if exp is a positive non-integer or positive even
integer.
* pow(+∞, exp) returns +0 for any negative exp.
* pow(+∞, exp) returns +∞ for any positive exp.
* except where specified above, if any argument is NaN, NaN is returned.

Notes¶

C++98 added overloads where exp has type int on top of C pow(), and the return type
of std::pow(float, int) was float. However, the additional overloads introduced in
C++11 specify that std::pow(float, int) should return double. LWG issue 550 was
raised to target this conflict, and the resolution is to removed the extra int exp
overloads.

Although std::pow cannot be used to obtain a root of a negative number, std::cbrt is
provided for the common case where exp is 1/3.

The additional overloads are not required to be provided exactly as (A). They only
need to be sufficient to ensure that for their first argument num1 and second
argument num2:

* If num1 or num2 has type long double, then std::pow(num1, num2)
has the same effect as std::pow(static_cast<long double>(num1),
static_cast<long double>(num2)).
* Otherwise, if num1 and/or num2 has type double or an integer type,
then std::pow(num1, num2) has the same effect as (until C++23)
std::pow(static_cast<double>(num1),
static_cast<double>(num2)).
* Otherwise, if num1 or num2 has type float, then std::pow(num1,
num2) has the same effect as std::pow(static_cast<float>(num1),
static_cast<float>(num2)).
If num1 and num2 have arithmetic types, then std::pow(num1, num2) has
the same effect as std::pow(static_cast</* common-floating-point-type
*/>(num1),
static_cast</* common-floating-point-type */>(num2)), where
/* common-floating-point-type */ is the floating-point type with the
greatest floating-point conversion rank and greatest floating-point
conversion subrank between the types of num1 and num2, arguments of (since C++23)
integer type are considered to have the same floating-point conversion
rank as double.

If no such floating-point type with the greatest rank and subrank
exists, then overload resolution does not result in a usable candidate
from the overloads provided.

Example¶

// Run this code

#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
// #pragma STDC FENV_ACCESS ON

int main()
{
// typical usage
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';

// special values
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';

// error handling
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";
}

Possible output:¶

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

See also¶

sqrt computes square root (\(\small{\sqrt{x}}\)
sqrtf √
sqrtl x)
(C++11) (function)
(C++11)
cbrt computes cube root (\(\small{\sqrt[3]{x}}\)
cbrtf 3
cbrtl √
(C++11) x)
(C++11) (function)
(C++11)
computes square root of the sum of the squares of two
or three
(since C++17) given numbers (\(\scriptsize{\sqrt{x^2+y^2}}\)
√
hypot x2
hypotf +y2
hypotl )
(C++11) , (\(\scriptsize{\sqrt{x^2+y^2+z^2}}\)
(C++11) √
(C++11) x2
+y2
+z2
)
(since C++17)
(function)
pow(std::complex) complex power, one or both arguments may be a complex number
(function template)
applies the function std::pow to two valarrays or a valarray and
pow(std::valarray) a value
(function template)
C documentation for
pow