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

Functions

Basic operations

abs(int)labsllabsimaxabs (C++11)
abs(float)fabs
divldivlldivimaxdiv (C++11)
fmod

remainder (C++11)
remquo (C++11)
fma (C++11)
fmax (C++11)
fmin (C++11)
fdim (C++11)
nannanfnanl (C++11)(C++11)(C++11)

Exponential functions

exp
exp2 (C++11)
expm1 (C++11)

log
log10
log1p (C++11)
log2 (C++11)

Power functions

sqrt
cbrt (C++11)

hypot (C++11)
pow

Trigonometric and hyperbolic functions

sin
cos
tan
asin
acos
atan
atan2

sinh
cosh
tanh
asinh (C++11)
acosh (C++11)
atanh (C++11)

Error and gamma functions

erf (C++11)
erfc (C++11)

lgamma (C++11)
tgamma (C++11)

Nearest integer floating point operations

ceil
floor
roundlroundllround (C++11)(C++11)(C++11)

trunc (C++11)
nearbyint (C++11)
rintlrintllrint (C++11)(C++11)(C++11)

Floating point manipulation functions

ldexp
scalbnscalbln (C++11)(C++11)
ilogb (C++11)
logb (C++11)

frexp
modf
nextafternexttoward (C++11)(C++11)
copysign (C++11)

Classification/Comparison

fpclassify (C++11)
isfinite (C++11)
isinf (C++11)
isnan (C++11)
isnormal (C++11)
signbit (C++11)

isgreater (C++11)
isgreaterequal (C++11)
isless (C++11)
islessequal (C++11)
islessgreater (C++11)
isunordered (C++11)

Macro constants

HUGE_VALFHUGE_VALHUGE_VALL (C++11)(C++11)
INFINITY (C++11)
NAN (C++11)
math_errhandlingMATH_ERRNOMATH_ERREXCEPT (C++11)

FP_NORMALFP_SUBNORMALFP_ZEROFP_INFINITEFP_NAN

(C++11)(C++11)(C++11)(C++11)(C++11)

Defined in header `<cmath>`
	(1)
float pow ( float base, float exp );
float powf( float base, float exp );			(since 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 );				(since C++11)
float pow ( float base, int iexp );			(4)	(until C++11)
double pow ( double base, int iexp );			(5)	(until C++11)
long double pow ( long double base, int iexp );			(6)	(until C++11)
Promoted pow ( Arithmetic1 base, Arithmetic2 exp );			(7)	(since C++11)

1-6) Computes the value of base raised to the power exp or iexp.

7) A set of overloads or a function template for all combinations of arguments of arithmetic type not covered by 1-3). If any argument has integral type, it is cast to double. If any argument is long double, then the return type Promoted is also long double, otherwise the return type is always double.

Parameters

base	-	base as a value of floating-point or integral type
exp	-	exponent as a value of floating-point or integral type
iexp	-	exponent as integer value

Return value

If no errors occur, base raised to the power of exp (or iexp) ( $base exp$ ), 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 even integer
pow(-∞, exp) returns -∞ if exp is a positive odd integer
pow(-∞, exp) returns +∞ if exp is a positive non-integer or 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

pow(float, int) returns float until C++11 (per overload 4) but returns double since C++11 (per overload 7)

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

Example

Run this code

#include <iostream>
#include <cmath>
#include <cerrno>
#include <cfenv>
#include <cstring>
 
#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

Language
Standard Library Headers
Freestanding and hosted implementations
Named requirements
Language support library
Concepts library (C++20)
Diagnostics library
Utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Input/output library
Localizations library
Regular expressions library (C++11)
Atomic operations library (C++11)
Thread support library (C++11)
Filesystem library (C++17)
Technical Specifications

Common mathematical functions
Special mathematical functions
Floating-point environment (C++11)
Complex numbers
Numeric arrays
Pseudo-random number generation
Compile-time rational arithmetic (C++11)
Numeric algorithms
gcd (C++17)
lcm (C++17)
Interpolations
midpoint (C++20)
lerp (C++20)
Generic numeric operations
iota (C++11)
accumulate
inner_product
adjacent_difference
partial_sum
reduce (C++17)
transform_reduce (C++17)
inclusive_scan (C++17)
exclusive_scan (C++17)
transform_inclusive_scan (C++17)
transform_exclusive_scan (C++17)
Bit operations
bit_cast (C++20)
ispow2 (C++20)
ceil2 (C++20)
floor2 (C++20)
log2p1 (C++20)