## Name

pow, powf, powl — power functions

## Synopsis

```#include <math.h>
```
 ```double pow(``` double x, double y`)`;

 ```float powf(``` float x, float y`)`;

 ```long double powl(``` long double x, long double y`)`; Note
Feature Test Macro Requirements for glibc (see feature_test_macros(7)):
`powf`(), `powl`():
`_BSD_SOURCE` || `_SVID_SOURCE` || `_XOPEN_SOURCE` >= 600 || `_ISOC99_SOURCE` || `_POSIX_C_SOURCE` >= 200112L;
or cc `-std=c99`
Note Link with `−lm`.

## DESCRIPTION

The `pow`() function returns the value of `x` raised to the power of `y`.

## RETURN VALUE

On success, these functions return the value of `x` to the power of `y`.

If `x` is a finite value less than 0, and `y` is a finite noninteger, a domain error occurs, and a NaN is returned.

If the result overflows, a range error occurs, and the functions return `HUGE_VAL`, `HUGE_VALF`, or `HUGE_VALL`, respectively, with the mathematically correct sign.

If result underflows, and is not representable, a range error occurs, and 0.0 is returned.

Except as specified below, if `x` or `y` is a NaN, the result is a NaN.

If `x` is +1, the result is 1.0 (even if `y` is a NaN).

If `y` is 0, the result is 1.0 (even if `x` is a NaN).

If `x` is +0 (−0), and `y` is an odd integer greater than 0, the result is +0 (−0).

If `x` is 0, and `y` greater than 0 and not an odd integer, the result is +0.

If `x` is −1, and `y` is positive infinity or negative infinity, the result is 1.0.

If the absolute value of `x` is less than 1, and `y` is negative infinity, the result is positive infinity.

If the absolute value of `x` is greater than 1, and `y` is negative infinity, the result is +0.

If the absolute value of `x` is less than 1, and `y` is positive infinity, the result is +0.

If the absolute value of `x` is greater than 1, and `y` is positive infinity, the result is positive infinity.

If `x` is negative infinity, and `y` is an odd integer less than 0, the result is −0.

If `x` is negative infinity, and `y` less than 0 and not an odd integer, the result is +0.

If `x` is negative infinity, and `y` is an odd integer greater than 0, the result is negative infinity.

If `x` is negative infinity, and `y` greater than 0 and not an odd integer, the result is positive infinity.

If `x` is positive infinity, and `y` less than 0, the result is +0.

If `x` is positive infinity, and `y` greater than 0, the result is positive infinity.

If `x` is +0 or −0, and `y` is an odd integer less than 0, a pole error occurs and `HUGE_VAL`, `HUGE_VALF`, or `HUGE_VALL`, is returned, with the same sign as `x`.

If `x` is +0 or −0, and `y` is less than 0 and not an odd integer, a pole error occurs and +`HUGE_VAL`, +`HUGE_VALF`, or +`HUGE_VALL`, is returned.

## ERRORS

See math_error(7) for information on how to determine whether an error has occurred when calling these functions.

The following errors can occur:

Domain error: `x` is negative, and `y` is a finite noninteger

`errno` is set to EDOM. An invalid floating-point exception (`FE_INVALID`) is raised.

Pole error: `x` is zero, and `y` is negative

`errno` is set to ERANGE (but see BUGS). A divide-by-zero floating-point exception (`FE_DIVBYZERO`) is raised.

Range error: the result overflows

`errno` is set to ERANGE. An overflow floating-point exception (`FE_OVERFLOW`) is raised.

Range error: the result underflows

`errno` is set to ERANGE. An underflow floating-point exception (`FE_UNDERFLOW`) is raised.

## CONFORMING TO

C99, POSIX.1-2001. The variant returning double also conforms to SVr4, 4.3BSD, C89.

## BUGS

In glibc 2.9 and earlier, when a pole error occurs, `errno` is set to EDOM instead of the POSIX-mandated ERANGE. Since version 2.10, glibc does the right thing.

If `x` is negative, then large negative or positive `y` values yield a NaN as the function result, with `errno` set to EDOM, and an invalid (`FE_INVALID`) floating-point exception. For example, with `pow`(), one sees this behavior when the absolute value of `y` is greater than about 9.223373e18.

In version 2.3.2 and earlier, when an overflow or underflow error occurs, glibc's `pow`() generates a bogus invalid floating-point exception (`FE_INVALID`) in addition to the overflow or underflow exception.

This page is part of release 3.52 of the Linux `man-pages` project. A description of the project, and information about reporting bugs, can be found at http://www.kernel.org/doc/man−pages/.