# pow

## NAME



           pow, powf, powl - power functions
    


## LIBRARY



           Math library (_libm_ , _-lm_)
    


## 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_**);**
    
       Feature Test Macro Requirements for glibc (see
       feature_test_macros(7)):
    
           **powf**(), **powl**():
               _ISOC99_SOURCE || _POSIX_C_SOURCE >= 200112L
                   || /* Since glibc 2.19: */ _DEFAULT_SOURCE
                   || /* glibc <= 2.19: */ _BSD_SOURCE || _SVID_SOURCE
    


## DESCRIPTION



           These functions return 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 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 with the appropriate sign is returned.
    
           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.
    
           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 _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 a finite value less than 0, and _y_ is a finite noninteger,
           a domain error occurs, and a NaN is returned.
    
           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.
    
           Except as specified above, if _x_ or _y_ is a NaN, the result is a
           NaN.
    


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


## ATTRIBUTES



           For an explanation of the terms used in this section, see
           attributes(7).
           ┌──────────────────────────────────────┬───────────────┬─────────┐
           │ **Interface** │ **Attribute** │ **Value** │
           ├──────────────────────────────────────┼───────────────┼─────────┤
           │ **pow**(), **powf**(), **powl**()                │ Thread safety │ MT-Safe │
           └──────────────────────────────────────┴───────────────┴─────────┘
    


## STANDARDS



           C11, POSIX.1-2008.
    


## BUGS



       **Historical bugs (now fixed)**
           Before glibc 2.28, on some architectures (e.g., x86-64) **pow**() may
           be more than 10,000 times slower for some inputs than for other
           nearby inputs.  This affects only **pow**(), and not **powf**() nor
           **powl**().  This problem was fixed in glibc 2.28.
    
           A number of bugs in the glibc implementation of **pow**() were fixed
           in glibc 2.16.
    
           In glibc 2.9 and earlier, when a pole error occurs, _errno_ is set
           to **EDOM** instead of the POSIX-mandated **ERANGE**.  Since glibc 2.10,
           glibc does the right thing.
    
           In glibc 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.
    


* * *